← Back to branch summary

~thumper/nux/next-changes

« back to all changes in this revision

Viewing changes to NuxGraphics/GLRenderStates.cpp

  • Committer: Neil Jagdish Patel
  • Date: 2010-09-01 21:15:42 UTC
  • Revision ID: neil.patel@canonical.com-20100901211542-cw2ce3ak28unouwb
Add NuxGraphics with licensing

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxGraphics/GLRenderStates.cpp
 
1
/*
 
2
 * Copyright 2010 Inalogic Inc.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify it 
 
5
 * under the terms of the GNU Lesser General Public License version 3, as
 
6
 * published by the  Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful, but 
 
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of 
 
10
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR 
 
11
 * PURPOSE.  See the applicable version of the GNU Lesser General Public 
 
12
 * License for more details.
 
13
 * 
 
14
 * You should have received a copy of both the GNU Lesser General Public 
 
15
 * License version 3 along with this program.  If not, see 
 
16
 * <http://www.gnu.org/licenses/>
 
17
 *
 
18
 * Authored by: Jay Taoko <jay.taoko_AT_gmail_DOT_com>
 
19
 *
 
20
 */
 
21
 
 
22
 
 
23
#include "GLResource.h"
 
24
#include "GLRenderStates.h"
 
25
 
 
26
NAMESPACE_BEGIN_OGL
 
27
 
 
28
const struct StateLookUpTable
 
29
{
 
30
    StateLookUpTable()
 
31
    {
 
32
        // setup render state map
 
33
#define UL_MAP(state__, default_value__, checked__)                         \
 
34
        default_render_state[GFXRS_##state__].iValue     = default_value__;      \
 
35
        default_render_state[GFXRS_##state__].Checked   = checked__;
 
36
 
 
37
#define UL_MAP_FLOAT(state__, default_value__, checked__)                         \
 
38
    default_render_state[GFXRS_##state__].fValue     = default_value__;      \
 
39
    default_render_state[GFXRS_##state__].Checked   = checked__;            \
 
40
 
 
41
 
 
42
        UL_MAP(FRONT_POLYGONMODE            ,           GL_FILL         ,       1);
 
43
        UL_MAP(BACK_POLYGONMODE             ,           GL_FILL         ,       1);
 
44
        UL_MAP(CULLFACEENABLE               ,           GL_FALSE        ,       1);
 
45
        UL_MAP(CULLFACE                     ,           GL_BACK         ,       1);
 
46
        UL_MAP(FRONTFACE                    ,           GL_CCW          ,       1);
 
47
 
 
48
        UL_MAP(SCISSORTESTENABLE            ,           GL_FALSE        ,       1);
 
49
        UL_MAP(FOGENABLE                    ,           GL_FALSE        ,       1);
 
50
 
 
51
        UL_MAP(ZTESTENABLE                  ,           GL_TRUE         ,       1);
 
52
        UL_MAP(ZWRITEENABLE                 ,           GL_TRUE         ,       1);
 
53
        UL_MAP(ZFUNC                        ,           GL_LESS         ,       1);
 
54
        UL_MAP_FLOAT(ZNEAR                  ,           static_cast<UINT>(0.0f)            ,       1);
 
55
        UL_MAP_FLOAT(ZFAR                   ,           static_cast<UINT>(1.0f)            ,       1);
 
56
 
 
57
        UL_MAP(ALPHABLENDENABLE             ,           GL_FALSE        ,       1);
 
58
        UL_MAP(BLENDOP                      ,           GL_FUNC_ADD     ,       1);
 
59
        UL_MAP(BLENDOPALPHA                 ,           GL_FUNC_ADD     ,       1);
 
60
        UL_MAP(SRCBLEND                     ,           GL_ONE          ,       1);
 
61
        UL_MAP(DESTBLEND                    ,           GL_ZERO         ,       1);
 
62
        UL_MAP(SRCBLENDALPHA                ,           GL_ONE          ,       1);
 
63
        UL_MAP(DESTBLENDALPHA               ,           GL_ZERO         ,       1);
 
64
 
 
65
        UL_MAP(ALPHATESTENABLE              ,           GL_FALSE        ,       1);
 
66
        UL_MAP(ALPHATESTREF                 ,           0x0             ,       1);
 
67
        UL_MAP(ALPHATESTFUNC                ,           GL_ALWAYS       ,       1);
 
68
 
 
69
        UL_MAP(STENCILENABLE                ,           GL_FALSE        ,       1);
 
70
        UL_MAP(TWOSIDEDSTENCILENABLE        ,           GL_FALSE        ,       1);
 
71
        UL_MAP(FRONT_STENCILWRITEMASK       ,           0xFFFFFFFF      ,       1);
 
72
        UL_MAP(BACK_STENCILWRITEMASK        ,           0xFFFFFFFF      ,       1);
 
73
 
 
74
        UL_MAP(FRONT_STENCILFUNC            ,           GL_ALWAYS       ,       1);
 
75
        UL_MAP(FRONT_STENCILREF             ,           0x0             ,       1);
 
76
        UL_MAP(FRONT_STENCILMASK            ,           0xFF            ,       1);
 
77
        UL_MAP(FRONT_STENCILFAIL            ,           GL_KEEP         ,       1);
 
78
        UL_MAP(FRONT_STENCILZFAIL           ,           GL_KEEP         ,       1);
 
79
        UL_MAP(FRONT_STENCILZPASS           ,           GL_KEEP         ,       1);
 
80
 
 
81
        UL_MAP(BACK_STENCILFUNC             ,           GL_ALWAYS       ,       1);
 
82
        UL_MAP(BACK_STENCILREF              ,           0x0             ,       1);
 
83
        UL_MAP(BACK_STENCILMASK             ,           0xFF            ,       1);
 
84
        UL_MAP(BACK_STENCILFAIL             ,           GL_KEEP         ,       1);
 
85
        UL_MAP(BACK_STENCILZFAIL            ,           GL_KEEP         ,       1);
 
86
        UL_MAP(BACK_STENCILZPASS            ,           GL_KEEP         ,       1);
 
87
 
 
88
 
 
89
        UL_MAP(POINTSMOOTHENABLE            ,           GL_FALSE        ,       1);
 
90
        UL_MAP(LINESMOOTHENABLE             ,           GL_FALSE        ,       1);
 
91
        UL_MAP(POINTSIZE                    ,           1               ,       1);
 
92
        UL_MAP(LINEWIDTH                    ,           1               ,       1);
 
93
        UL_MAP(POINTHINT                    ,           GL_FASTEST      ,       1);
 
94
        UL_MAP(LINEHINT                     ,           GL_FASTEST      ,       1);
 
95
 
 
96
        UL_MAP(COLORWRITEENABLE_R           ,           GL_TRUE         ,       1);
 
97
        UL_MAP(COLORWRITEENABLE_G           ,           GL_TRUE         ,       1);
 
98
        UL_MAP(COLORWRITEENABLE_B           ,           GL_TRUE         ,       1);
 
99
        UL_MAP(COLORWRITEENABLE_A           ,           GL_TRUE         ,       1);
 
100
 
 
101
#undef UL_MAP
 
102
#undef UL_MAP_FLOAT
 
103
    };
 
104
 
 
105
    RenderStateMap default_render_state[GFXRS_MAX_RENDERSTATES];
 
106
    RenderStateMap sampler_state_map[GFXSS_MAX_SAMPLERSTATES];
 
107
 
 
108
} s_StateLUT;
 
109
 
 
110
 
 
111
GLRenderStates::GLRenderStates(eGraphicsBoardVendor board)
 
112
{
 
113
    m_BoardVendor = board;
 
114
    Memcpy(&m_RenderStateChanges, &s_StateLUT.default_render_state, sizeof(m_RenderStateChanges));
 
115
}
 
116
 
 
117
GLRenderStates::~GLRenderStates()
 
118
{
 
119
 
 
120
}
 
121
 
 
122
void GLRenderStates::ResetDefault()
 
123
{
 
124
    HW__EnableCulling( s_StateLUT.default_render_state[GFXRS_CULLFACEENABLE].iValue );
 
125
    HW__SetFrontFace( s_StateLUT.default_render_state[GFXRS_FRONTFACE].iValue );
 
126
    HW__SetCullFace( s_StateLUT.default_render_state[GFXRS_CULLFACE].iValue );
 
127
 
 
128
    HW__SetDepthMask( s_StateLUT.default_render_state[GFXRS_ZWRITEENABLE].iValue );
 
129
    HW__SetDepthFunc( s_StateLUT.default_render_state[GFXRS_ZFUNC].iValue );
 
130
    HW__SetEnableDepthTest( s_StateLUT.default_render_state[GFXRS_ZTESTENABLE].iValue );
 
131
    HW__SetDepthRange( s_StateLUT.default_render_state[GFXRS_ZNEAR].fValue, s_StateLUT.default_render_state[GFXRS_ZFAR].fValue );
 
132
 
 
133
    HW__EnableAlphaBlend( s_StateLUT.default_render_state[GFXRS_ALPHABLENDENABLE].iValue );
 
134
    HW__SetAlphaBlendOp( s_StateLUT.default_render_state[GFXRS_BLENDOP].iValue, s_StateLUT.default_render_state[GFXRS_BLENDOPALPHA].iValue );
 
135
    HW__SetSeparateAlphaBlendFactors(
 
136
        s_StateLUT.default_render_state[GFXRS_SRCBLEND].iValue, s_StateLUT.default_render_state[GFXRS_DESTBLEND].iValue,
 
137
        s_StateLUT.default_render_state[GFXRS_SRCBLENDALPHA].iValue, s_StateLUT.default_render_state[GFXRS_DESTBLENDALPHA ].iValue );
 
138
 
 
139
 
 
140
    HW__EnableAlphaTest( s_StateLUT.default_render_state[GFXRS_ALPHATESTENABLE].iValue );
 
141
    HW__SetAlphaTestFunc( s_StateLUT.default_render_state[GFXRS_ALPHATESTFUNC].iValue, s_StateLUT.default_render_state[GFXRS_ALPHATESTREF].iValue );
 
142
 
 
143
 
 
144
    HW__EnableStencil( s_StateLUT.default_render_state[GFXRS_STENCILENABLE].iValue );
 
145
    HW__EnableTwoSidedStencil( s_StateLUT.default_render_state[GFXRS_TWOSIDEDSTENCILENABLE].iValue );
 
146
 
 
147
    HW__SetFrontFaceStencilFunc(
 
148
        s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFUNC].iValue,
 
149
        s_StateLUT.default_render_state[GFXRS_FRONT_STENCILREF].iValue,
 
150
        s_StateLUT.default_render_state[GFXRS_FRONT_STENCILMASK].iValue );
 
151
    HW__SetFrontFaceStencilOp(
 
152
        s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFAIL].iValue,
 
153
        s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
 
154
        s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue );
 
155
 
 
156
    HW__SetBackFaceStencilFunc(
 
157
        s_StateLUT.default_render_state[GFXRS_BACK_STENCILFUNC].iValue,
 
158
        s_StateLUT.default_render_state[GFXRS_BACK_STENCILREF].iValue,
 
159
        s_StateLUT.default_render_state[GFXRS_BACK_STENCILMASK].iValue );
 
160
    HW__SetBackFaceStencilOp(
 
161
        s_StateLUT.default_render_state[GFXRS_BACK_STENCILFAIL].iValue,
 
162
        s_StateLUT.default_render_state[GFXRS_BACK_STENCILZFAIL].iValue,
 
163
        s_StateLUT.default_render_state[GFXRS_BACK_STENCILZPASS].iValue );
 
164
 
 
165
    HW__EnableScissor( s_StateLUT.default_render_state[GFXRS_SCISSORTESTENABLE].iValue );
 
166
 
 
167
    HW__EnableScissor( s_StateLUT.default_render_state[GFXRS_SCISSORTESTENABLE].iValue );
 
168
    HW__EnableFog( s_StateLUT.default_render_state[GFXRS_FOGENABLE].iValue );
 
169
 
 
170
}
 
171
 
 
172
void GLRenderStates::SubmitChangeStates()
 
173
{
 
174
    HW__EnableCulling( m_RenderStateChanges[GFXRS_CULLFACEENABLE].iValue );
 
175
    HW__SetFrontFace( m_RenderStateChanges[GFXRS_FRONTFACE].iValue );
 
176
    HW__SetCullFace( m_RenderStateChanges[GFXRS_CULLFACE].iValue );
 
177
 
 
178
    HW__SetDepthMask( m_RenderStateChanges[GFXRS_ZWRITEENABLE].iValue );
 
179
    HW__SetDepthFunc( m_RenderStateChanges[GFXRS_ZFUNC].iValue );
 
180
    HW__SetEnableDepthTest( m_RenderStateChanges[GFXRS_ZTESTENABLE].iValue );
 
181
    HW__SetDepthRange( m_RenderStateChanges[GFXRS_ZNEAR].fValue, m_RenderStateChanges[GFXRS_ZFAR].fValue );
 
182
 
 
183
    HW__EnableAlphaBlend( m_RenderStateChanges[GFXRS_ALPHABLENDENABLE].iValue );
 
184
    HW__SetAlphaBlendOp( m_RenderStateChanges[GFXRS_BLENDOP].iValue, m_RenderStateChanges[GFXRS_BLENDOPALPHA].iValue );
 
185
    HW__SetSeparateAlphaBlendFactors(
 
186
        m_RenderStateChanges[GFXRS_SRCBLEND].iValue, m_RenderStateChanges[GFXRS_DESTBLEND].iValue,
 
187
        m_RenderStateChanges[GFXRS_SRCBLENDALPHA].iValue, m_RenderStateChanges[GFXRS_DESTBLENDALPHA ].iValue );
 
188
 
 
189
 
 
190
    HW__EnableAlphaTest( m_RenderStateChanges[GFXRS_ALPHATESTENABLE].iValue );
 
191
    HW__SetAlphaTestFunc( m_RenderStateChanges[GFXRS_ALPHATESTFUNC].iValue, m_RenderStateChanges[GFXRS_ALPHATESTREF].iValue );
 
192
 
 
193
 
 
194
    HW__EnableStencil( m_RenderStateChanges[GFXRS_STENCILENABLE].iValue );
 
195
    HW__EnableTwoSidedStencil( s_StateLUT.default_render_state[GFXRS_TWOSIDEDSTENCILENABLE].iValue );
 
196
 
 
197
    HW__SetFrontFaceStencilFunc(
 
198
        m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC].iValue,
 
199
        m_RenderStateChanges[GFXRS_FRONT_STENCILREF].iValue,
 
200
        m_RenderStateChanges[GFXRS_FRONT_STENCILMASK].iValue );
 
201
    HW__SetFrontFaceStencilOp(
 
202
        m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL].iValue,
 
203
        m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL].iValue,
 
204
        m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS].iValue );
 
205
 
 
206
    HW__SetBackFaceStencilFunc(
 
207
        m_RenderStateChanges[GFXRS_BACK_STENCILFUNC].iValue,
 
208
        m_RenderStateChanges[GFXRS_BACK_STENCILREF].iValue,
 
209
        m_RenderStateChanges[GFXRS_BACK_STENCILMASK].iValue );
 
210
    HW__SetBackFaceStencilOp(
 
211
        m_RenderStateChanges[GFXRS_BACK_STENCILFAIL].iValue,
 
212
        m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL].iValue,
 
213
        m_RenderStateChanges[GFXRS_BACK_STENCILZPASS].iValue );
 
214
 
 
215
    HW__EnableScissor( m_RenderStateChanges[GFXRS_SCISSORTESTENABLE].iValue );
 
216
 
 
217
    HW__EnableScissor( m_RenderStateChanges[GFXRS_SCISSORTESTENABLE].iValue );
 
218
    HW__EnableFog( m_RenderStateChanges[GFXRS_FOGENABLE].iValue );
 
219
 
 
220
}
 
221
 
 
222
void GLRenderStates::ResetStateChangeToDefault()
 
223
{
 
224
    for(UINT i = 0; i < GFXRS_MAX_RENDERSTATES; i++)
 
225
    {
 
226
        if(m_RenderStateChanges[i].Checked &&
 
227
            ((m_RenderStateChanges[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
 
228
            (m_RenderStateChanges[i].fValue != s_StateLUT.default_render_state[i].fValue) ))
 
229
        {
 
230
            m_RenderStateChanges[i].iValue = s_StateLUT.default_render_state[i].iValue;
 
231
            m_RenderStateChanges[i].fValue = s_StateLUT.default_render_state[i].fValue;
 
232
        }
 
233
    }
 
234
}
 
235
 
 
236
void GLRenderStates::CheckStateChange()
 
237
{
 
238
    for(UINT i = 0; i < GFXRS_MAX_RENDERSTATES; i++)
 
239
    {
 
240
        if(m_RenderStateChanges[i].Checked &&
 
241
            ((m_RenderStateChanges[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
 
242
            (m_RenderStateChanges[i].fValue != s_StateLUT.default_render_state[i].fValue) ))
 
243
        {
 
244
            m_RenderStateChanges[i].iValue = s_StateLUT.default_render_state[i].iValue;
 
245
            m_RenderStateChanges[i].fValue = s_StateLUT.default_render_state[i].fValue;
 
246
            nuxError(TEXT("[GLRenderStates::Check] Render state doesn't have default value"));
 
247
        }
 
248
    }
 
249
}
 
250
 
 
251
void GLRenderStates::SetRenderStates(UINT rs, UINT value)
 
252
{
 
253
    #define RS_VALUE(a)      (a).iValue
 
254
 
 
255
    if (value != m_RenderStateChanges[rs].iValue)
 
256
    {
 
257
        m_RenderStateChanges[rs].iValue = static_cast<UINT>(value);
 
258
 
 
259
        if(rs == GFXRS_ALPHATESTENABLE ||
 
260
            rs == GFXRS_ALPHATESTREF ||
 
261
            rs == GFXRS_ALPHATESTFUNC)
 
262
        {
 
263
            HW__EnableAlphaTest(RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTENABLE]));
 
264
            HW__SetAlphaTestFunc(
 
265
                RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTFUNC]),
 
266
                RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTREF]));
 
267
        }
 
268
 
 
269
        if(rs == GFXRS_STENCILENABLE          ||
 
270
            rs == GFXRS_TWOSIDEDSTENCILENABLE ||
 
271
            rs == GFXRS_FRONT_STENCILFAIL           ||
 
272
            rs == GFXRS_FRONT_STENCILZFAIL          ||
 
273
            rs == GFXRS_FRONT_STENCILZPASS           ||
 
274
            rs == GFXRS_FRONT_STENCILFUNC           ||
 
275
            rs == GFXRS_FRONT_STENCILREF            ||
 
276
            rs == GFXRS_FRONT_STENCILMASK           ||
 
277
            rs == GFXRS_FRONT_STENCILWRITEMASK      ||
 
278
            rs == GFXRS_BACK_STENCILFAIL           ||
 
279
            rs == GFXRS_BACK_STENCILZFAIL          ||
 
280
            rs == GFXRS_BACK_STENCILZPASS           ||
 
281
            rs == GFXRS_BACK_STENCILFUNC           ||
 
282
            rs == GFXRS_BACK_STENCILREF            ||
 
283
            rs == GFXRS_BACK_STENCILMASK           ||
 
284
            rs == GFXRS_BACK_STENCILWRITEMASK)
 
285
        {
 
286
            HW__EnableStencil(RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE]));
 
287
            HW__EnableTwoSidedStencil(RS_VALUE(m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE]));
 
288
 
 
289
            HW__SetFrontFaceStencilFunc(
 
290
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]),
 
291
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF]),
 
292
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]));
 
293
            HW__SetFrontFaceStencilOp(
 
294
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]),
 
295
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]),
 
296
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]));
 
297
            HW__SetStencilFrontFaceWriteMask(
 
298
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK]));
 
299
 
 
300
            HW__SetBackFaceStencilFunc(
 
301
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFUNC]),
 
302
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILREF]),
 
303
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILMASK]));
 
304
            HW__SetBackFaceStencilOp(
 
305
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFAIL]),
 
306
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL]),
 
307
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZPASS]));
 
308
            HW__SetStencilBackFaceWriteMask(
 
309
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK]));
 
310
        }
 
311
 
 
312
        if(rs == GFXRS_ALPHABLENDENABLE   ||
 
313
            rs == GFXRS_BLENDOP           ||
 
314
            rs == GFXRS_BLENDOPALPHA      ||
 
315
            rs == GFXRS_SRCBLEND          ||
 
316
            rs == GFXRS_DESTBLEND         ||
 
317
            rs == GFXRS_SRCBLENDALPHA     ||
 
318
            rs == GFXRS_DESTBLENDALPHA)
 
319
        {
 
320
            HW__EnableAlphaBlend(
 
321
                RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]));
 
322
 
 
323
            HW__SetSeparateAlphaBlendFactors(
 
324
                RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND]),
 
325
                RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]),
 
326
                RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLENDALPHA]),
 
327
                RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLENDALPHA]));
 
328
            HW__SetAlphaBlendOp(
 
329
                RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP]),
 
330
                RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA]));
 
331
        }
 
332
 
 
333
        if(rs == GFXRS_COLORWRITEENABLE_R    ||
 
334
            rs == GFXRS_COLORWRITEENABLE_G   ||
 
335
            rs == GFXRS_COLORWRITEENABLE_B   ||
 
336
            rs == GFXRS_COLORWRITEENABLE_A)
 
337
        {
 
338
            HW__SetColorMask(
 
339
                RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]),
 
340
                RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]),
 
341
                RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]),
 
342
                RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]));
 
343
        }
 
344
 
 
345
        if(rs == GFXRS_ZTESTENABLE    ||
 
346
            rs == GFXRS_ZWRITEENABLE   ||
 
347
            rs == GFXRS_ZFUNC   ||
 
348
            rs == GFXRS_ZNEAR   ||
 
349
            rs == GFXRS_ZFAR)
 
350
        {
 
351
            HW__SetEnableDepthTest(RS_VALUE(m_RenderStateChanges[GFXRS_ZTESTENABLE]));
 
352
            HW__SetDepthMask(RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE]));
 
353
            HW__SetDepthFunc(RS_VALUE(m_RenderStateChanges[GFXRS_ZFUNC]));
 
354
            HW__SetDepthRange(
 
355
                RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR]),
 
356
                RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR]));
 
357
        }
 
358
 
 
359
        if(rs == GFXRS_POLYGONOFFSETENABLE    ||
 
360
            rs == GFXRS_POLYGONOFFSETFACTOR   ||
 
361
            rs == GFXRS_POLYGONOFFSETUNITS)
 
362
        {
 
363
            HW__EnablePolygonOffset(RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETENABLE]));
 
364
            HW__SetPolygonOffset(
 
365
                RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]),
 
366
                RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]));
 
367
        }
 
368
 
 
369
        if(rs == GFXRS_FRONT_POLYGONMODE    ||
 
370
            rs == GFXRS_BACK_POLYGONMODE)
 
371
        {
 
372
            HW__SetPolygonMode(
 
373
                RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]),
 
374
                RS_VALUE(m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]));
 
375
        }
 
376
 
 
377
        if(rs == GFXRS_CULLFACEENABLE     ||
 
378
            rs == GFXRS_CULLFACE          ||
 
379
            rs == GFXRS_FRONTFACE)
 
380
        {
 
381
            HW__EnableCulling(RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACEENABLE]));
 
382
            HW__SetFrontFace(RS_VALUE(m_RenderStateChanges[GFXRS_FRONTFACE]));
 
383
            HW__SetCullFace(RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACE]));
 
384
        }
 
385
    }
 
386
 
 
387
#undef RS_VALUE
 
388
}
 
389
 
 
390
NAMESPACE_END_OGL