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

Revision 3047, 5.8 KB checked in by mattausch, 16 years ago (diff)

adding special technique for depth pass (not working yet)
Line 
1#include "RenderState.h"
2#include "Geometry.h"
3#include "Material.h"
4#include "ShaderProgram.h"
5#include "Texture.h"
6#include "ResourceManager.h"
7
8
9using namespace std;
10
11
12namespace CHCDemoEngine
13{
14
15
16/////////////////
17
18RenderState::RenderState():
19mRenderType(FORWARD),
20mUseAlphaToCoverage(true),
21mLockCullFaceEnabled(false)
22{
23        SetMode(RENDER);
24
25        mCurrentVboId = -1;
26        mCurrentTexId = 0;
27
28        mCullFaceEnabled = true;
29        mAlphaTestEnabled = false;
30        mTexturesEnabled = false;
31
32        mCurrentVertexProgram = NULL;
33        mCurrentFragmentProgram = NULL;
34
35        glEnable(GL_CULL_FACE);
36
37        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
38        glDisable(GL_ALPHA_TEST);
39
40        glDisable(GL_TEXTURE_2D);
41        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
42}
43
44
45void RenderState::Reset()
46{
47        SetMode(RENDER);
48
49        mCurrentVboId = -1;
50        mCurrentTexId = 0;
51
52        mCullFaceEnabled = true;
53        mAlphaTestEnabled = false;
54        mTexturesEnabled = false;
55
56        mCurrentVertexProgram = NULL;
57        mCurrentFragmentProgram = NULL;
58
59        glEnable(GL_CULL_FACE);
60
61        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
62        glDisable(GL_ALPHA_TEST);
63
64        glDisable(GL_TEXTURE_2D);
65        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
66
67        ResourceManager::GetSingleton()->DisableFragmentProfile();
68        ResourceManager::GetSingleton()->DisableVertexProfile();
69
70        mFragmentProgramEnabled = false;
71        mVertexProgramEnabled = false;
72}
73
74// q matt: is this function really necessary or would it be better
75// to just create a query material and use the setstate function?
76bool RenderState::SetMode(Mode mode)
77{
78        ///////////
79        //-- just change the modewhen necessary
80
81        if (mode == mMode) return false;
82
83        mMode = mode;
84
85        if (mode == QUERY)
86        {
87                if (mRenderType != DEPTH_PASS)
88                {
89                        glDisable(GL_LIGHTING);
90                        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
91                }
92
93                if (mFragmentProgramEnabled)
94                {
95                        ResourceManager::GetSingleton()->DisableFragmentProfile();
96                }
97                       
98                if (mVertexProgramEnabled)
99                {
100                        ResourceManager::GetSingleton()->DisableVertexProfile();
101                }
102               
103                glDepthMask(GL_FALSE);
104
105                static Technique defaultTech;
106                SetState(&defaultTech);
107        }
108        else // mode returns to render
109        {
110                /////////////
111                //-- restore render state
112
113                if (mRenderType != DEPTH_PASS)
114                {
115                        glEnable(GL_LIGHTING);
116                        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
117                }
118               
119                if (mFragmentProgramEnabled)
120                {
121                        ResourceManager::GetSingleton()->EnableFragmentProfile();
122                }
123                       
124                if (mVertexProgramEnabled)
125                {
126                        ResourceManager::GetSingleton()->EnableVertexProfile();
127                }
128
129                glDepthMask(GL_TRUE);
130        }
131
132        return true;
133}
134
135       
136void RenderState::SetState(Technique *tech)
137{
138        Texture *tex = tech->GetTexture();
139
140        const bool texturing = (tex != NULL);
141
142        bool alphaTest = tech->IsAlphaTestEnabled();
143        bool cullFace = tech->IsCullFaceEnabled();
144
145        if (!mLockCullFaceEnabled)
146        {
147                if (mCullFaceEnabled && !cullFace)
148                {
149                        mCullFaceEnabled = false;
150                        glDisable(GL_CULL_FACE);
151                }
152                else if (!mCullFaceEnabled && cullFace)
153                {
154                        mCullFaceEnabled = true;
155                        glEnable(GL_CULL_FACE);
156                }
157        }
158        if (mAlphaTestEnabled && !alphaTest)
159        {
160                mAlphaTestEnabled = false;
161               
162                if (mUseAlphaToCoverage)
163                        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
164                else
165                        glDisable(GL_ALPHA_TEST);
166        }
167        else if (!mAlphaTestEnabled && alphaTest)
168        {
169                mAlphaTestEnabled = true;
170               
171                if (mUseAlphaToCoverage)
172                        glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
173                else
174                        glEnable(GL_ALPHA_TEST);
175        }
176
177        if (mTexturesEnabled &&
178                (!texturing || (mRenderType == DEPTH_PASS) && !mAlphaTestEnabled))
179        {
180                mTexturesEnabled = false;
181
182                if (!tech->GetFragmentProgram())
183                        glDisable(GL_TEXTURE_2D);
184
185                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
186        }
187        else if (!mTexturesEnabled && texturing)
188        {
189                // support only alpha textures in depth pass
190                if ((mRenderType != DEPTH_PASS) || mAlphaTestEnabled)
191                {
192                        mTexturesEnabled = true;
193
194                        if (!tech->GetFragmentProgram())
195                                glEnable(GL_TEXTURE_2D);
196
197                        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
198                }
199        }
200
201        ///////////////////
202        //-- fragment and vertex programs
203       
204        ShaderProgram *frag = tech->GetFragmentProgram();
205
206        if (frag)
207        {
208                if (!mFragmentProgramEnabled)
209                {
210                        mFragmentProgramEnabled = true;
211                        ResourceManager::GetSingleton()->EnableFragmentProfile();
212                }
213
214                if (frag != mCurrentFragmentProgram)
215                {                       
216                        mCurrentFragmentProgram = frag;
217                        mCurrentFragmentProgram->Bind();                       
218                }
219                       
220                tech->GetFragmentProgramParameters()->UpdateParameters();
221        }
222        else
223        {
224                if (mFragmentProgramEnabled)
225                {
226                        mFragmentProgramEnabled = false;
227                        ResourceManager::GetSingleton()->DisableFragmentProfile();
228                }
229        }
230
231        ShaderProgram *vert = tech->GetVertexProgram();
232
233        if (vert)
234        {
235                if (!mVertexProgramEnabled)
236                {
237                        mVertexProgramEnabled = true;
238                        ResourceManager::GetSingleton()->EnableVertexProfile();
239                }
240
241                if (vert != mCurrentVertexProgram)
242                {
243                        mCurrentVertexProgram = vert;
244                        mCurrentVertexProgram->Bind();
245                }
246               
247                tech->GetVertexProgramParameters()->UpdateParameters();
248        }
249        else
250        {
251                if (mVertexProgramEnabled)
252                {
253                        mVertexProgramEnabled = false;
254                        ResourceManager::GetSingleton()->DisableVertexProfile();
255                }
256        }
257
258        if (!mFragmentProgramEnabled)
259        {
260                // set FORWARD texture
261                if (tex)
262                {
263                        if (mCurrentTexId != tex->GetId())
264                        {
265                                tex->Bind();
266                                mCurrentTexId = tex->GetId();
267                        }
268                }
269                else
270                {
271                        mCurrentTexId = 0;
272                        glBindTexture(GL_TEXTURE_2D, 0);
273                }
274        }
275}
276
277
278void RenderState::SetUseAlphaToCoverage(bool useAlphaToCoverage)
279{
280        mUseAlphaToCoverage = useAlphaToCoverage;
281}
282
283
284void RenderState::SetRenderPassType(RenderPassType t)
285{
286        mRenderType = t;
287}
288
289
290RenderState::RenderPassType RenderState::GetRenderPassType() const
291{
292        return mRenderType;
293}
294
295
296void RenderState::LockCullFaceEnabled(bool lockCull)
297{
298        mLockCullFaceEnabled =  lockCull;
299}
300
301
302}
Note: See TracBrowser for help on using the repository browser.