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

Revision 3039, 4.9 KB checked in by mattausch, 16 years ago (diff)
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(FIXED),
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
71
72bool RenderState::SetMode(Mode mode)
73{
74        ///////////
75        //-- just change the modewhen necessary
76
77        if (mode == mMode) return false;
78
79        mMode = mode;
80
81        if (mode == QUERY)
82        {
83                if (mRenderType != DEPTH_PASS)
84                {
85                        glDisable(GL_LIGHTING);
86                        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
87
88                        if (mRenderType == DEFERRED)
89                        {
90                                ResourceManager::GetSingleton()->DisableFragmentProfile();
91                                ResourceManager::GetSingleton()->DisableFragmentProfile();
92                        }
93                }
94
95                glDepthMask(GL_FALSE);
96
97                static Material defaultMat;
98                SetState(&defaultMat);
99        }
100        else // mode returns to render
101        {
102                /////////////
103                //-- restore render state
104
105                if (mRenderType != DEPTH_PASS)
106                {
107                        glEnable(GL_LIGHTING);
108                        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
109
110                        if (mRenderType == DEFERRED)
111                        {
112                                ResourceManager::GetSingleton()->EnableFragmentProfile();
113                                ResourceManager::GetSingleton()->EnableVertexProfile();
114                        }
115                }
116
117                glDepthMask(GL_TRUE);
118        }
119
120        return true;
121}
122
123       
124void RenderState::SetState(Material *mat)
125{
126        Texture *tex = mat->GetTexture();
127
128        const bool texturing = (tex != NULL);
129
130        bool alphaTest = mat->IsAlphaTestEnabled();
131        bool cullFace = mat->IsCullFaceEnabled();
132
133        if (!mLockCullFaceEnabled)
134        {
135                if (mCullFaceEnabled && !cullFace)
136                {
137                        mCullFaceEnabled = false;
138                        glDisable(GL_CULL_FACE);
139                }
140                else if (!mCullFaceEnabled && cullFace)
141                {
142                        mCullFaceEnabled = true;
143                        glEnable(GL_CULL_FACE);
144                }
145        }
146        if (mAlphaTestEnabled && !alphaTest)
147        {
148                mAlphaTestEnabled = false;
149               
150                if (mUseAlphaToCoverage)
151                        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
152                else
153                        glDisable(GL_ALPHA_TEST);
154        }
155        else if (!mAlphaTestEnabled && alphaTest)
156        {
157                mAlphaTestEnabled = true;
158               
159                if (mUseAlphaToCoverage)
160                        glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
161                else
162                        glEnable(GL_ALPHA_TEST);
163        }
164
165        if (mTexturesEnabled &&
166                (!texturing || (mRenderType == DEPTH_PASS) && !mAlphaTestEnabled))
167        {
168                mTexturesEnabled = false;
169
170                if (mRenderType != DEFERRED)//!mat->mFragmentProgram)
171                        glDisable(GL_TEXTURE_2D);
172
173                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
174        }
175        else if (!mTexturesEnabled && texturing)
176        {
177                // support only alpha textures in depth pass
178                if ((mRenderType != DEPTH_PASS) || mAlphaTestEnabled)
179                {
180                        mTexturesEnabled = true;
181
182                        if (mRenderType != DEFERRED)//!mat->mFragmentProgram)
183                                glEnable(GL_TEXTURE_2D);
184
185                        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
186                }
187        }
188
189        if (mRenderType == DEFERRED)
190        {
191                if (mat->GetFragmentProgram())
192                {
193                        if (mat->GetFragmentProgram() != mCurrentFragmentProgram)
194                        {                       
195                                mCurrentFragmentProgram = mat->GetFragmentProgram();
196                                mCurrentFragmentProgram->Bind();                       
197                        }
198                       
199                        mat->GetFragmentProgramParameters()->UpdateParameters();
200
201                }
202       
203                if (mat->GetVertexProgram())
204                {
205                        if (mat->GetVertexProgram() != mCurrentVertexProgram)
206                        {
207                                mCurrentVertexProgram = mat->GetVertexProgram();
208                                mCurrentVertexProgram->Bind();
209                        }
210               
211                        mat->GetVertexProgramParameters()->UpdateParameters();
212                }
213        }
214        else
215        {
216                // set fixed texture
217                if (tex)
218                {
219                        if (mCurrentTexId != tex->GetId())
220                        {
221                                tex->Bind();
222                                mCurrentTexId = tex->GetId();
223                        }
224                }
225                else
226                {
227                        mCurrentTexId = 0;
228                        glBindTexture(GL_TEXTURE_2D, 0);
229                }
230        }
231}
232
233
234void RenderState::SetUseAlphaToCoverage(bool useAlphaToCoverage)
235{
236        mUseAlphaToCoverage = useAlphaToCoverage;
237}
238
239
240void RenderState::SetRenderPassType(RenderPassType t)
241{
242        mRenderType = t;
243}
244
245
246RenderState::RenderPassType RenderState::GetRenderPassType() const
247{
248        return mRenderType;
249}
250
251
252void RenderState::LockCullFaceEnabled(bool lockCull)
253{
254        mLockCullFaceEnabled =  lockCull;
255}
256
257
258}
Note: See TracBrowser for help on using the repository browser.