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

Revision 3214, 6.4 KB checked in by mattausch, 16 years ago (diff)

worked on lense flare
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
88/** A special technique for occlusion queries. This material
89        has color write, depth write, and lighting turned off
90*/
91static Technique GetQueryTechnique()
92{
93        Technique tech;
94        tech.Init();
95
96        tech.SetColorWriteEnabled(false);
97        tech.SetLightingEnabled(false);
98        tech.SetDepthWriteEnabled(false);
99        //tech.SetCullFaceEnabled(false);
100
101        return tech;
102}
103
104
105bool RenderState::SetMode(Mode mode)
106{
107        ///////////
108        //-- just change the mode when necessary
109
110        if (mode == mMode) return false;
111
112        mMode = mode;
113
114        if (mode == QUERY)
115        {
116                /// the query box material
117                static Technique queryTech = GetQueryTechnique();
118                SetState(&queryTech);
119
120                glDisableClientState(GL_NORMAL_ARRAY);
121        }
122        else
123        {
124                glEnableClientState(GL_NORMAL_ARRAY);
125        }
126
127        return true;
128}
129
130       
131void RenderState::SetState(Technique *tech, SceneEntity *ent)
132{
133        //if (mCurrentTechnique == tech) return;
134        mCurrentTechnique = tech;
135
136        Texture * const tex = tech->GetTexture();
137
138        const bool texturing = (tex != NULL);
139        const bool alphaTest = tech->IsAlphaTestEnabled();
140        const bool cullFace = tech->IsCullFaceEnabled();
141        const bool lighting = tech->IsLightingEnabled();
142        const bool colorWrite = tech->IsColorWriteEnabled();
143        const bool depthWrite = tech->IsDepthWriteEnabled();
144
145
146        if (mDepthWriteEnabled && !depthWrite)
147        {
148                mDepthWriteEnabled = false;
149                glDepthMask(GL_FALSE);
150        }
151        else if (!mDepthWriteEnabled && depthWrite)
152        {
153                mDepthWriteEnabled = true;
154                glDepthMask(GL_TRUE);
155        }
156
157        if (mLightingEnabled && !lighting)
158        {
159                mLightingEnabled = false;
160                glDisable(GL_LIGHTING);
161        }
162        else if (!mLightingEnabled && lighting)
163        {
164                mLightingEnabled = true;
165                glEnable(GL_LIGHTING);
166        }
167
168        if (mColorWriteEnabled && !colorWrite)
169        {
170                mColorWriteEnabled = false;
171                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
172        }
173        else if (!mColorWriteEnabled && colorWrite)
174        {
175                mColorWriteEnabled = true;
176                glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
177        }
178
179        if (!mLockCullFaceEnabled)
180        {
181                if (mCullFaceEnabled && !cullFace)
182                {
183                        mCullFaceEnabled = false;
184                        glDisable(GL_CULL_FACE);
185                }
186                else if (!mCullFaceEnabled && cullFace)
187                {
188                        mCullFaceEnabled = true;
189                        glEnable(GL_CULL_FACE);
190                }
191        }
192        if (mAlphaTestEnabled && !alphaTest)
193        {
194                mAlphaTestEnabled = false;
195               
196                if (mUseAlphaToCoverage)
197                        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
198                else
199                        glDisable(GL_ALPHA_TEST);
200        }
201        else if (!mAlphaTestEnabled && alphaTest)
202        {
203                mAlphaTestEnabled = true;
204               
205                if (mUseAlphaToCoverage)
206                        glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
207                else
208                        glEnable(GL_ALPHA_TEST);
209        }
210
211        if (mTexturesEnabled && !texturing)
212        {
213                mTexturesEnabled = false;
214                glDisable(GL_TEXTURE_2D);
215
216                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
217        }
218        else if (!mTexturesEnabled && texturing)
219        {
220                mTexturesEnabled = true;
221
222                glEnable(GL_TEXTURE_2D);
223                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
224        }
225
226
227        // set texture for fixed function rendering
228        if (tex)
229        {
230                if (mCurrentTexId != tex->GetId())
231                {
232                        tex->Bind();
233                        mCurrentTexId = tex->GetId();
234                }
235        }
236        else
237        {
238                mCurrentTexId = -1;
239                glBindTexture(GL_TEXTURE_2D, 0);
240        }
241
242
243        //////////////////
244        //-- fragment and vertex programs
245       
246        ShaderProgram *frag = tech->GetFragmentProgram();
247
248        if (frag)
249        {
250                if (!mFragmentProgramEnabled)
251                {
252                        mFragmentProgramEnabled = true;
253                        ShaderManager::GetSingleton()->EnableFragmentProfile();
254                }
255
256                if (frag != mCurrentFragmentProgram)
257                {                       
258                        mCurrentFragmentProgram = frag;
259                        mCurrentFragmentProgram->Bind();                       
260                }
261                       
262                tech->GetFragmentProgramParameters()->UpdateParameters(ent);
263        }
264        else
265        {
266                if (mFragmentProgramEnabled)
267                {
268                        mFragmentProgramEnabled = false;
269                        ShaderManager::GetSingleton()->DisableFragmentProfile();
270                }
271        }
272
273        ShaderProgram *vtx = tech->GetVertexProgram();
274
275        if (vtx)
276        {
277                if (!mVertexProgramEnabled)
278                {
279                        mVertexProgramEnabled = true;
280                        ShaderManager::GetSingleton()->EnableVertexProfile();
281                }
282
283                if (vtx != mCurrentVertexProgram)
284                {
285                        mCurrentVertexProgram = vtx;
286                        mCurrentVertexProgram->Bind();
287                }
288               
289                tech->GetVertexProgramParameters()->UpdateParameters(ent);
290        }
291        else
292        {
293                if (mVertexProgramEnabled)
294                {
295                        mVertexProgramEnabled = false;
296                        ShaderManager::GetSingleton()->DisableVertexProfile();
297                }
298        }
299}
300
301
302void RenderState::SetUseAlphaToCoverage(bool useAlphaToCoverage)
303{
304        mUseAlphaToCoverage = useAlphaToCoverage;
305}
306
307
308void RenderState::SetRenderTechnique(int t)
309{
310        mRenderTechnique = t;
311}
312
313
314int RenderState::GetRenderTechnique() const
315{
316        return mRenderTechnique;
317}
318
319
320void RenderState::LockCullFaceEnabled(bool lockCull)
321{
322        mLockCullFaceEnabled =  lockCull;
323}
324
325
326
327}
Note: See TracBrowser for help on using the repository browser.