1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of NVIDIA CORPORATION nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.
#ifndef OGL_RENDERER_H
#define OGL_RENDERER_H
#include <RendererConfig.h>
#if defined(RENDERER_ENABLE_OPENGL)
#include <GLIncludes.h>
#if defined(RENDERER_ENABLE_CG)
#include <Cg/cg.h>
#include <Cg/cgGL.h>
#endif
#include <Renderer.h>
namespace SampleFramework {
class SamplePlatform;
}
namespace SampleRenderer
{
#if defined(RENDERER_ENABLE_CG)
void setColorParameter(CGparameter param, const RendererColor &color);
void setFloat4Parameter(CGparameter param, float* values);
#endif
class OGLRendererMaterial;
void PxToGL(GLfloat *gl44, const physx::PxMat44 &mat);
void RenToGL(GLfloat *gl44, const RendererProjection &proj);
class OGLRenderer : public Renderer
{
public:
OGLRenderer(const RendererDesc &desc, const char* assetDir);
virtual ~OGLRenderer(void);
#if defined(RENDERER_ENABLE_CG)
class CGEnvironment
{
public:
CGparameter modelMatrix;
CGparameter viewMatrix;
CGparameter projMatrix;
CGparameter modelViewMatrix;
CGparameter modelViewProjMatrix;
CGparameter boneMatrices;
CGparameter fogColorAndDistance;
CGparameter eyePosition;
CGparameter eyeDirection;
CGparameter ambientColor;
CGparameter lightColor;
CGparameter lightIntensity;
CGparameter lightDirection;
CGparameter lightPosition;
CGparameter lightInnerRadius;
CGparameter lightOuterRadius;
CGparameter lightInnerCone;
CGparameter lightOuterCone;
public:
CGEnvironment(void);
CGEnvironment(CGcontext cgContext);
};
CGcontext getCGContext(void) { return m_cgContext; }
CGEnvironment &getCGEnvironment(void) { return m_cgEnv; }
const CGEnvironment &getCGEnvironment(void) const { return m_cgEnv; }
#endif
const physx::PxMat44 &getViewMatrix(void) const { return m_viewMatrix; }
void setCurrentMaterial(const OGLRendererMaterial *cm) { m_currMaterial = cm; }
const OGLRendererMaterial *getCurrentMaterial(void) { return m_currMaterial; }
private:
bool begin(void);
void end(void);
void checkResize(void);
public:
// clears the offscreen buffers.
virtual void clearBuffers(void);
// presents the current color buffer to the screen.
// returns true on device reset and if buffers need to be rewritten.
virtual bool swapBuffers(void);
// get the device pointer (void * abstraction)
virtual void *getDevice() { return static_cast<void*>(getCGContext()); }
virtual bool captureScreen(const char* ) { PX_ASSERT("not supported"); return false; }
// gets a handle to the current frame's data, in bitmap format
// note: subsequent calls will invalidate any previously returned data
// return true on successful screenshot capture
virtual bool captureScreen(PxU32 &width, PxU32& height, PxU32& sizeInBytes, const void*& screenshotData);
// get the window size
void getWindowSize(PxU32 &width, PxU32 &height) const;
virtual RendererVertexBuffer *createVertexBuffer( const RendererVertexBufferDesc &desc);
virtual RendererIndexBuffer *createIndexBuffer( const RendererIndexBufferDesc &desc);
virtual RendererInstanceBuffer *createInstanceBuffer(const RendererInstanceBufferDesc &desc);
virtual RendererTexture2D *createTexture2D( const RendererTexture2DDesc &desc);
virtual RendererTexture3D *createTexture3D( const RendererTexture3DDesc &desc);
virtual RendererTarget *createTarget( const RendererTargetDesc &desc);
virtual RendererMaterial *createMaterial( const RendererMaterialDesc &desc);
virtual RendererMesh *createMesh( const RendererMeshDesc &desc);
virtual RendererLight *createLight( const RendererLightDesc &desc);
virtual void setVsync(bool on);
private:
virtual void bindViewProj(const physx::PxMat44 &inveye, const RendererProjection &proj);
virtual void bindAmbientState(const RendererColor &ambientColor);
virtual void bindFogState(const RendererColor &fogColor, float fogDistance);
virtual void bindDeferredState(void);
virtual void bindMeshContext(const RendererMeshContext &context);
virtual void beginMultiPass(void);
virtual void endMultiPass(void);
virtual void beginTransparentMultiPass(void);
virtual void endTransparentMultiPass(void);
virtual void renderDeferredLight(const RendererLight &light);
virtual PxU32 convertColor(const RendererColor& color) const;
virtual bool isOk(void) const;
virtual void setupTextRenderStates();
virtual void resetTextRenderStates();
virtual void renderTextBuffer(const void* vertices, PxU32 nbVerts, const PxU16* indices, PxU32 nbIndices, RendererMaterial* material);
virtual void renderLines2D(const void* vertices, PxU32 nbVerts);
virtual void setupScreenquadRenderStates();
virtual void resetScreenquadRenderStates();
private:
SampleFramework::SamplePlatform* m_platform;
#if defined(RENDERER_ENABLE_CG)
CGcontext m_cgContext;
CGEnvironment m_cgEnv;
#endif
const OGLRendererMaterial *m_currMaterial;
PxU32 m_displayWidth;
PxU32 m_displayHeight;
std::vector<GLubyte> m_displayData;
physx::PxMat44 m_viewMatrix;
};
} // namespace SampleRenderer
#endif // #if defined(RENDERER_ENABLE_OPENGL)
#endif
|