Nux

Merge lp:~unity-team/nux/nux.fix-937444 into lp:nux/2.0

  1. nux.fix-937444
  2. Merge into 2.0
Proposed by Jay Taoko
Status: Merged
Approved by: Jay Taoko
Approved revision: 581
Merged at revision: 580
Proposed branch: lp:~unity-team/nux/nux.fix-937444
Merge into: lp:nux/2.0
Diff against target: 1078 lines (+197/-340)
3 files modified
NuxGraphics/GLRenderStates.cpp (+65/-205)
NuxGraphics/GLRenderStates.h (+131/-134)
configure.ac (+1/-1)
To merge this branch: bzr merge lp:~unity-team/nux/nux.fix-937444
Reviewer Review Type Date Requested Status
Jay Taoko (community) Approve
Review via email: mp+93924@code.launchpad.net

Description of the change

* Fix for bug #937444.
* Removed obsolete functions GpuRenderStates::SetRenderStates.
* Code style fixes.

To post a comment you must log in.
lp:~unity-team/nux/nux.fix-937444 updated
581. By Jay Taoko

* Use proper states.

Revision history for this message
Jay Taoko (jaytaoko) :
review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'NuxGraphics/GLRenderStates.cpp'
2--- NuxGraphics/GLRenderStates.cpp 2011-10-21 22:06:35 +0000
3+++ NuxGraphics/GLRenderStates.cpp 2012-02-21 06:59:17 +0000
4@@ -1,5 +1,5 @@
5 /*
6- * Copyright 2010 Inalogic® Inc.
7+ * Copyright 2010-2012 Inalogic® Inc.
8 *
9 * This program is free software: you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License, as
11@@ -115,7 +115,7 @@
12 {
13 _gpu_brand = board;
14 _gpu_info = info;
15- Memcpy(&m_RenderStateChanges, &s_StateLUT.default_render_state, sizeof(m_RenderStateChanges));
16+ Memcpy(&render_state_changes_, &s_StateLUT.default_render_state, sizeof(render_state_changes_));
17 }
18
19 GpuRenderStates::~GpuRenderStates()
20@@ -155,6 +155,12 @@
21 s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
22 s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue);
23
24+ HW__EnableLineSmooth(s_StateLUT.default_render_state[GFXRS_LINESMOOTHENABLE].iValue);
25+ HW__SetLineWidth(s_StateLUT.default_render_state[GFXRS_LINEWIDTH].iValue, s_StateLUT.default_render_state[GFXRS_LINEHINT].iValue);
26+
27+ HW__EnablePointSmooth(s_StateLUT.default_render_state[GFXRS_POINTSMOOTHENABLE].iValue);
28+ HW__SetPointSize(s_StateLUT.default_render_state[GFXRS_POINTSIZE].iValue, s_StateLUT.default_render_state[GFXRS_POINTHINT].iValue);
29+
30 #if 0
31 HW__EnableTwoSidedStencil( s_StateLUT.default_render_state[GFXRS_TWOSIDEDSTENCILENABLE].iValue );
32
33@@ -184,62 +190,68 @@
34
35 void GpuRenderStates::SubmitChangeStates()
36 {
37- HW__EnableCulling( m_RenderStateChanges[GFXRS_CULLFACEENABLE].iValue );
38- HW__SetFrontFace( m_RenderStateChanges[GFXRS_FRONTFACE].iValue );
39- HW__SetCullFace( m_RenderStateChanges[GFXRS_CULLFACE].iValue );
40-
41- HW__SetDepthMask( m_RenderStateChanges[GFXRS_ZWRITEENABLE].iValue );
42- HW__SetDepthFunc( m_RenderStateChanges[GFXRS_ZFUNC].iValue );
43- HW__SetEnableDepthTest( m_RenderStateChanges[GFXRS_ZTESTENABLE].iValue );
44- HW__SetDepthRange( m_RenderStateChanges[GFXRS_ZNEAR].fValue, m_RenderStateChanges[GFXRS_ZFAR].fValue );
45-
46- HW__EnableAlphaBlend( m_RenderStateChanges[GFXRS_ALPHABLENDENABLE].iValue );
47- HW__SetAlphaBlendOp( m_RenderStateChanges[GFXRS_BLENDOP].iValue, m_RenderStateChanges[GFXRS_BLENDOPALPHA].iValue );
48+ HW__EnableCulling( render_state_changes_[GFXRS_CULLFACEENABLE].iValue );
49+ HW__SetFrontFace( render_state_changes_[GFXRS_FRONTFACE].iValue );
50+ HW__SetCullFace( render_state_changes_[GFXRS_CULLFACE].iValue );
51+
52+ HW__SetDepthMask( render_state_changes_[GFXRS_ZWRITEENABLE].iValue );
53+ HW__SetDepthFunc( render_state_changes_[GFXRS_ZFUNC].iValue );
54+ HW__SetEnableDepthTest( render_state_changes_[GFXRS_ZTESTENABLE].iValue );
55+ HW__SetDepthRange( render_state_changes_[GFXRS_ZNEAR].fValue, render_state_changes_[GFXRS_ZFAR].fValue );
56+
57+ HW__EnableAlphaBlend( render_state_changes_[GFXRS_ALPHABLENDENABLE].iValue );
58+ HW__SetAlphaBlendOp( render_state_changes_[GFXRS_BLENDOP].iValue, render_state_changes_[GFXRS_BLENDOPALPHA].iValue );
59 HW__SetSeparateAlphaBlendFactors(
60- m_RenderStateChanges[GFXRS_SRCBLEND].iValue, m_RenderStateChanges[GFXRS_DESTBLEND].iValue,
61- m_RenderStateChanges[GFXRS_SRCBLENDALPHA].iValue, m_RenderStateChanges[GFXRS_DESTBLENDALPHA ].iValue );
62-
63-
64- HW__EnableAlphaTest( m_RenderStateChanges[GFXRS_ALPHATESTENABLE].iValue );
65- HW__SetAlphaTestFunc( m_RenderStateChanges[GFXRS_ALPHATESTFUNC].iValue, m_RenderStateChanges[GFXRS_ALPHATESTREF].iValue );
66-
67-
68- HW__EnableStencil( m_RenderStateChanges[GFXRS_STENCILENABLE].iValue );
69+ render_state_changes_[GFXRS_SRCBLEND].iValue, render_state_changes_[GFXRS_DESTBLEND].iValue,
70+ render_state_changes_[GFXRS_SRCBLENDALPHA].iValue, render_state_changes_[GFXRS_DESTBLENDALPHA ].iValue );
71+
72+
73+ HW__EnableAlphaTest( render_state_changes_[GFXRS_ALPHATESTENABLE].iValue );
74+ HW__SetAlphaTestFunc( render_state_changes_[GFXRS_ALPHATESTFUNC].iValue, render_state_changes_[GFXRS_ALPHATESTREF].iValue );
75+
76+
77+ HW__EnableStencil( render_state_changes_[GFXRS_STENCILENABLE].iValue );
78
79 HW__SetStencilFunc(
80- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFUNC].iValue,
81- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILREF].iValue,
82- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILMASK].iValue);
83+ render_state_changes_[GFXRS_FRONT_STENCILFUNC].iValue,
84+ render_state_changes_[GFXRS_FRONT_STENCILREF].iValue,
85+ render_state_changes_[GFXRS_FRONT_STENCILMASK].iValue);
86 HW__SetStencilOp(
87- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFAIL].iValue,
88- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
89- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue);
90-
91+ render_state_changes_[GFXRS_FRONT_STENCILFAIL].iValue,
92+ render_state_changes_[GFXRS_FRONT_STENCILZFAIL].iValue,
93+ render_state_changes_[GFXRS_FRONT_STENCILZPASS].iValue);
94+
95+ HW__EnableLineSmooth(render_state_changes_[GFXRS_LINESMOOTHENABLE].iValue);
96+ HW__SetLineWidth(render_state_changes_[GFXRS_LINEWIDTH].iValue, render_state_changes_[GFXRS_LINEHINT].iValue);
97+
98+ HW__EnablePointSmooth(render_state_changes_[GFXRS_POINTSMOOTHENABLE].iValue);
99+ HW__SetPointSize(render_state_changes_[GFXRS_POINTSIZE].iValue, render_state_changes_[GFXRS_POINTHINT].iValue);
100+
101 #if 0
102 HW__EnableTwoSidedStencil( s_StateLUT.default_render_state[GFXRS_TWOSIDEDSTENCILENABLE].iValue );
103
104 HW__SetFrontFaceStencilFunc(
105- m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC].iValue,
106- m_RenderStateChanges[GFXRS_FRONT_STENCILREF].iValue,
107- m_RenderStateChanges[GFXRS_FRONT_STENCILMASK].iValue );
108+ render_state_changes_[GFXRS_FRONT_STENCILFUNC].iValue,
109+ render_state_changes_[GFXRS_FRONT_STENCILREF].iValue,
110+ render_state_changes_[GFXRS_FRONT_STENCILMASK].iValue );
111 HW__SetFrontFaceStencilOp(
112- m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL].iValue,
113- m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL].iValue,
114- m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS].iValue );
115+ render_state_changes_[GFXRS_FRONT_STENCILFAIL].iValue,
116+ render_state_changes_[GFXRS_FRONT_STENCILZFAIL].iValue,
117+ render_state_changes_[GFXRS_FRONT_STENCILZPASS].iValue );
118
119 HW__SetBackFaceStencilFunc(
120- m_RenderStateChanges[GFXRS_BACK_STENCILFUNC].iValue,
121- m_RenderStateChanges[GFXRS_BACK_STENCILREF].iValue,
122- m_RenderStateChanges[GFXRS_BACK_STENCILMASK].iValue );
123+ render_state_changes_[GFXRS_BACK_STENCILFUNC].iValue,
124+ render_state_changes_[GFXRS_BACK_STENCILREF].iValue,
125+ render_state_changes_[GFXRS_BACK_STENCILMASK].iValue );
126 HW__SetBackFaceStencilOp(
127- m_RenderStateChanges[GFXRS_BACK_STENCILFAIL].iValue,
128- m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL].iValue,
129- m_RenderStateChanges[GFXRS_BACK_STENCILZPASS].iValue );
130+ render_state_changes_[GFXRS_BACK_STENCILFAIL].iValue,
131+ render_state_changes_[GFXRS_BACK_STENCILZFAIL].iValue,
132+ render_state_changes_[GFXRS_BACK_STENCILZPASS].iValue );
133 #endif
134
135- HW__EnableScissor( m_RenderStateChanges[GFXRS_SCISSORTESTENABLE].iValue );
136+ HW__EnableScissor( render_state_changes_[GFXRS_SCISSORTESTENABLE].iValue );
137
138- HW__EnableFog( m_RenderStateChanges[GFXRS_FOGENABLE].iValue );
139+ HW__EnableFog( render_state_changes_[GFXRS_FOGENABLE].iValue );
140
141 }
142
143@@ -247,12 +259,12 @@
144 {
145 for (unsigned int i = 0; i < GFXRS_MAX_RENDERSTATES; i++)
146 {
147- if (m_RenderStateChanges[i].Checked &&
148- ((m_RenderStateChanges[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
149- (m_RenderStateChanges[i].fValue != s_StateLUT.default_render_state[i].fValue)))
150+ if (render_state_changes_[i].Checked &&
151+ ((render_state_changes_[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
152+ (render_state_changes_[i].fValue != s_StateLUT.default_render_state[i].fValue)))
153 {
154- m_RenderStateChanges[i].iValue = s_StateLUT.default_render_state[i].iValue;
155- m_RenderStateChanges[i].fValue = s_StateLUT.default_render_state[i].fValue;
156+ render_state_changes_[i].iValue = s_StateLUT.default_render_state[i].iValue;
157+ render_state_changes_[i].fValue = s_StateLUT.default_render_state[i].fValue;
158 }
159 }
160 }
161@@ -261,167 +273,15 @@
162 {
163 for (unsigned int i = 0; i < GFXRS_MAX_RENDERSTATES; i++)
164 {
165- if (m_RenderStateChanges[i].Checked &&
166- ((m_RenderStateChanges[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
167- (m_RenderStateChanges[i].fValue != s_StateLUT.default_render_state[i].fValue)))
168+ if (render_state_changes_[i].Checked &&
169+ ((render_state_changes_[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
170+ (render_state_changes_[i].fValue != s_StateLUT.default_render_state[i].fValue)))
171 {
172- m_RenderStateChanges[i].iValue = s_StateLUT.default_render_state[i].iValue;
173- m_RenderStateChanges[i].fValue = s_StateLUT.default_render_state[i].fValue;
174+ render_state_changes_[i].iValue = s_StateLUT.default_render_state[i].iValue;
175+ render_state_changes_[i].fValue = s_StateLUT.default_render_state[i].fValue;
176 nuxError("[GpuRenderStates::Check] Render state doesn't have default value");
177 }
178 }
179 }
180-
181- void GpuRenderStates::SetRenderStates(unsigned int rs, unsigned int value)
182- {
183-#define RS_VALUE(a) (a).iValue
184-
185- if (value != m_RenderStateChanges[rs].iValue)
186- {
187- m_RenderStateChanges[rs].iValue = static_cast<unsigned int> (value);
188-
189- if (rs == GFXRS_ALPHATESTENABLE ||
190- rs == GFXRS_ALPHATESTREF ||
191- rs == GFXRS_ALPHATESTFUNC)
192- {
193- HW__EnableAlphaTest(RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTENABLE]));
194- HW__SetAlphaTestFunc(
195- RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTFUNC]),
196- RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTREF]));
197- }
198-
199- if (rs == GFXRS_STENCILENABLE ||
200- rs == GFXRS_TWOSIDEDSTENCILENABLE ||
201- rs == GFXRS_FRONT_STENCILFAIL ||
202- rs == GFXRS_FRONT_STENCILZFAIL ||
203- rs == GFXRS_FRONT_STENCILZPASS ||
204- rs == GFXRS_FRONT_STENCILFUNC ||
205- rs == GFXRS_FRONT_STENCILREF ||
206- rs == GFXRS_FRONT_STENCILMASK ||
207- rs == GFXRS_FRONT_STENCILWRITEMASK ||
208- rs == GFXRS_BACK_STENCILFAIL ||
209- rs == GFXRS_BACK_STENCILZFAIL ||
210- rs == GFXRS_BACK_STENCILZPASS ||
211- rs == GFXRS_BACK_STENCILFUNC ||
212- rs == GFXRS_BACK_STENCILREF ||
213- rs == GFXRS_BACK_STENCILMASK ||
214- rs == GFXRS_BACK_STENCILWRITEMASK)
215- {
216- HW__EnableStencil(RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE]));
217-
218- HW__SetStencilFunc(
219- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFUNC].iValue,
220- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILREF].iValue,
221- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILMASK].iValue);
222- HW__SetStencilOp(
223- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFAIL].iValue,
224- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
225- s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue);
226-
227-#if 0
228- HW__EnableTwoSidedStencil(RS_VALUE(m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE]));
229-
230- HW__SetFrontFaceStencilFunc(
231- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]),
232- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF]),
233- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]));
234- HW__SetFrontFaceStencilOp(
235- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]),
236- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]),
237- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]));
238- HW__SetStencilFrontFaceWriteMask(
239- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK]));
240-
241- HW__SetBackFaceStencilFunc(
242- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFUNC]),
243- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILREF]),
244- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILMASK]));
245- HW__SetBackFaceStencilOp(
246- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFAIL]),
247- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL]),
248- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZPASS]));
249- HW__SetStencilBackFaceWriteMask(
250- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK]));
251-#endif
252- }
253-
254- if (rs == GFXRS_ALPHABLENDENABLE ||
255- rs == GFXRS_BLENDOP ||
256- rs == GFXRS_BLENDOPALPHA ||
257- rs == GFXRS_SRCBLEND ||
258- rs == GFXRS_DESTBLEND ||
259- rs == GFXRS_SRCBLENDALPHA ||
260- rs == GFXRS_DESTBLENDALPHA)
261- {
262- HW__EnableAlphaBlend(
263- RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]));
264-
265- HW__SetSeparateAlphaBlendFactors(
266- RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND]),
267- RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]),
268- RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLENDALPHA]),
269- RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLENDALPHA]));
270- HW__SetAlphaBlendOp(
271- RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP]),
272- RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA]));
273- }
274-
275- if (rs == GFXRS_COLORWRITEENABLE_R ||
276- rs == GFXRS_COLORWRITEENABLE_G ||
277- rs == GFXRS_COLORWRITEENABLE_B ||
278- rs == GFXRS_COLORWRITEENABLE_A)
279- {
280- HW__SetColorMask(
281- RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]),
282- RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]),
283- RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]),
284- RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]));
285- }
286-
287- if (rs == GFXRS_ZTESTENABLE ||
288- rs == GFXRS_ZWRITEENABLE ||
289- rs == GFXRS_ZFUNC ||
290- rs == GFXRS_ZNEAR ||
291- rs == GFXRS_ZFAR)
292- {
293- HW__SetEnableDepthTest(RS_VALUE(m_RenderStateChanges[GFXRS_ZTESTENABLE]));
294- HW__SetDepthMask(RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE]));
295- HW__SetDepthFunc(RS_VALUE(m_RenderStateChanges[GFXRS_ZFUNC]));
296- HW__SetDepthRange(
297- RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR]),
298- RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR]));
299- }
300-
301- if (rs == GFXRS_POLYGONOFFSETENABLE ||
302- rs == GFXRS_POLYGONOFFSETFACTOR ||
303- rs == GFXRS_POLYGONOFFSETUNITS)
304- {
305- HW__EnablePolygonOffset(RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETENABLE]));
306- HW__SetPolygonOffset(
307- RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]),
308- RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]));
309- }
310-
311- if (rs == GFXRS_FRONT_POLYGONMODE ||
312- rs == GFXRS_BACK_POLYGONMODE)
313- {
314- HW__SetPolygonMode(
315- RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]),
316- RS_VALUE(m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]));
317- }
318-
319- if (rs == GFXRS_CULLFACEENABLE ||
320- rs == GFXRS_CULLFACE ||
321- rs == GFXRS_FRONTFACE)
322- {
323- HW__EnableCulling(RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACEENABLE]));
324- HW__SetFrontFace(RS_VALUE(m_RenderStateChanges[GFXRS_FRONTFACE]));
325- HW__SetCullFace(RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACE]));
326- }
327- }
328-
329-#undef RS_VALUE
330- }
331-
332 }
333
334
335=== modified file 'NuxGraphics/GLRenderStates.h'
336--- NuxGraphics/GLRenderStates.h 2011-10-21 22:06:35 +0000
337+++ NuxGraphics/GLRenderStates.h 2012-02-21 06:59:17 +0000
338@@ -152,9 +152,6 @@
339 //! Check that all render states ar conform to the default
340 void CheckRenderStatesConformity();
341
342-
343- void SetRenderStates(unsigned int rs, unsigned int value);
344-
345 // Render states
346 inline void SetAlphaTest(
347 bool EnableAlphaTest_,
348@@ -346,8 +343,8 @@
349 inline void HW__SetPolygonOffset(float Factor, float Units);
350
351 private:
352- RenderStateMap m_RenderStateChanges[GFXRS_MAX_RENDERSTATES];
353- RenderStateMap m_SamplerStateChanges[4][GFXSS_MAX_SAMPLERSTATES];
354+ RenderStateMap render_state_changes_[GFXRS_MAX_RENDERSTATES];
355+ RenderStateMap sampler_state_changes_[4][GFXSS_MAX_SAMPLERSTATES];
356 };
357
358
359@@ -366,13 +363,13 @@
360 {
361 if (EnableAlphaTest_)
362 {
363- if (!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTENABLE]))
364+ if (!RS_VALUE(render_state_changes_[GFXRS_ALPHATESTENABLE]))
365 {
366 HW__EnableAlphaTest(TRUE);
367 }
368
369- if ((RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTFUNC]) != AlphaTestFunc_) ||
370- (RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTREF]) != AlphaTestRef_))
371+ if ((RS_VALUE(render_state_changes_[GFXRS_ALPHATESTFUNC]) != AlphaTestFunc_) ||
372+ (RS_VALUE(render_state_changes_[GFXRS_ALPHATESTREF]) != AlphaTestRef_))
373 {
374 HW__SetAlphaTestFunc(AlphaTestFunc_, AlphaTestRef_);
375 }
376@@ -388,14 +385,14 @@
377 {
378 if (AlphaBlendEnable_)
379 {
380- if (!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
381+ if (!RS_VALUE(render_state_changes_[GFXRS_ALPHABLENDENABLE]))
382 {
383 HW__EnableAlphaBlend(TRUE);
384 }
385 }
386 else
387 {
388- if (RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
389+ if (RS_VALUE(render_state_changes_[GFXRS_ALPHABLENDENABLE]))
390 {
391 HW__EnableAlphaBlend(GL_FALSE);
392 }
393@@ -408,8 +405,8 @@
394 {
395 SetBlend(AlphaBlendEnable_);
396
397- if ((RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
398- (RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_))
399+ if ((RS_VALUE(render_state_changes_[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
400+ (RS_VALUE(render_state_changes_[GFXRS_DESTBLEND]) != DestBlendFactor_))
401 {
402 HW__SetSeparateAlphaBlendFactors(
403 SrcBlendFactor_,
404@@ -423,9 +420,9 @@
405 unsigned int& SrcBlendFactor_,
406 unsigned int& DestBlendFactor_)
407 {
408- AlphaBlendEnable_ = RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]);
409- SrcBlendFactor_ = RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND]);
410- DestBlendFactor_ = RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]);
411+ AlphaBlendEnable_ = RS_VALUE(render_state_changes_[GFXRS_ALPHABLENDENABLE]);
412+ SrcBlendFactor_ = RS_VALUE(render_state_changes_[GFXRS_SRCBLEND]);
413+ DestBlendFactor_ = RS_VALUE(render_state_changes_[GFXRS_DESTBLEND]);
414 }
415
416 inline void GpuRenderStates::SetSeparateBlend(bool EnableSeparateAlphaBlend,
417@@ -438,15 +435,15 @@
418
419 // if (EnableSeparateAlphaBlend)
420 // {
421-// if (!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
422+// if (!RS_VALUE(render_state_changes_[GFXRS_ALPHABLENDENABLE]))
423 // {
424 // HW__EnableAlphaBlend(TRUE);
425 // }
426
427- if ((RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
428- (RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_) ||
429- (RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLENDALPHA]) != SrcBlendFactorAlpha_) ||
430- (RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLENDALPHA]) != DestBlendFactorAlpha_))
431+ if ((RS_VALUE(render_state_changes_[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
432+ (RS_VALUE(render_state_changes_[GFXRS_DESTBLEND]) != DestBlendFactor_) ||
433+ (RS_VALUE(render_state_changes_[GFXRS_SRCBLENDALPHA]) != SrcBlendFactorAlpha_) ||
434+ (RS_VALUE(render_state_changes_[GFXRS_DESTBLENDALPHA]) != DestBlendFactorAlpha_))
435 {
436 HW__SetSeparateAlphaBlendFactors(
437 SrcBlendFactor_,
438@@ -490,9 +487,9 @@
439 { GL_ONE, GL_ONE } // PLUS
440 };
441
442- if ((RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND]) !=
443+ if ((RS_VALUE(render_state_changes_[GFXRS_SRCBLEND]) !=
444 factor[op].src_blend) ||
445- (RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]) !=
446+ (RS_VALUE(render_state_changes_[GFXRS_DESTBLEND]) !=
447 factor[op].dst_blend))
448 {
449 HW__SetSeparateAlphaBlendFactors
450@@ -503,7 +500,7 @@
451
452 inline void GpuRenderStates::SetBlendOp(unsigned int BlendOp)
453 {
454- if ((RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOp))
455+ if ((RS_VALUE(render_state_changes_[GFXRS_BLENDOP]) != BlendOp))
456 {
457 HW__SetAlphaBlendOp(BlendOp, BlendOp);
458 }
459@@ -513,8 +510,8 @@
460 unsigned int BlendOpRGB_,
461 unsigned int BlendOpAlpha_)
462 {
463- if ((RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOpRGB_) ||
464- (RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA]) != BlendOpAlpha_))
465+ if ((RS_VALUE(render_state_changes_[GFXRS_BLENDOP]) != BlendOpRGB_) ||
466+ (RS_VALUE(render_state_changes_[GFXRS_BLENDOPALPHA]) != BlendOpAlpha_))
467 {
468 HW__SetAlphaBlendOp(BlendOpRGB_, BlendOpAlpha_);
469 }
470@@ -526,17 +523,17 @@
471 {
472 if (EnableCullFace)
473 {
474- if (!RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACEENABLE]))
475+ if (!RS_VALUE(render_state_changes_[GFXRS_CULLFACEENABLE]))
476 {
477 HW__EnableCulling(TRUE);
478 }
479
480- if (RS_VALUE(m_RenderStateChanges[GFXRS_FRONTFACE]) != FrontFace_)
481+ if (RS_VALUE(render_state_changes_[GFXRS_FRONTFACE]) != FrontFace_)
482 {
483 HW__SetFrontFace(FrontFace_);
484 }
485
486- if (RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACE]) != Cullface_)
487+ if (RS_VALUE(render_state_changes_[GFXRS_CULLFACE]) != Cullface_)
488 {
489 HW__SetCullFace(Cullface_);
490 }
491@@ -555,17 +552,17 @@
492 {
493 if (EnableDepthTest)
494 {
495- if (!RS_VALUE(m_RenderStateChanges[GFXRS_ZTESTENABLE]))
496+ if (!RS_VALUE(render_state_changes_[GFXRS_ZTESTENABLE]))
497 {
498 HW__SetEnableDepthTest(TRUE);
499 }
500
501- if (RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != WriteEnable_)
502+ if (RS_VALUE(render_state_changes_[GFXRS_ZWRITEENABLE]) != WriteEnable_)
503 {
504 HW__SetDepthMask(WriteEnable_);
505 }
506
507- if (RS_VALUE(m_RenderStateChanges[GFXRS_ZFUNC]) != DepthFunc_)
508+ if (RS_VALUE(render_state_changes_[GFXRS_ZFUNC]) != DepthFunc_)
509 {
510 HW__SetDepthFunc(DepthFunc_);
511 }
512@@ -580,8 +577,8 @@
513
514 inline void GpuRenderStates::SetDepthRange(float zNear, float zFar)
515 {
516- if ((RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR]) != static_cast<unsigned int> (zNear)) ||
517- (RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR]) != static_cast<unsigned int> (zFar)))
518+ if ((RS_VALUE(render_state_changes_[GFXRS_ZNEAR]) != static_cast<unsigned int> (zNear)) ||
519+ (RS_VALUE(render_state_changes_[GFXRS_ZFAR]) != static_cast<unsigned int> (zFar)))
520 {
521 HW__SetDepthRange(zNear, zFar);
522 }
523@@ -591,7 +588,7 @@
524 {
525 if (enable_stencil)
526 {
527- if (!RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE]))
528+ if (!RS_VALUE(render_state_changes_[GFXRS_STENCILENABLE]))
529 {
530 HW__EnableStencil(TRUE);
531 }
532@@ -605,9 +602,9 @@
533 void GpuRenderStates::SetStencilFunc(unsigned int func, int ref, unsigned int mask)
534 {
535 if (
536- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]) != func) ||
537- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != (unsigned int)ref) ||
538- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != mask)
539+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFUNC]) != func) ||
540+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILREF]) != (unsigned int)ref) ||
541+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILMASK]) != mask)
542 )
543 {
544 HW__SetStencilFunc(func, ref, mask);
545@@ -617,9 +614,9 @@
546 void GpuRenderStates::SetStencilOp(unsigned int stencil_fail, unsigned int stencil_pass_depth_fail, unsigned int stencil_pass_depth_pass)
547 {
548 if (
549- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != stencil_fail) ||
550- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]) != stencil_pass_depth_fail) ||
551- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) != stencil_pass_depth_pass)
552+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFAIL]) != stencil_fail) ||
553+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZFAIL]) != stencil_pass_depth_fail) ||
554+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZPASS]) != stencil_pass_depth_pass)
555 )
556 {
557 HW__SetStencilOp(stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
558@@ -638,18 +635,18 @@
559 {
560 if (EnableStencil_)
561 {
562- if (!RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE]))
563+ if (!RS_VALUE(render_state_changes_[GFXRS_STENCILENABLE]))
564 {
565 HW__EnableStencil(TRUE);
566 }
567
568 if (
569- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]) != Func_) ||
570- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != Ref_) ||
571- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != Mask_) ||
572- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != FailOp_) ||
573- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]) != ZFailOp_) ||
574- (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) != ZPassOp_)
575+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFUNC]) != Func_) ||
576+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILREF]) != Ref_) ||
577+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILMASK]) != Mask_) ||
578+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFAIL]) != FailOp_) ||
579+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZFAIL]) != ZFailOp_) ||
580+ (RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZPASS]) != ZPassOp_)
581 )
582 {
583 HW__SetFrontFaceStencilFunc(Func_, Ref_, Mask_);
584@@ -675,23 +672,23 @@
585 {
586 if (EnableTwoSideStencil_)
587 {
588- if (!RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE]))
589+ if (!RS_VALUE(render_state_changes_[GFXRS_STENCILENABLE]))
590 {
591 HW__EnableStencil(TRUE);
592 }
593
594- if (!RS_VALUE(m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE]))
595+ if (!RS_VALUE(render_state_changes_[GFXRS_TWOSIDEDSTENCILENABLE]))
596 {
597 HW__EnableTwoSidedStencil(TRUE);
598 }
599
600 if (
601- (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFUNC]) != Func_) ||
602- (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILREF]) != Ref_) ||
603- (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILMASK]) != Mask_) ||
604- (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFAIL]) != FailOp_) ||
605- (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL]) != ZFailOp_) ||
606- (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZPASS]) != ZPassOp_)
607+ (RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILFUNC]) != Func_) ||
608+ (RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILREF]) != Ref_) ||
609+ (RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILMASK]) != Mask_) ||
610+ (RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILFAIL]) != FailOp_) ||
611+ (RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILZFAIL]) != ZFailOp_) ||
612+ (RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILZPASS]) != ZPassOp_)
613 )
614 {
615 HW__SetBackFaceStencilFunc(Func_, Ref_, Mask_);
616@@ -726,13 +723,13 @@
617 {
618 if (EnableLineSmooth)
619 {
620- if (!RS_VALUE(m_RenderStateChanges[GFXRS_LINESMOOTHENABLE]))
621+ if (!RS_VALUE(render_state_changes_[GFXRS_LINESMOOTHENABLE]))
622 {
623 HW__EnableLineSmooth(GL_TRUE);
624 }
625
626- if ((RS_VALUE(m_RenderStateChanges[GFXRS_LINEWIDTH]) != LineWidth) ||
627- (RS_VALUE(m_RenderStateChanges[GFXRS_LINEHINT]) != Hint))
628+ if ((RS_VALUE(render_state_changes_[GFXRS_LINEWIDTH]) != LineWidth) ||
629+ (RS_VALUE(render_state_changes_[GFXRS_LINEHINT]) != Hint))
630 {
631 HW__SetLineWidth(LineWidth, Hint);
632 }
633@@ -751,13 +748,13 @@
634 {
635 if (EnablePointSmooth)
636 {
637- if (!RS_VALUE(m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE]))
638+ if (!RS_VALUE(render_state_changes_[GFXRS_POINTSMOOTHENABLE]))
639 {
640 HW__EnablePointSmooth(GL_TRUE);
641 }
642
643- if ((RS_VALUE(m_RenderStateChanges[GFXRS_POINTSIZE]) != PointSize) ||
644- (RS_VALUE(m_RenderStateChanges[GFXRS_POINTHINT]) != Hint))
645+ if ((RS_VALUE(render_state_changes_[GFXRS_POINTSIZE]) != PointSize) ||
646+ (RS_VALUE(render_state_changes_[GFXRS_POINTHINT]) != Hint))
647 {
648 HW__SetLineWidth(PointSize, Hint);
649 }
650@@ -775,10 +772,10 @@
651 unsigned int bBlue,
652 unsigned int bAlpha)
653 {
654- if ((RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]) != bRed) ||
655- (RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]) != bGreen) ||
656- (RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]) != bBlue) ||
657- (RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]) != bAlpha))
658+ if ((RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_R]) != bRed) ||
659+ (RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_G]) != bGreen) ||
660+ (RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_B]) != bBlue) ||
661+ (RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_A]) != bAlpha))
662 {
663 HW__SetColorMask(bRed, bGreen, bBlue, bAlpha);
664 }
665@@ -791,15 +788,15 @@
666 unsigned int& bBlue,
667 unsigned int& bAlpha)
668 {
669- bRed = RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]);
670- bGreen = RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]);
671- bBlue = RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]);
672- bAlpha = RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]);
673+ bRed = RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_R]);
674+ bGreen = RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_G]);
675+ bBlue = RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_B]);
676+ bAlpha = RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_A]);
677 }
678
679 inline void GpuRenderStates::SetDepthMask(unsigned int bDepth)
680 {
681- if ((RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != bDepth))
682+ if ((RS_VALUE(render_state_changes_[GFXRS_ZWRITEENABLE]) != bDepth))
683 {
684 HW__SetDepthMask(bDepth);
685 }
686@@ -807,7 +804,7 @@
687
688 inline void GpuRenderStates::EnableScissor(unsigned int bScissor)
689 {
690- if ((RS_VALUE(m_RenderStateChanges[GFXRS_SCISSORTESTENABLE]) != bScissor))
691+ if ((RS_VALUE(render_state_changes_[GFXRS_SCISSORTESTENABLE]) != bScissor))
692 {
693 HW__EnableScissor(bScissor);
694 }
695@@ -815,7 +812,7 @@
696
697 inline void GpuRenderStates::EnableFog(unsigned int bFog)
698 {
699- if ((RS_VALUE(m_RenderStateChanges[GFXRS_FOGENABLE]) != bFog))
700+ if ((RS_VALUE(render_state_changes_[GFXRS_FOGENABLE]) != bFog))
701 {
702 HW__EnableFog(bFog);
703 }
704@@ -823,8 +820,8 @@
705
706 inline void GpuRenderStates::SetPolygonMode(unsigned int FrontMode, unsigned int BackMode)
707 {
708- if ((RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]) != FrontMode) ||
709- (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]) != BackMode))
710+ if ((RS_VALUE(render_state_changes_[GFXRS_FRONT_POLYGONMODE]) != FrontMode) ||
711+ (RS_VALUE(render_state_changes_[GFXRS_BACK_POLYGONMODE]) != BackMode))
712 {
713 HW__SetPolygonMode(FrontMode, BackMode);
714 }
715@@ -835,13 +832,13 @@
716 {
717 if (bEnable)
718 {
719- if (!RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETENABLE]))
720+ if (!RS_VALUE(render_state_changes_[GFXRS_POLYGONOFFSETENABLE]))
721 {
722 HW__EnablePolygonOffset(GL_TRUE);
723 }
724
725- if ((RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]) != static_cast<unsigned int> (Factor)) ||
726- (RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]) != static_cast<unsigned int> (Units)))
727+ if ((RS_VALUE(render_state_changes_[GFXRS_POLYGONOFFSETFACTOR]) != static_cast<unsigned int> (Factor)) ||
728+ (RS_VALUE(render_state_changes_[GFXRS_POLYGONOFFSETUNITS]) != static_cast<unsigned int> (Units)))
729 {
730 HW__SetPolygonOffset(Factor, Units);
731 }
732@@ -866,7 +863,7 @@
733 CHECKGL(glDisable(GL_ALPHA_TEST));
734 }
735
736- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTENABLE], b ? GL_TRUE : GL_FALSE);
737+ SET_RS_VALUE(render_state_changes_[GFXRS_ALPHATESTENABLE], b ? GL_TRUE : GL_FALSE);
738 #endif
739 }
740
741@@ -886,8 +883,8 @@
742 "Error(HW__SetAlphaTestFunc): Invalid Alpha Test Function RenderState");
743
744 CHECKGL(glAlphaFunc(AlphaTestFunc_, (float) AlphaTestRef_ * (1.0f / 255.0f)));
745- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTFUNC], AlphaTestFunc_);
746- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTREF], AlphaTestRef_);
747+ SET_RS_VALUE(render_state_changes_[GFXRS_ALPHATESTFUNC], AlphaTestFunc_);
748+ SET_RS_VALUE(render_state_changes_[GFXRS_ALPHATESTREF], AlphaTestRef_);
749 #endif
750 }
751
752@@ -902,7 +899,7 @@
753 CHECKGL(glDisable(GL_BLEND));
754 }
755
756- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE], b ? GL_TRUE : GL_FALSE);
757+ SET_RS_VALUE(render_state_changes_[GFXRS_ALPHABLENDENABLE], b ? GL_TRUE : GL_FALSE);
758 }
759
760 inline void GpuRenderStates::HW__SetSeparateAlphaBlendFactors(
761@@ -926,10 +923,10 @@
762 SrcFactorAlpha_,
763 DestFactorAlpha_));
764
765- SET_RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND], SrcBlendFactor_);
766- SET_RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND], DestBlendFactor_);
767- SET_RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLENDALPHA], SrcFactorAlpha_);
768- SET_RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLENDALPHA], DestFactorAlpha_);
769+ SET_RS_VALUE(render_state_changes_[GFXRS_SRCBLEND], SrcBlendFactor_);
770+ SET_RS_VALUE(render_state_changes_[GFXRS_DESTBLEND], DestBlendFactor_);
771+ SET_RS_VALUE(render_state_changes_[GFXRS_SRCBLENDALPHA], SrcFactorAlpha_);
772+ SET_RS_VALUE(render_state_changes_[GFXRS_DESTBLENDALPHA], DestFactorAlpha_);
773 }
774
775 inline void GpuRenderStates::HW__SetAlphaBlendOp(
776@@ -980,8 +977,8 @@
777 }
778 #endif
779
780- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP], BlendOpRGB_);
781- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA], BlendOpAlpha_);
782+ SET_RS_VALUE(render_state_changes_[GFXRS_BLENDOP], BlendOpRGB_);
783+ SET_RS_VALUE(render_state_changes_[GFXRS_BLENDOPALPHA], BlendOpAlpha_);
784 }
785
786 inline void GpuRenderStates::HW__EnableCulling(unsigned int b)
787@@ -995,7 +992,7 @@
788 CHECKGL(glDisable(GL_CULL_FACE));
789 }
790
791- SET_RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACEENABLE], b ? GL_TRUE : GL_FALSE);
792+ SET_RS_VALUE(render_state_changes_[GFXRS_CULLFACEENABLE], b ? GL_TRUE : GL_FALSE);
793 }
794
795
796@@ -1007,7 +1004,7 @@
797 "Error(HW__SetFrontFace): Invalid Front Face RenderState");
798
799 CHECKGL(glFrontFace(FrontFace_));
800- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONTFACE], FrontFace_);
801+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONTFACE], FrontFace_);
802 }
803
804 inline void GpuRenderStates::HW__SetCullFace(unsigned int CullFace_)
805@@ -1019,7 +1016,7 @@
806 "Error(HW__SetCullFace): Invalid Cull Face RenderState");
807
808 CHECKGL(glCullFace(CullFace_));
809- SET_RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACE], CullFace_);
810+ SET_RS_VALUE(render_state_changes_[GFXRS_CULLFACE], CullFace_);
811 }
812
813 inline void GpuRenderStates::HW__SetEnableDepthTest(unsigned int b)
814@@ -1033,14 +1030,14 @@
815 CHECKGL(glDisable(GL_DEPTH_TEST));
816 }
817
818- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZTESTENABLE], b ? GL_TRUE : GL_FALSE);
819+ SET_RS_VALUE(render_state_changes_[GFXRS_ZTESTENABLE], b ? GL_TRUE : GL_FALSE);
820 }
821
822 inline void GpuRenderStates::HW__SetDepthRange(float zNear, float zFar)
823 {
824 CHECKGL(glDepthRange(zNear, zFar));
825- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR], static_cast<unsigned int> (Clamp(zNear, 0.0f, 1.0f)));
826- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR], static_cast<unsigned int> (Clamp(zFar, 0.0f, 1.0f)));
827+ SET_RS_VALUE(render_state_changes_[GFXRS_ZNEAR], static_cast<unsigned int> (Clamp(zNear, 0.0f, 1.0f)));
828+ SET_RS_VALUE(render_state_changes_[GFXRS_ZFAR], static_cast<unsigned int> (Clamp(zFar, 0.0f, 1.0f)));
829 }
830
831 inline void GpuRenderStates::HW__SetDepthFunc(unsigned int Func)
832@@ -1057,7 +1054,7 @@
833 "Error(HW__SetDepthFunc): Invalid Depth Func RenderState");
834
835 CHECKGL(glDepthFunc(Func));
836- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZFUNC], Func);
837+ SET_RS_VALUE(render_state_changes_[GFXRS_ZFUNC], Func);
838 }
839
840 inline void GpuRenderStates::HW__EnableStencil(unsigned int b)
841@@ -1071,7 +1068,7 @@
842 CHECKGL(glDisable(GL_STENCIL_TEST));
843 }
844
845- SET_RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE], b ? GL_TRUE : GL_FALSE);
846+ SET_RS_VALUE(render_state_changes_[GFXRS_STENCILENABLE], b ? GL_TRUE : GL_FALSE);
847 }
848
849 inline void GpuRenderStates::HW__SetStencilFunc(unsigned int func, int ref, unsigned int mask)
850@@ -1089,9 +1086,9 @@
851
852 CHECKGL(glStencilFunc(func, ref, mask));
853
854- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC], func);
855- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF], ref);
856- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], mask);
857+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFUNC], func);
858+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILREF], ref);
859+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILMASK], mask);
860 }
861
862 inline void GpuRenderStates::HW__SetStencilOp(unsigned int stencil_fail, unsigned int stencil_pass_depth_fail, unsigned int stencil_pass_depth_pass)
863@@ -1131,9 +1128,9 @@
864
865 CHECKGL(glStencilOp(stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass));
866
867- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL], stencil_fail);
868- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL], stencil_pass_depth_fail);
869- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS], stencil_pass_depth_pass);
870+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFAIL], stencil_fail);
871+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZFAIL], stencil_pass_depth_fail);
872+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZPASS], stencil_pass_depth_pass);
873 }
874
875 #if 0
876@@ -1162,21 +1159,21 @@
877 }
878 }
879
880- SET_RS_VALUE(m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE], b ? GL_TRUE : GL_FALSE);
881+ SET_RS_VALUE(render_state_changes_[GFXRS_TWOSIDEDSTENCILENABLE], b ? GL_TRUE : GL_FALSE);
882 }
883
884 inline void GpuRenderStates::HW__SetStencilFrontFaceWriteMask(unsigned int WriteMask_)
885 {
886 CHECKGL(glActiveStencilFaceEXT(GL_FRONT));
887 CHECKGL(glStencilMask(WriteMask_));
888- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK], WriteMask_);
889+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILWRITEMASK], WriteMask_);
890 }
891
892 inline void GpuRenderStates::HW__SetStencilBackFaceWriteMask(unsigned int WriteMask_)
893 {
894 CHECKGL(glActiveStencilFaceEXT(GL_BACK));
895 CHECKGL(glStencilMask(WriteMask_));
896- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK], WriteMask_);
897+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILWRITEMASK], WriteMask_);
898 }
899
900 inline void GpuRenderStates::HW__SetFrontFaceStencilFunc(unsigned int Func_,
901@@ -1197,9 +1194,9 @@
902 CHECKGL(glActiveStencilFaceEXT(GL_FRONT));
903 CHECKGL(glStencilFunc(Func_, Ref_, Mask_));
904
905- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC], Func_);
906- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF], Ref_);
907- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], Mask_);
908+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFUNC], Func_);
909+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILREF], Ref_);
910+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILMASK], Mask_);
911 }
912
913 inline void GpuRenderStates::HW__SetBackFaceStencilFunc(
914@@ -1228,9 +1225,9 @@
915 CHECKGL(glStencilFunc(Func_, Ref_, Mask_));
916 }
917
918- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFUNC], Func_);
919- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILREF], Ref_);
920- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILMASK], Mask_);
921+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILFUNC], Func_);
922+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILREF], Ref_);
923+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILMASK], Mask_);
924 }
925
926 inline void GpuRenderStates::HW__SetFrontFaceStencilOp(
927@@ -1281,9 +1278,9 @@
928 CHECKGL(glStencilOp(FailOp_, ZFailOp_, ZPassOp_));
929 }
930
931- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL], FailOp_);
932- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL], ZFailOp_);
933- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS], ZPassOp_);
934+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILFAIL], FailOp_);
935+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZFAIL], ZFailOp_);
936+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_STENCILZPASS], ZPassOp_);
937 }
938
939 inline void GpuRenderStates::HW__SetBackFaceStencilOp(
940@@ -1334,9 +1331,9 @@
941 CHECKGL(glStencilOp(FailOp_, ZFailOp_, ZPassOp_));
942 }
943
944- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFAIL], FailOp_);
945- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL], ZFailOp_);
946- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZPASS], ZPassOp_);
947+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILFAIL], FailOp_);
948+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILZFAIL], ZFailOp_);
949+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_STENCILZPASS], ZPassOp_);
950 }
951 #endif
952
953@@ -1352,7 +1349,7 @@
954 CHECKGL(glDisable(GL_LINE_SMOOTH));
955 }
956
957- SET_RS_VALUE(m_RenderStateChanges[GFXRS_LINESMOOTHENABLE], EnableLineSmooth ? GL_TRUE : GL_FALSE);
958+ SET_RS_VALUE(render_state_changes_[GFXRS_LINESMOOTHENABLE], EnableLineSmooth ? GL_TRUE : GL_FALSE);
959 #endif
960 }
961
962@@ -1365,11 +1362,11 @@
963 "Error(HW__SetLineWidth): Invalid Line Hint RenderState");
964
965 CHECKGL(glLineWidth(width));
966- SET_RS_VALUE(m_RenderStateChanges[GFXRS_LINEWIDTH], width);
967+ SET_RS_VALUE(render_state_changes_[GFXRS_LINEWIDTH], width);
968
969 #ifndef NUX_OPENGLES_20
970 CHECKGL(glHint(GL_LINE_SMOOTH_HINT, Hint));
971- SET_RS_VALUE(m_RenderStateChanges[GFXRS_LINEHINT], Hint);
972+ SET_RS_VALUE(render_state_changes_[GFXRS_LINEHINT], Hint);
973 #endif
974 }
975
976@@ -1385,7 +1382,7 @@
977 CHECKGL(glDisable(GL_POINT_SMOOTH));
978 }
979
980- SET_RS_VALUE(m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE], EnablePointSmooth ? GL_TRUE : GL_FALSE);
981+ SET_RS_VALUE(render_state_changes_[GFXRS_POINTSMOOTHENABLE], EnablePointSmooth ? GL_TRUE : GL_FALSE);
982 #endif
983 }
984
985@@ -1400,8 +1397,8 @@
986
987 CHECKGL(glPointSize(size));
988 CHECKGL(glHint(GL_POINT_SMOOTH_HINT, Hint);)
989- SET_RS_VALUE(m_RenderStateChanges[GFXRS_POINTSIZE], size);
990- SET_RS_VALUE(m_RenderStateChanges[GFXRS_POINTHINT], Hint);
991+ SET_RS_VALUE(render_state_changes_[GFXRS_POINTSIZE], size);
992+ SET_RS_VALUE(render_state_changes_[GFXRS_POINTHINT], Hint);
993 #endif
994 }
995
996@@ -1412,16 +1409,16 @@
997 unsigned int bAlpha)
998 {
999 CHECKGL(glColorMask(bRed, bGreen, bBlue, bAlpha));
1000- SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R], bRed);
1001- SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G], bGreen);
1002- SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B], bBlue);
1003- SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A], bAlpha);
1004+ SET_RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_R], bRed);
1005+ SET_RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_G], bGreen);
1006+ SET_RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_B], bBlue);
1007+ SET_RS_VALUE(render_state_changes_[GFXRS_COLORWRITEENABLE_A], bAlpha);
1008 }
1009
1010 inline void GpuRenderStates::HW__SetDepthMask(unsigned int bDepth)
1011 {
1012 CHECKGL(glDepthMask(bDepth));
1013- SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE], bDepth);
1014+ SET_RS_VALUE(render_state_changes_[GFXRS_ZWRITEENABLE], bDepth);
1015 }
1016
1017 inline void GpuRenderStates::HW__EnableScissor(unsigned int bScissor)
1018@@ -1435,7 +1432,7 @@
1019 CHECKGL(glDisable(GL_SCISSOR_TEST));
1020 }
1021
1022- SET_RS_VALUE(m_RenderStateChanges[GFXRS_SCISSORTESTENABLE], bScissor ? GL_TRUE : GL_FALSE);
1023+ SET_RS_VALUE(render_state_changes_[GFXRS_SCISSORTESTENABLE], bScissor ? GL_TRUE : GL_FALSE);
1024 }
1025
1026 inline void GpuRenderStates::HW__EnableFog(unsigned int bFog)
1027@@ -1450,7 +1447,7 @@
1028 CHECKGL(glDisable(GL_FOG));
1029 }
1030
1031- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FOGENABLE], bFog ? GL_TRUE : GL_FALSE);
1032+ SET_RS_VALUE(render_state_changes_[GFXRS_FOGENABLE], bFog ? GL_TRUE : GL_FALSE);
1033 #endif
1034 }
1035
1036@@ -1472,8 +1469,8 @@
1037 CHECKGL(glPolygonMode(GL_FRONT, FrontMode));
1038 CHECKGL(glPolygonMode(GL_BACK, BackMode));
1039
1040- SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE], FrontMode);
1041- SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_POLYGONMODE], BackMode);
1042+ SET_RS_VALUE(render_state_changes_[GFXRS_FRONT_POLYGONMODE], FrontMode);
1043+ SET_RS_VALUE(render_state_changes_[GFXRS_BACK_POLYGONMODE], BackMode);
1044 #endif
1045 }
1046
1047@@ -1488,15 +1485,15 @@
1048 CHECKGL(glDisable(GL_POLYGON_OFFSET_FILL));
1049 }
1050
1051- SET_RS_VALUE(m_RenderStateChanges[GL_POLYGON_OFFSET_FILL], EnablePolygonOffset ? GL_TRUE : GL_FALSE);
1052+ SET_RS_VALUE(render_state_changes_[GL_POLYGON_OFFSET_FILL], EnablePolygonOffset ? GL_TRUE : GL_FALSE);
1053 }
1054
1055 inline void GpuRenderStates::HW__SetPolygonOffset(float Factor, float Units)
1056 {
1057 CHECKGL(glPolygonOffset(Factor, Units));
1058
1059- SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR], static_cast<unsigned int> (Factor));
1060- SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS], static_cast<unsigned int> (Units));
1061+ SET_RS_VALUE(render_state_changes_[GFXRS_POLYGONOFFSETFACTOR], static_cast<unsigned int> (Factor));
1062+ SET_RS_VALUE(render_state_changes_[GFXRS_POLYGONOFFSETUNITS], static_cast<unsigned int> (Units));
1063 }
1064
1065 #undef SET_RS_VALUE
1066
1067=== modified file 'configure.ac'
1068--- configure.ac 2012-02-20 16:48:05 +0000
1069+++ configure.ac 2012-02-21 06:59:17 +0000
1070@@ -22,7 +22,7 @@
1071 # The number format is : year/month/day
1072 # e.g.: december 5th, 2011 is: 20111205
1073 # To make more than one API change in a day, add a number to the date. Like 20111205.xx
1074-m4_define([nux_abi_version], [20120219.01])
1075+m4_define([nux_abi_version], [20120221.01])
1076
1077 m4_define([nux_version],
1078 [nux_major_version.nux_minor_version.nux_micro_version])

Subscribers

People subscribed via source and target branches

to all changes: