SDK 0.2.3

1 files changed, 362 insertions, 360 deletions

diff --git a/Samples/CommonSrc/Render/Render_D3D1X_Device.h b/Samples/CommonSrc/Render/Render_D3D1X_Device.h
index c0edc28..b615e2b 100644
--- a/Samples/CommonSrc/Render/Render_D3D1X_Device.h
+++ b/Samples/CommonSrc/Render/Render_D3D1X_Device.h
@@ -1,360 +1,362 @@
-/************************************************************************************

-

-Filename    :   Render_D3D1X_Device.h

-Content     :   RenderDevice implementation header for D3DX10/11.

-Created     :   September 10, 2012

-Authors     :   Andrew Reisse

-

-Copyright   :   Copyright 2012 Oculus VR, Inc. All Rights reserved.

-

-Licensed under the Apache License, Version 2.0 (the "License");

-you may not use this file except in compliance with the License.

-You may obtain a copy of the License at

-

-http://www.apache.org/licenses/LICENSE-2.0

-

-Unless required by applicable law or agreed to in writing, software

-distributed under the License is distributed on an "AS IS" BASIS,

-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

-See the License for the specific language governing permissions and

-limitations under the License.

-

-************************************************************************************/

-

-// ***** IMPORTANT:

-// This file can be included twice, once with OVR_D3D_VERSION=10 and

-// once with OVR_D3D_VERSION=11.

-

-

-#ifndef OVR_D3D_VERSION

-#error define OVR_D3D_VERSION to 10 or 11

-#endif

-

-#include "Kernel/OVR_String.h"

-#include "Kernel/OVR_Array.h"

-

-#if (OVR_D3D_VERSION == 10 && !defined(_OVR_RENDERER_D3D10)) || \

-    (OVR_D3D_VERSION == 11 && !defined(_OVR_RENDERER_D3D11))

-

-#include "../Render/Render_Device.h"

-

-#include <Windows.h>

-

-#if (OVR_D3D_VERSION == 10)

-#define _OVR_RENDERER_D3D10

-#include <d3d10.h>

-

-namespace OVR { namespace Render { namespace D3D10 {

-

-#else // 11

-

-#define _OVR_RENDERER_D3D11

-#include <d3d11.h>

-

-namespace OVR { namespace Render { namespace D3D11 {

-#endif

-

-class RenderDevice;

-

-#ifdef D3D1x_

-#undef D3D1x_

-#endif

-#ifdef ID3D1x

-#undef ID3D1x

-#endif

-

-#if (OVR_D3D_VERSION == 10)

-typedef ID3D10Device            ID3D1xDevice;

-typedef ID3D10Device            ID3D1xDeviceContext;

-typedef ID3D10RenderTargetView  ID3D1xRenderTargetView;

-typedef ID3D10Texture2D         ID3D1xTexture2D;

-typedef ID3D10ShaderResourceView ID3D1xShaderResourceView;

-typedef ID3D10DepthStencilView  ID3D1xDepthStencilView;

-typedef ID3D10DepthStencilState ID3D1xDepthStencilState;

-typedef ID3D10InputLayout       ID3D1xInputLayout;

-typedef ID3D10Buffer            ID3D1xBuffer;

-typedef ID3D10VertexShader      ID3D1xVertexShader;

-typedef ID3D10PixelShader       ID3D1xPixelShader;

-typedef ID3D10GeometryShader    ID3D1xGeometryShader;

-typedef ID3D10BlendState        ID3D1xBlendState;

-typedef ID3D10RasterizerState   ID3D1xRasterizerState;

-typedef ID3D10SamplerState      ID3D1xSamplerState;

-typedef ID3D10Query             ID3D1xQuery;

-typedef ID3D10Blob              ID3D1xBlob;

-typedef D3D10_VIEWPORT          D3D1x_VIEWPORT;

-typedef D3D10_QUERY_DESC        D3D1x_QUERY_DESC;

-#define D3D1x_(x)               D3D10_##x

-#define ID3D1x(x)               ID3D10##x

-

-#else // D3D 11

-typedef ID3D11Device            ID3D1xDevice;

-typedef ID3D11DeviceContext     ID3D1xDeviceContext;

-typedef ID3D11RenderTargetView  ID3D1xRenderTargetView;

-typedef ID3D11Texture2D         ID3D1xTexture2D;

-typedef ID3D11ShaderResourceView ID3D1xShaderResourceView;

-typedef ID3D11DepthStencilView  ID3D1xDepthStencilView;

-typedef ID3D11DepthStencilState ID3D1xDepthStencilState;

-typedef ID3D11InputLayout       ID3D1xInputLayout;

-typedef ID3D11Buffer            ID3D1xBuffer;

-typedef ID3D10Blob              ID3D1xBlob;

-typedef ID3D11VertexShader      ID3D1xVertexShader;

-typedef ID3D11PixelShader       ID3D1xPixelShader;

-typedef ID3D11GeometryShader    ID3D1xGeometryShader;

-typedef ID3D11BlendState        ID3D1xBlendState;

-typedef ID3D11RasterizerState   ID3D1xRasterizerState;

-typedef ID3D11SamplerState      ID3D1xSamplerState;

-typedef ID3D11Query             ID3D1xQuery;

-typedef D3D11_VIEWPORT          D3D1x_VIEWPORT;

-typedef D3D11_QUERY_DESC        D3D1x_QUERY_DESC;

-#define D3D1x_(x)               D3D11_##x

-#define ID3D1x(x)               ID3D11##x

-#endif

-

-class Buffer;

-

-class ShaderBase : public Render::Shader

-{

-public:

-    RenderDevice*   Ren;

-    unsigned char*  UniformData;

-    int             UniformsSize;

-

-    struct Uniform

-    {

-        String Name;

-        int    Offset, Size;

-    };

-    Array<Uniform> UniformInfo;

-

-    ShaderBase(RenderDevice* r, ShaderStage stage);

-    ~ShaderBase();

-

-    void InitUniforms(ID3D10Blob* s);

-    bool SetUniform(const char* name, int n, const float* v);

-    //virtual bool UseTransposeMatrix() const { return 1; }

-

-    void UpdateBuffer(Buffer* b);

-};

-

-template<Render::ShaderStage SStage, class D3DShaderType>

-class Shader : public ShaderBase

-{

-public:

-    D3DShaderType*  D3DShader;

-

-    Shader(RenderDevice* r, D3DShaderType* s) : ShaderBase(r, SStage), D3DShader(s) {}

-    Shader(RenderDevice* r, ID3D1xBlob* s) : ShaderBase(r, SStage)

-    {

-        Load(s);

-        InitUniforms(s);

-    }

-    ~Shader()

-    {

-        if(D3DShader)

-        {

-            D3DShader->Release();

-        }

-    }

-    bool Load(ID3D1xBlob* shader)

-    {

-        return Load(shader->GetBufferPointer(), shader->GetBufferSize());

-    }

-

-    // These functions have specializations.

-    bool Load(void* shader, size_t size);

-    void Set(PrimitiveType prim) const;

-    void SetUniformBuffer(Render::Buffer* buffers, int i = 0);

-};

-

-typedef Shader<Render::Shader_Vertex, ID3D1xVertexShader> VertexShader;

-typedef Shader<Render::Shader_Geometry, ID3D1xGeometryShader> GeomShader;

-typedef Shader<Render::Shader_Fragment, ID3D1xPixelShader> PixelShader;

-

-

-class Buffer : public Render::Buffer

-{

-public:

-    RenderDevice*     Ren;

-    Ptr<ID3D1xBuffer> D3DBuffer;

-    size_t            Size;

-    int               Use;

-    bool              Dynamic;

-

-public:

-    Buffer(RenderDevice* r) : Ren(r), Size(0), Use(0) {}

-    ~Buffer();

-

-    ID3D1xBuffer* GetBuffer()

-    {

-        return D3DBuffer;

-    }

-

-    virtual size_t GetSize()

-    {

-        return Size;

-    }

-    virtual void*  Map(size_t start, size_t size, int flags = 0);

-    virtual bool   Unmap(void *m);

-    virtual bool   Data(int use, const void* buffer, size_t size);

-};

-

-class Texture : public Render::Texture

-{

-public:

-    RenderDevice*                    Ren;

-    Ptr<ID3D1xTexture2D>            Tex;

-    Ptr<ID3D1xShaderResourceView>   TexSv;

-    Ptr<ID3D1xRenderTargetView>     TexRtv;

-    Ptr<ID3D1xDepthStencilView>     TexDsv;

-    mutable Ptr<ID3D1xSamplerState> Sampler;

-    int                             Width, Height;

-    int                             Samples;

-

-    Texture(RenderDevice* r, int fmt, int w, int h);

-    ~Texture();

-

-    virtual int GetWidth() const

-    {

-        return Width;

-    }

-    virtual int GetHeight() const

-    {

-        return Height;

-    }

-    virtual int GetSamples() const

-    {

-        return Samples;

-    }

-

-    virtual void SetSampleMode(int sm);

-

-    virtual void Set(int slot, Render::ShaderStage stage = Render::Shader_Fragment) const;

-};

-

-class RenderDevice : public Render::RenderDevice

-{

-public:

-    Ptr<IDXGIFactory>           DXGIFactory;

-    HWND                        Window;

-

-    Ptr<ID3D1xDevice>           Device;

-    Ptr<ID3D1xDeviceContext>    Context;

-    Ptr<IDXGISwapChain>         SwapChain;

-    Ptr<IDXGIAdapter>           Adapter;

-    Ptr<IDXGIOutput>            FullscreenOutput;

-    int                         FSDesktopX, FSDesktopY;

-    int                         PreFullscreenX, PreFullscreenY, PreFullscreenW, PreFullscreenH;

-

-    Ptr<ID3D1xTexture2D>        BackBuffer;

-    Ptr<ID3D1xRenderTargetView> BackBufferRT;

-    Ptr<Texture>                CurRenderTarget;

-    Ptr<Texture>                CurDepthBuffer;

-    Ptr<ID3D1xRasterizerState>  Rasterizer;

-    Ptr<ID3D1xBlendState>       BlendState;

-    int                         NumViewports;

-    D3D1x_VIEWPORT              Viewports[2];

-

-    Ptr<ID3D1xDepthStencilState> DepthStates[1 + 2 * Compare_Count];

-    Ptr<ID3D1xDepthStencilState> CurDepthState;

-    Ptr<ID3D1xInputLayout>      ModelVertexIL;

-

-    Ptr<ID3D1xSamplerState>     SamplerStates[Sample_Count];

-

-    struct StandardUniformData

-    {

-        Matrix4f  Proj;

-        Matrix4f  View;

-    }                        StdUniforms;

-    Ptr<Buffer>              UniformBuffers[Shader_Count];

-    int                      MaxTextureSet[Shader_Count];

-

-    Ptr<VertexShader>        VertexShaders[VShader_Count];

-    Ptr<PixelShader>         PixelShaders[FShader_Count];

-    Ptr<GeomShader>          pStereoShaders[Prim_Count];

-    Ptr<Buffer>              CommonUniforms[8];

-    Ptr<ShaderSet>           ExtraShaders;

-    Ptr<ShaderFill>          DefaultFill;

-

-    Ptr<Buffer>              QuadVertexBuffer;

-

-    Array<Ptr<Texture> >     DepthBuffers;

-

-public:

-    RenderDevice(const RendererParams& p, HWND window);

-    ~RenderDevice();

-

-    // Implement static initializer function to create this class.

-    static Render::RenderDevice* CreateDevice(const RendererParams& rp, void* oswnd);

-

-    // if needRecreate == true it will recreate DXGIFactory and Adapter

-    // to get the latest info about monitors (including just connected/

-    // disconnected ones). Note, SwapChain will be released in this case

-    // and it should be recreated.

-    void        UpdateMonitorOutputs(bool needRecreate = false);

-

-    virtual void SetMultipleViewports(int n, const Viewport* vps);

-    virtual void SetWindowSize(int w, int h);

-    virtual bool SetParams(const RendererParams& newParams);

-    //virtual void SetScissor(int x, int y, int w, int h);

-

-    virtual void Present();

-    virtual void ForceFlushGPU();

-

-    virtual bool SetFullscreen(DisplayMode fullscreen);

-	virtual UPInt QueryGPUMemorySize();

-

-    virtual void Clear(float r = 0, float g = 0, float b = 0, float a = 1, float depth = 1);

-    virtual void Rect(float left, float top, float right, float bottom)

-    {

-        OVR_UNUSED4(left, top, right, bottom);

-    }

-

-    virtual Buffer* CreateBuffer();

-    virtual Texture* CreateTexture(int format, int width, int height, const void* data, int mipcount=1);

-    

-    static void GenerateSubresourceData(

-                    unsigned imageWidth, unsigned imageHeight, int format, unsigned imageDimUpperLimit,

-                    const void* rawBytes,

-                    D3D1x_(SUBRESOURCE_DATA)* subresData,

-                    unsigned& largestMipWidth, unsigned& largestMipHeight, unsigned& byteSize, unsigned& effectiveMipCount);

-

-    Texture* GetDepthBuffer(int w, int h, int ms);

-

-    virtual void BeginRendering();

-    virtual void SetRenderTarget(Render::Texture* color,

-                                 Render::Texture* depth = NULL, Render::Texture* stencil = NULL);

-    virtual void SetDepthMode(bool enable, bool write, CompareFunc func = Compare_Less);

-    virtual void SetWorldUniforms(const Matrix4f& proj);

-    virtual void SetCommonUniformBuffer(int i, Render::Buffer* buffer);

-    virtual void SetExtraShaders(ShaderSet* s)

-    {

-        ExtraShaders = s;

-    }

-

-

-    // Overrident to apply proper blend state.

-    virtual void FillRect(float left, float top, float right, float bottom, Color c);

-	virtual void RenderText(const struct Font* font, const char* str, float x, float y, float size, Color c);

-

-    virtual void Render(const Matrix4f& matrix, Model* model);

-    virtual void Render(const Fill* fill, Render::Buffer* vertices, Render::Buffer* indices,

-                        const Matrix4f& matrix, int offset, int count, PrimitiveType prim = Prim_Triangles);

-    virtual void RenderWithAlpha(   const Fill* fill, Render::Buffer* vertices, Render::Buffer* indices,

-                                    const Matrix4f& matrix, int offset, int count, PrimitiveType prim = Prim_Triangles);

-

-    virtual Fill *CreateSimpleFill(int flags = Fill::F_Solid);

-

-    virtual Render::Shader *LoadBuiltinShader(ShaderStage stage, int shader);

-

-    bool RecreateSwapChain();

-    virtual ID3D10Blob* CompileShader(const char* profile, const char* src, const char* mainName = "main");

-    virtual ShaderBase* CreateStereoShader(PrimitiveType prim, Render::Shader* vs);

-

-    ID3D1xSamplerState* GetSamplerState(int sm);

-

-    void SetTexture(Render::ShaderStage stage, int slot, const Texture* t);

-};

-

-}}}

-

-#endif

+/************************************************************************************
+
+Filename    :   Render_D3D1X_Device.h
+Content     :   RenderDevice implementation header for D3DX10/11.
+Created     :   September 10, 2012
+Authors     :   Andrew Reisse
+
+Copyright   :   Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+// ***** IMPORTANT:
+// This file can be included twice, once with OVR_D3D_VERSION=10 and
+// once with OVR_D3D_VERSION=11.
+
+
+#ifndef OVR_D3D_VERSION
+#error define OVR_D3D_VERSION to 10 or 11
+#endif
+
+#include "Kernel/OVR_String.h"
+#include "Kernel/OVR_Array.h"
+
+#if (OVR_D3D_VERSION == 10 && !defined(_OVR_RENDERER_D3D10)) || \
+    (OVR_D3D_VERSION == 11 && !defined(_OVR_RENDERER_D3D11))
+
+#include "../Render/Render_Device.h"
+
+#include <Windows.h>
+
+#if (OVR_D3D_VERSION == 10)
+#define _OVR_RENDERER_D3D10
+#include <d3d10.h>
+
+namespace OVR { namespace Render { namespace D3D10 {
+
+#else // 11
+
+#define _OVR_RENDERER_D3D11
+#include <d3d11.h>
+
+namespace OVR { namespace Render { namespace D3D11 {
+#endif
+
+class RenderDevice;
+
+#ifdef D3D1x_
+#undef D3D1x_
+#endif
+#ifdef ID3D1x
+#undef ID3D1x
+#endif
+
+#if (OVR_D3D_VERSION == 10)
+typedef ID3D10Device            ID3D1xDevice;
+typedef ID3D10Device            ID3D1xDeviceContext;
+typedef ID3D10RenderTargetView  ID3D1xRenderTargetView;
+typedef ID3D10Texture2D         ID3D1xTexture2D;
+typedef ID3D10ShaderResourceView ID3D1xShaderResourceView;
+typedef ID3D10DepthStencilView  ID3D1xDepthStencilView;
+typedef ID3D10DepthStencilState ID3D1xDepthStencilState;
+typedef ID3D10InputLayout       ID3D1xInputLayout;
+typedef ID3D10Buffer            ID3D1xBuffer;
+typedef ID3D10VertexShader      ID3D1xVertexShader;
+typedef ID3D10PixelShader       ID3D1xPixelShader;
+typedef ID3D10GeometryShader    ID3D1xGeometryShader;
+typedef ID3D10BlendState        ID3D1xBlendState;
+typedef ID3D10RasterizerState   ID3D1xRasterizerState;
+typedef ID3D10SamplerState      ID3D1xSamplerState;
+typedef ID3D10Query             ID3D1xQuery;
+typedef ID3D10Blob              ID3D1xBlob;
+typedef D3D10_VIEWPORT          D3D1x_VIEWPORT;
+typedef D3D10_QUERY_DESC        D3D1x_QUERY_DESC;
+#define D3D1x_(x)               D3D10_##x
+#define ID3D1x(x)               ID3D10##x
+
+#else // D3D 11
+typedef ID3D11Device            ID3D1xDevice;
+typedef ID3D11DeviceContext     ID3D1xDeviceContext;
+typedef ID3D11RenderTargetView  ID3D1xRenderTargetView;
+typedef ID3D11Texture2D         ID3D1xTexture2D;
+typedef ID3D11ShaderResourceView ID3D1xShaderResourceView;
+typedef ID3D11DepthStencilView  ID3D1xDepthStencilView;
+typedef ID3D11DepthStencilState ID3D1xDepthStencilState;
+typedef ID3D11InputLayout       ID3D1xInputLayout;
+typedef ID3D11Buffer            ID3D1xBuffer;
+typedef ID3D10Blob              ID3D1xBlob;
+typedef ID3D11VertexShader      ID3D1xVertexShader;
+typedef ID3D11PixelShader       ID3D1xPixelShader;
+typedef ID3D11GeometryShader    ID3D1xGeometryShader;
+typedef ID3D11BlendState        ID3D1xBlendState;
+typedef ID3D11RasterizerState   ID3D1xRasterizerState;
+typedef ID3D11SamplerState      ID3D1xSamplerState;
+typedef ID3D11Query             ID3D1xQuery;
+typedef D3D11_VIEWPORT          D3D1x_VIEWPORT;
+typedef D3D11_QUERY_DESC        D3D1x_QUERY_DESC;
+#define D3D1x_(x)               D3D11_##x
+#define ID3D1x(x)               ID3D11##x
+#endif
+
+class Buffer;
+
+class ShaderBase : public Render::Shader
+{
+public:
+    RenderDevice*   Ren;
+    unsigned char*  UniformData;
+    int             UniformsSize;
+
+    struct Uniform
+    {
+        String Name;
+        int    Offset, Size;
+    };
+    Array<Uniform> UniformInfo;
+
+    ShaderBase(RenderDevice* r, ShaderStage stage);
+    ~ShaderBase();
+
+    void InitUniforms(ID3D10Blob* s);
+    bool SetUniform(const char* name, int n, const float* v);
+    //virtual bool UseTransposeMatrix() const { return 1; }
+
+    void UpdateBuffer(Buffer* b);
+};
+
+template<Render::ShaderStage SStage, class D3DShaderType>
+class Shader : public ShaderBase
+{
+public:
+    D3DShaderType*  D3DShader;
+
+    Shader(RenderDevice* r, D3DShaderType* s) : ShaderBase(r, SStage), D3DShader(s) {}
+    Shader(RenderDevice* r, ID3D1xBlob* s) : ShaderBase(r, SStage)
+    {
+        Load(s);
+        InitUniforms(s);
+    }
+    ~Shader()
+    {
+        if(D3DShader)
+        {
+            D3DShader->Release();
+        }
+    }
+    bool Load(ID3D1xBlob* shader)
+    {
+        return Load(shader->GetBufferPointer(), shader->GetBufferSize());
+    }
+
+    // These functions have specializations.
+    bool Load(void* shader, size_t size);
+    void Set(PrimitiveType prim) const;
+    void SetUniformBuffer(Render::Buffer* buffers, int i = 0);
+};
+
+typedef Shader<Render::Shader_Vertex, ID3D1xVertexShader> VertexShader;
+typedef Shader<Render::Shader_Geometry, ID3D1xGeometryShader> GeomShader;
+typedef Shader<Render::Shader_Fragment, ID3D1xPixelShader> PixelShader;
+
+
+class Buffer : public Render::Buffer
+{
+public:
+    RenderDevice*     Ren;
+    Ptr<ID3D1xBuffer> D3DBuffer;
+    size_t            Size;
+    int               Use;
+    bool              Dynamic;
+
+public:
+    Buffer(RenderDevice* r) : Ren(r), Size(0), Use(0) {}
+    ~Buffer();
+
+    ID3D1xBuffer* GetBuffer()
+    {
+        return D3DBuffer;
+    }
+
+    virtual size_t GetSize()
+    {
+        return Size;
+    }
+    virtual void*  Map(size_t start, size_t size, int flags = 0);
+    virtual bool   Unmap(void *m);
+    virtual bool   Data(int use, const void* buffer, size_t size);
+};
+
+class Texture : public Render::Texture
+{
+public:
+    RenderDevice*                    Ren;
+    Ptr<ID3D1xTexture2D>            Tex;
+    Ptr<ID3D1xShaderResourceView>   TexSv;
+    Ptr<ID3D1xRenderTargetView>     TexRtv;
+    Ptr<ID3D1xDepthStencilView>     TexDsv;
+    mutable Ptr<ID3D1xSamplerState> Sampler;
+    int                             Width, Height;
+    int                             Samples;
+
+    Texture(RenderDevice* r, int fmt, int w, int h);
+    ~Texture();
+
+    virtual int GetWidth() const
+    {
+        return Width;
+    }
+    virtual int GetHeight() const
+    {
+        return Height;
+    }
+    virtual int GetSamples() const
+    {
+        return Samples;
+    }
+
+    virtual void SetSampleMode(int sm);
+
+    virtual void Set(int slot, Render::ShaderStage stage = Render::Shader_Fragment) const;
+};
+
+class RenderDevice : public Render::RenderDevice
+{
+public:
+    Ptr<IDXGIFactory>           DXGIFactory;
+    HWND                        Window;
+
+    Ptr<ID3D1xDevice>           Device;
+    Ptr<ID3D1xDeviceContext>    Context;
+    Ptr<IDXGISwapChain>         SwapChain;
+    Ptr<IDXGIAdapter>           Adapter;
+    Ptr<IDXGIOutput>            FullscreenOutput;
+    int                         FSDesktopX, FSDesktopY;
+    int                         PreFullscreenX, PreFullscreenY, PreFullscreenW, PreFullscreenH;
+
+    Ptr<ID3D1xTexture2D>        BackBuffer;
+    Ptr<ID3D1xRenderTargetView> BackBufferRT;
+    Ptr<Texture>                CurRenderTarget;
+    Ptr<Texture>                CurDepthBuffer;
+    Ptr<ID3D1xRasterizerState>  Rasterizer;
+    Ptr<ID3D1xBlendState>       BlendState;
+    int                         NumViewports;
+    D3D1x_VIEWPORT              Viewports[2];
+
+    Ptr<ID3D1xDepthStencilState> DepthStates[1 + 2 * Compare_Count];
+    Ptr<ID3D1xDepthStencilState> CurDepthState;
+    Ptr<ID3D1xInputLayout>      ModelVertexIL;
+
+    Ptr<ID3D1xSamplerState>     SamplerStates[Sample_Count];
+
+    struct StandardUniformData
+    {
+        Matrix4f  Proj;
+        Matrix4f  View;
+    }                        StdUniforms;
+    Ptr<Buffer>              UniformBuffers[Shader_Count];
+    int                      MaxTextureSet[Shader_Count];
+
+    Ptr<VertexShader>        VertexShaders[VShader_Count];
+    Ptr<PixelShader>         PixelShaders[FShader_Count];
+    Ptr<GeomShader>          pStereoShaders[Prim_Count];
+    Ptr<Buffer>              CommonUniforms[8];
+    Ptr<ShaderSet>           ExtraShaders;
+    Ptr<ShaderFill>          DefaultFill;
+
+    Ptr<Buffer>              QuadVertexBuffer;
+
+    Array<Ptr<Texture> >     DepthBuffers;
+
+public:
+    RenderDevice(const RendererParams& p, HWND window);
+    ~RenderDevice();
+
+    // Implement static initializer function to create this class.
+    static Render::RenderDevice* CreateDevice(const RendererParams& rp, void* oswnd);
+
+    // if needRecreate == true it will recreate DXGIFactory and Adapter
+    // to get the latest info about monitors (including just connected/
+    // disconnected ones). Note, SwapChain will be released in this case
+    // and it should be recreated.
+    void        UpdateMonitorOutputs(bool needRecreate = false);
+
+    virtual void SetMultipleViewports(int n, const Viewport* vps);
+    virtual void SetWindowSize(int w, int h);
+    virtual bool SetParams(const RendererParams& newParams);
+    //virtual void SetScissor(int x, int y, int w, int h);
+
+    virtual void Present();
+    virtual void ForceFlushGPU();
+
+    virtual bool SetFullscreen(DisplayMode fullscreen);
+	virtual UPInt QueryGPUMemorySize();
+
+    virtual void Clear(float r = 0, float g = 0, float b = 0, float a = 1, float depth = 1);
+    virtual void Rect(float left, float top, float right, float bottom)
+    {
+        OVR_UNUSED4(left, top, right, bottom);
+    }
+
+    virtual Buffer* CreateBuffer();
+    virtual Texture* CreateTexture(int format, int width, int height, const void* data, int mipcount=1);
+    
+    static void GenerateSubresourceData(
+                    unsigned imageWidth, unsigned imageHeight, int format, unsigned imageDimUpperLimit,
+                    const void* rawBytes,
+                    D3D1x_(SUBRESOURCE_DATA)* subresData,
+                    unsigned& largestMipWidth, unsigned& largestMipHeight, unsigned& byteSize, unsigned& effectiveMipCount);
+
+    Texture* GetDepthBuffer(int w, int h, int ms);
+
+    virtual void BeginRendering();
+    virtual void SetRenderTarget(Render::Texture* color,
+                                 Render::Texture* depth = NULL, Render::Texture* stencil = NULL);
+    virtual void SetDepthMode(bool enable, bool write, CompareFunc func = Compare_Less);
+    virtual void SetWorldUniforms(const Matrix4f& proj);
+    virtual void SetCommonUniformBuffer(int i, Render::Buffer* buffer);
+    virtual void SetExtraShaders(ShaderSet* s)
+    {
+        ExtraShaders = s;
+    }
+
+
+    // Overrident to apply proper blend state.
+    virtual void FillRect(float left, float top, float right, float bottom, Color c);
+    virtual void FillGradientRect(float left, float top, float right, float bottom, Color col_top, Color col_btm);
+	virtual void RenderText(const struct Font* font, const char* str, float x, float y, float size, Color c);
+    virtual void RenderImage(float left, float top, float right, float bottom, ShaderFill* image);
+
+    virtual void Render(const Matrix4f& matrix, Model* model);
+    virtual void Render(const Fill* fill, Render::Buffer* vertices, Render::Buffer* indices,
+                        const Matrix4f& matrix, int offset, int count, PrimitiveType prim = Prim_Triangles);
+    virtual void RenderWithAlpha(   const Fill* fill, Render::Buffer* vertices, Render::Buffer* indices,
+                                    const Matrix4f& matrix, int offset, int count, PrimitiveType prim = Prim_Triangles);
+
+    virtual Fill *CreateSimpleFill(int flags = Fill::F_Solid);
+
+    virtual Render::Shader *LoadBuiltinShader(ShaderStage stage, int shader);
+
+    bool RecreateSwapChain();
+    virtual ID3D10Blob* CompileShader(const char* profile, const char* src, const char* mainName = "main");
+    virtual ShaderBase* CreateStereoShader(PrimitiveType prim, Render::Shader* vs);
+
+    ID3D1xSamplerState* GetSamplerState(int sm);
+
+    void SetTexture(Render::ShaderStage stage, int slot, const Texture* t);
+};
+
+}}}
+
+#endif