source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.cpp @ 3117

Revision 3117, 6.6 KB checked in by mattausch, 16 years ago (diff)

strange errors
Line 
1#include "RenderState.h"
2#include "Geometry.h"
3#include "Material.h"
4#include "ShaderProgram.h"
5#include "Texture.h"
6#include "ShaderManager.h"
7
8
9using namespace std;
10
11
12namespace CHCDemoEngine
13{
14
15
16/////////////////
17
18RenderState::RenderState():
19mRenderTechnique(0),
20mUseAlphaToCoverage(true),
21mLockCullFaceEnabled(false),
22mCurrentVboId(-1),
23mCurrentTexId(0),
24mCullFaceEnabled(true),
25mAlphaTestEnabled(false),
26mTexturesEnabled(false),
27mCurrentVertexProgram(NULL),
28mCurrentFragmentProgram(NULL),
29mLightingEnabled(true),
30mColorWriteEnabled(true),
31mDepthWriteEnabled(true),
32mCurrentTechnique(NULL)
33{
34        SetMode(RENDER);
35       
36        glEnable(GL_CULL_FACE);
37        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
38        glDisable(GL_ALPHA_TEST);
39        glDisable(GL_TEXTURE_2D);
40        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
41        glEnable(GL_LIGHTING);
42        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
43        glDepthMask(GL_TRUE);
44}
45
46
47void RenderState::Reset()
48{
49        SetMode(RENDER);
50
51        mCurrentVboId = -1;
52        mCurrentTexId = 0;
53
54        mCullFaceEnabled = true;
55        mAlphaTestEnabled = false;
56        mTexturesEnabled = false;
57
58        mCurrentVertexProgram = NULL;
59        mCurrentFragmentProgram = NULL;
60
61        glEnable(GL_CULL_FACE);
62
63        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
64        glDisable(GL_ALPHA_TEST);
65
66        glDisable(GL_TEXTURE_2D);
67        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
68
69        ShaderManager::GetSingleton()->DisableFragmentProfile();
70        ShaderManager::GetSingleton()->DisableVertexProfile();
71
72        mFragmentProgramEnabled = false;
73        mVertexProgramEnabled = false;
74
75        mLightingEnabled = true;
76        glEnable(GL_LIGHTING);
77
78        mColorWriteEnabled = true;
79        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
80
81        mDepthWriteEnabled = true;
82        glDepthMask(GL_TRUE);
83
84        mCurrentTechnique = NULL;
85}
86
87
88static Technique GetDummyTechnique()
89{
90        Technique tech;
91        tech.Init();
92
93        tech.SetColorWriteEnabled(true);
94        tech.SetLightingEnabled(true);
95        tech.SetDepthWriteEnabled(false);
96        //tech.SetCullFaceEnabled(false);
97
98        return tech;
99}
100
101/** A special technique for occlusion queries. This material
102        has color write, depth write, and lighting turned off
103*/
104static Technique GetQueryTechnique()
105{
106        Technique tech;
107        tech.Init();
108
109        tech.SetColorWriteEnabled(false);
110        tech.SetLightingEnabled(false);
111        tech.SetDepthWriteEnabled(false);
112        //tech.SetCullFaceEnabled(false);
113
114        return tech;
115}
116
117
118bool RenderState::SetMode(Mode mode)
119{
120        ///////////
121        //-- just change the mode when necessary
122
123        if (mode == mMode) return false;
124
125        mMode = mode;
126
127        if (mode == QUERY)
128        {
129                /// the query box material
130                static Technique queryTech = GetQueryTechnique();
131                SetState(&queryTech);
132        }
133
134        return true;
135}
136
137       
138void RenderState::SetState(Technique *tech, SceneEntity *ent)
139{
140        //if (mCurrentTechnique == tech) return;
141        mCurrentTechnique = tech;
142
143        Texture * const tex = tech->GetTexture();
144
145        const bool texturing = (tex != NULL);
146        const bool alphaTest = tech->IsAlphaTestEnabled();
147        const bool cullFace = tech->IsCullFaceEnabled();
148        const bool lighting = tech->IsLightingEnabled();
149        const bool colorWrite = tech->IsColorWriteEnabled();
150        const bool depthWrite = tech->IsDepthWriteEnabled();
151
152
153        if (mDepthWriteEnabled && !depthWrite)
154        {
155                mDepthWriteEnabled = false;
156                glDepthMask(GL_FALSE);
157        }
158        else if (!mDepthWriteEnabled && depthWrite)
159        {
160                mDepthWriteEnabled = true;
161                glDepthMask(GL_TRUE);
162        }
163
164        if (mLightingEnabled && !lighting)
165        {
166                mLightingEnabled = false;
167                glDisable(GL_LIGHTING);
168        }
169        else if (!mLightingEnabled && lighting)
170        {
171                mLightingEnabled = true;
172                glEnable(GL_LIGHTING);
173        }
174
175        if (mColorWriteEnabled && !colorWrite)
176        {
177                mColorWriteEnabled = false;
178                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
179        }
180        else if (!mColorWriteEnabled && colorWrite)
181        {
182                mColorWriteEnabled = true;
183                glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
184        }
185
186        if (!mLockCullFaceEnabled)
187        {
188                if (mCullFaceEnabled && !cullFace)
189                {
190                        mCullFaceEnabled = false;
191                        glDisable(GL_CULL_FACE);
192                }
193                else if (!mCullFaceEnabled && cullFace)
194                {
195                        mCullFaceEnabled = true;
196                        glEnable(GL_CULL_FACE);
197                }
198        }
199        if (mAlphaTestEnabled && !alphaTest)
200        {
201                mAlphaTestEnabled = false;
202               
203                if (mUseAlphaToCoverage)
204                        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
205                else
206                        glDisable(GL_ALPHA_TEST);
207        }
208        else if (!mAlphaTestEnabled && alphaTest)
209        {
210                mAlphaTestEnabled = true;
211               
212                if (mUseAlphaToCoverage)
213                        glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
214                else
215                        glEnable(GL_ALPHA_TEST);
216        }
217
218        if (mTexturesEnabled && !texturing)
219        {
220                mTexturesEnabled = false;
221
222                //if (!tech->GetFragmentProgram())
223                        glDisable(GL_TEXTURE_2D);
224
225                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
226        }
227        else if (!mTexturesEnabled && texturing)
228        {
229                mTexturesEnabled = true;
230
231                //if (!tech->GetFragmentProgram())
232                        glEnable(GL_TEXTURE_2D);
233
234                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
235        }
236
237
238        //////////////////
239        //-- fragment and vertex programs
240       
241        ShaderProgram *frag = tech->GetFragmentProgram();
242
243        if (frag)
244        {
245                if (!mFragmentProgramEnabled)
246                {
247                        mFragmentProgramEnabled = true;
248                        ShaderManager::GetSingleton()->EnableFragmentProfile();
249                }
250
251                if (frag != mCurrentFragmentProgram)
252                {                       
253                        mCurrentFragmentProgram = frag;
254                        mCurrentFragmentProgram->Bind();                       
255                }
256                       
257                tech->GetFragmentProgramParameters()->UpdateParameters(ent);
258        }
259        else
260        {
261                if (mFragmentProgramEnabled)
262                {
263                        mFragmentProgramEnabled = false;
264                        ShaderManager::GetSingleton()->DisableFragmentProfile();
265                }
266        }
267
268        ShaderProgram *vtx = tech->GetVertexProgram();
269
270        if (vtx)
271        {
272                if (!mVertexProgramEnabled)
273                {
274                        mVertexProgramEnabled = true;
275                        ShaderManager::GetSingleton()->EnableVertexProfile();
276                }
277
278                if (vtx != mCurrentVertexProgram)
279                {
280                        mCurrentVertexProgram = vtx;
281                        mCurrentVertexProgram->Bind();
282                }
283               
284                tech->GetVertexProgramParameters()->UpdateParameters(ent);
285        }
286        else
287        {
288                if (mVertexProgramEnabled)
289                {
290                        mVertexProgramEnabled = false;
291                        ShaderManager::GetSingleton()->DisableVertexProfile();
292                }
293        }
294
295        if (!mFragmentProgramEnabled)
296        {
297                // set texture for fixed function rendering
298                if (tex)
299                {
300                        if (mCurrentTexId != tex->GetId())
301                        {
302                                tex->Bind();
303                                mCurrentTexId = tex->GetId();
304                        }
305                }
306                else
307                {
308                        mCurrentTexId = -1;
309                        glBindTexture(GL_TEXTURE_2D, 0);
310                }
311        }
312}
313
314
315void RenderState::SetUseAlphaToCoverage(bool useAlphaToCoverage)
316{
317        mUseAlphaToCoverage = useAlphaToCoverage;
318}
319
320
321void RenderState::SetRenderTechnique(int t)
322{
323        mRenderTechnique = t;
324}
325
326
327int RenderState::GetRenderTechnique() const
328{
329        return mRenderTechnique;
330}
331
332
333void RenderState::LockCullFaceEnabled(bool lockCull)
334{
335        mLockCullFaceEnabled =  lockCull;
336}
337
338
339
340}
Note: See TracBrowser for help on using the repository browser.