« back to all changes in this revision
Viewing changes to NuxGraphics/GLRenderStates.h
- browse files at revision 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: Neil Jagdish Patel
- Date: 2010-09-01 21:15:42 UTC
- Revision ID: neil.patel@canonical.com-20100901211542-cw2ce3ak28unouwb
Add NuxGraphics with licensing
- files added:
- NuxGraphics
- files modified:
- Makefile.am
added
removed
NuxGraphics/GLRenderStates.h
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
#ifndef GLRENDERSTATES_H
24
#define GLRENDERSTATES_H
25
26
#include "NuxCore/NKernel.h"
27
28
NAMESPACE_BEGIN_OGL
29
30
enum
31
{
32
GFXRS_FRONT_POLYGONMODE, // GL_FILL
33
GFXRS_BACK_POLYGONMODE, // GL_FILL
34
GFXRS_CULLFACEENABLE, // GL_FALSE
35
GFXRS_CULLFACE, // GL_BACK
36
GFXRS_FRONTFACE, // GL_CCW
37
38
GFXRS_SCISSORTESTENABLE, // GL_FALSE
39
GFXRS_FOGENABLE, // GL_FALSE
40
41
GFXRS_ZTESTENABLE, // GL_TRUE
42
GFXRS_ZWRITEENABLE, // GL_TRUE
43
GFXRS_ZFUNC, // GL_LESS
44
GFXRS_ZNEAR, // 0.0f
45
GFXRS_ZFAR, // 1.0f
46
47
GFXRS_ALPHABLENDENABLE, // GL_FALSE
48
GFXRS_BLENDOP, // GL_FUNC_ADD
49
GFXRS_BLENDOPALPHA, // GL_FUNC_ADD
50
GFXRS_SRCBLEND, // GL_ONE
51
GFXRS_DESTBLEND, // GL_ZERO
52
GFXRS_SRCBLENDALPHA, // GL_ONE
53
GFXRS_DESTBLENDALPHA, // GL_ZERO
54
55
GFXRS_ALPHATESTENABLE, // GL_FALSE
56
GFXRS_ALPHATESTREF, // 0x0
57
GFXRS_ALPHATESTFUNC, // GL_ALWAYS
58
59
GFXRS_STENCILENABLE, // GL_FALSE
60
GFXRS_TWOSIDEDSTENCILENABLE, // GL_FALSE
61
GFXRS_FRONT_STENCILWRITEMASK, // 0xFFFFFFFF
62
GFXRS_BACK_STENCILWRITEMASK, // 0xFFFFFFFF
63
64
GFXRS_FRONT_STENCILFUNC, // GL_ALWAYS
65
GFXRS_FRONT_STENCILREF, // 0x0
66
GFXRS_FRONT_STENCILMASK, // 0xFF
67
GFXRS_FRONT_STENCILFAIL, // GL_KEEP
68
GFXRS_FRONT_STENCILZFAIL, // GL_KEEP
69
GFXRS_FRONT_STENCILZPASS, // GL_KEEP
70
71
GFXRS_BACK_STENCILFUNC, // GL_ALWAYS
72
GFXRS_BACK_STENCILREF, // 0x0
73
GFXRS_BACK_STENCILMASK, // 0xFF
74
GFXRS_BACK_STENCILFAIL, // GL_KEEP
75
GFXRS_BACK_STENCILZFAIL, // GL_KEEP
76
GFXRS_BACK_STENCILZPASS, // GL_KEEP
77
78
79
GFXRS_POINTSMOOTHENABLE, // GL_FLASE
80
GFXRS_LINESMOOTHENABLE, // GL_FALSE
81
GFXRS_POINTSIZE, // 1.0f
82
GFXRS_LINEWIDTH, // 1.0f
83
GFXRS_POINTHINT, // GL_FASTEST
84
GFXRS_LINEHINT, // GL_FASTEST
85
86
GFXRS_COLORWRITEENABLE_R, // TRUE or FALSE
87
GFXRS_COLORWRITEENABLE_G, // TRUE or FALSE
88
GFXRS_COLORWRITEENABLE_B, // TRUE or FALSE
89
GFXRS_COLORWRITEENABLE_A, // TRUE or FALSE
90
91
GFXRS_POLYGONOFFSETENABLE, // GL_FALSE
92
GFXRS_POLYGONOFFSETFACTOR, // 0.0f
93
GFXRS_POLYGONOFFSETUNITS, // 0.0f
94
95
GFXRS_MAX_RENDERSTATES,
96
};
97
98
enum
99
{
100
GFXSS_ADDRESSU,
101
GFXSS_ADDRESSV,
102
GFXSS_ADDRESSW,
103
GFXSS_MINFILTER,
104
GFXSS_MAGFILTER,
105
GFXSS_MIPMAPFILTER,
106
GFXSS_MIPMAPLODBIAS,
107
GFXSS_MAXANISOTROPY,
108
GFXSS_SRGBWRITEENABLE,
109
110
GFXSS_MAX_SAMPLERSTATES,
111
};
112
113
typedef enum
114
{
115
BOARD_UNKNOWN = 0,
116
BOARD_ATI,
117
BOARD_NVIDIA,
118
BOARD_INTEL,
119
} eGraphicsBoardVendor;
120
121
struct RenderStateMap
122
{
123
UBOOL Checked;
124
UINT State;
125
UINT iValue;
126
FLOAT fValue;
127
};
128
129
class GLRenderStates
130
{
131
public:
132
GLRenderStates(eGraphicsBoardVendor board);
133
~GLRenderStates();
134
135
void ResetDefault();
136
void ResetStateChangeToDefault();
137
void CommitStateChangeToDefault();
138
void CheckStateChange();
139
140
void SubmitChangeStates();
141
//! Check that all render states ar conform to the default
142
void CheckRenderStatesConformity();
143
144
145
void SetRenderStates(UINT rs, UINT value);
146
147
// Render states
148
inline void SetAlphaTest(
149
UBOOL EnableAlphaTest_,
150
DWORD AlphaTestFunc_ = GL_ALWAYS,
151
BYTE AlphaTestRef_ = 0);
152
153
inline void SetBlend(UBOOL AlphaBlendEnable_);
154
inline void SetBlend(UBOOL AlphaBlendEnable_,
155
DWORD SrcBlendFactor_ /*= GL_ONE*/,
156
DWORD DestBlendFactor_ /*= GL_ZERO*/);
157
158
inline void SetSeparateBlend(UBOOL _bEnable,
159
DWORD SrcBlendFactor_ /*= GL_ONE*/,
160
DWORD DestBlendFactor_ /*= GL_ZERO*/,
161
DWORD SrcFactorAlpha_ /*= GL_ONE*/,
162
DWORD DestFactorAlpha_ /*= GL_ZERO*/);
163
164
inline void SetBlendOp(
165
DWORD BlendOp = GL_FUNC_ADD);
166
167
inline void SetSeparateBlendOp(
168
DWORD BlendOpRGB_ = GL_FUNC_ADD,
169
DWORD BlendOpAlpha_ = GL_FUNC_ADD);
170
171
inline void SetCullMode(UBOOL EnableCullFace,
172
DWORD FrontFace_ = GL_CCW,
173
DWORD Cullface_ = GL_BACK);
174
175
inline void SetDepthTest(UBOOL EnableDepthTest,
176
UBOOL WriteEnable_ = GL_TRUE,
177
DWORD DepthFunc_ = GL_LEQUAL);
178
179
inline void SetDepthRange(
180
FLOAT zNear = 0.0f,
181
FLOAT zFar = 1.0f);
182
183
// If two sided stencil is not activated, the setting is also used for the back face.
184
inline void SetStencilFrontFace(
185
UBOOL EnableStencil_, // GL_TRUE enable stencil test
186
DWORD Func_ = GL_ALWAYS,
187
DWORD FailOp_ = GL_KEEP,
188
DWORD ZFailOp_ = GL_KEEP,
189
DWORD ZPassOp_ = GL_KEEP,
190
DWORD Ref_ = 0,
191
DWORD Mask_ = 0xffffffff);
192
193
// Set stencil test for the back face.
194
inline void SetStencilBackFace(
195
UBOOL EnableTwoSideStencil_, // GL_TRUE enable Two Sided Stencil test
196
DWORD Func_ = GL_ALWAYS,
197
DWORD FailOp_ = GL_KEEP,
198
DWORD ZFailOp_ = GL_KEEP,
199
DWORD ZPassOp_ = GL_KEEP,
200
DWORD Ref_ = 0,
201
DWORD Mask_ = 0xffffffff);
202
203
inline void SetFrontFaceStencilWriteMask(
204
DWORD WriteMask_ = 0xffffffff);
205
206
inline void SetBackFaceStencilWriteMask(
207
DWORD WriteMask_ = 0xffffffff);
208
209
210
inline void EnableLineSmooth(
211
UBOOL EnableLineSmooth = TRUE,
212
UINT LineWidth = 1,
213
UINT HINT = GL_FASTEST);
214
215
inline void EnablePointSmooth(
216
UBOOL EnablePointSmooth = TRUE,
217
UINT PointSize = 1,
218
UINT HINT = GL_FASTEST);
219
220
inline void SetColorMask(
221
UBOOL bRed = TRUE,
222
UBOOL bGreen = TRUE,
223
UBOOL bBlue = TRUE,
224
UBOOL bAlpha = TRUE);
225
226
inline void SetDepthMask(UBOOL bDepth = TRUE);
227
228
inline void EnableScissor(UBOOL bScissor = FALSE);
229
inline void EnableFog(UBOOL bFog = FALSE);
230
inline void SetPolygonMode(UINT FrontMode = GL_FILL, UINT BackMode = GL_FILL);
231
232
inline void SetPolygonOffset(UBOOL bEnable,
233
FLOAT Factor = 0.0f, FLOAT Units = 0.0f);
234
235
private:
236
237
eGraphicsBoardVendor m_BoardVendor;
238
239
inline void HW__EnableAlphaTest(UBOOL b);
240
241
inline void HW__SetAlphaTestFunc(
242
DWORD AlphaTestFunc_,
243
BYTE AlphaTestRef_);
244
245
inline void HW__EnableAlphaBlend(UBOOL b);
246
247
inline void HW__SetSeparateAlphaBlend_Enable(UBOOL b);
248
249
inline void HW__SetSeparateAlphaBlendFactors(
250
DWORD SrcBlendFactor_,
251
DWORD DestBlendFactor_,
252
DWORD SrcFactorAlpha_,
253
DWORD DestFactorAlpha_);
254
255
inline void HW__SetAlphaBlendOp(DWORD BlendOpRGB_,
256
DWORD BlendOpAlpha_);
257
258
inline void HW__EnableCulling(UBOOL b);
259
260
inline void HW__SetFrontFace(DWORD FrontFace_);
261
262
inline void HW__SetCullFace(DWORD CullFace_);
263
264
inline void HW__SetEnableDepthTest(UBOOL b);
265
inline void HW__SetDepthFunc(DWORD Func);
266
inline void HW__SetDepthRange(FLOAT zNear, FLOAT zFar);
267
268
269
inline void HW__EnableStencil(UBOOL b);
270
inline void HW__EnableTwoSidedStencil(UBOOL b);
271
inline void HW__SetStencilFrontFaceWriteMask(DWORD WriteMask_);
272
inline void HW__SetStencilBackFaceWriteMask(DWORD WriteMask_);
273
274
inline void HW__SetFrontFaceStencilFunc(DWORD Func_,
275
DWORD Ref_,
276
DWORD Mask_);
277
278
inline void HW__SetBackFaceStencilFunc(
279
DWORD Func_,
280
DWORD Ref_,
281
DWORD Mask_);
282
283
inline void HW__SetFrontFaceStencilOp(
284
DWORD FailOp_,
285
DWORD ZFailOp_,
286
DWORD ZPassOp_);
287
288
inline void HW__SetBackFaceStencilOp(
289
DWORD FailOp_,
290
DWORD ZFailOp_,
291
DWORD ZPassOp_);
292
293
inline void HW__EnableLineSmooth(UBOOL EnableLineSmooth);
294
inline void HW__SetLineWidth(UINT width, UINT HINT);
295
296
inline void HW__EnablePointSmooth(UBOOL EnablePointSmooth);
297
inline void HW__SetPointSize(UINT size, UINT HINT);
298
299
inline void HW__SetColorMask(UBOOL bRed, UBOOL bGreen, UBOOL bBlue, UBOOL bAlpha);
300
inline void HW__SetDepthMask(UBOOL bDepth);
301
302
inline void HW__EnableScissor(UBOOL bScissor);
303
inline void HW__EnableFog(UBOOL bFog);
304
305
inline void HW__SetPolygonMode(UINT FrontMode, UINT BackMode);
306
inline void HW__EnablePolygonOffset(UBOOL EnablePolygonOffset);
307
inline void HW__SetPolygonOffset(FLOAT Factor, FLOAT Units);
308
309
private:
310
RenderStateMap *m_RenderStateChangeList;
311
RenderStateMap *m_SamplerStateChangeList;
312
RenderStateMap m_RenderStateChanges[GFXRS_MAX_RENDERSTATES];
313
RenderStateMap m_SamplerStateChanges[4][GFXSS_MAX_SAMPLERSTATES];
314
315
};
316
317
318
319
#define SET_RS_VALUE(a, b) (a).iValue = (b)
320
#define RS_VALUE(a) (a).iValue
321
322
//#define SET_RS_VALUE_FLOAT(a, b) (a).fValue = (b)
323
//#define RS_VALUE_FLOAT(a, b) (a).fValue
324
325
326
inline void GLRenderStates::SetAlphaTest(
327
UBOOL EnableAlphaTest_,
328
DWORD AlphaTestFunc_,
329
BYTE AlphaTestRef_)
330
{
331
if(EnableAlphaTest_)
332
{
333
if(!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTENABLE]))
334
{
335
HW__EnableAlphaTest(TRUE);
336
}
337
338
if((RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTFUNC]) != AlphaTestFunc_) ||
339
(RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTREF]) != AlphaTestRef_))
340
{
341
HW__SetAlphaTestFunc(AlphaTestFunc_, AlphaTestRef_);
342
}
343
}
344
else
345
{
346
HW__EnableAlphaTest(GL_FALSE);
347
HW__SetAlphaTestFunc(AlphaTestFunc_, AlphaTestRef_);
348
}
349
}
350
351
inline void GLRenderStates::SetBlend(UBOOL AlphaBlendEnable_)
352
{
353
if(AlphaBlendEnable_)
354
{
355
if(!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
356
{
357
HW__EnableAlphaBlend(TRUE);
358
}
359
}
360
else
361
{
362
if(RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
363
{
364
HW__EnableAlphaBlend(GL_FALSE);
365
}
366
}
367
}
368
369
inline void GLRenderStates::SetBlend(UBOOL AlphaBlendEnable_,
370
DWORD SrcBlendFactor_,
371
DWORD DestBlendFactor_)
372
{
373
SetBlend(AlphaBlendEnable_);
374
if((RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND])!= SrcBlendFactor_) ||
375
(RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_))
376
{
377
HW__SetSeparateAlphaBlendFactors(
378
SrcBlendFactor_,
379
DestBlendFactor_,
380
SrcBlendFactor_,
381
DestBlendFactor_);
382
}
383
}
384
385
inline void GLRenderStates::SetSeparateBlend(UBOOL EnableSeparateAlphaBlend,
386
DWORD SrcBlendFactor_,
387
DWORD DestBlendFactor_,
388
DWORD SrcBlendFactorAlpha_,
389
DWORD DestBlendFactorAlpha_)
390
{
391
SetBlend(EnableSeparateAlphaBlend);
392
393
// if(EnableSeparateAlphaBlend)
394
// {
395
// if(!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
396
// {
397
// HW__EnableAlphaBlend(TRUE);
398
// }
399
400
if((RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND])!= SrcBlendFactor_) ||
401
(RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_) ||
402
(RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLENDALPHA]) != SrcBlendFactorAlpha_) ||
403
(RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLENDALPHA]) != DestBlendFactorAlpha_))
404
{
405
HW__SetSeparateAlphaBlendFactors(
406
SrcBlendFactor_,
407
DestBlendFactor_,
408
SrcBlendFactorAlpha_,
409
DestBlendFactorAlpha_);
410
}
411
// }
412
// else
413
// {
414
// HW__EnableAlphaBlend(GL_FALSE);
415
// HW__SetSeparateAlphaBlendFactors(
416
// SrcBlendFactor_,
417
// DestBlendFactor_,
418
// SrcBlendFactorAlpha_,
419
// DestBlendFactorAlpha_);
420
// }
421
}
422
423
inline void GLRenderStates::SetBlendOp(DWORD BlendOp)
424
{
425
if((RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP])!= BlendOp))
426
{
427
HW__SetAlphaBlendOp(BlendOp, BlendOp);
428
}
429
}
430
431
inline void GLRenderStates::SetSeparateBlendOp(
432
DWORD BlendOpRGB_,
433
DWORD BlendOpAlpha_)
434
{
435
if((RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP])!= BlendOpRGB_) ||
436
(RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA])!= BlendOpAlpha_))
437
{
438
HW__SetAlphaBlendOp(BlendOpRGB_, BlendOpAlpha_);
439
}
440
}
441
442
inline void GLRenderStates::SetCullMode(UBOOL EnableCullFace,
443
DWORD FrontFace_,
444
DWORD Cullface_)
445
{
446
if(EnableCullFace)
447
{
448
if(!RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACEENABLE]))
449
{
450
HW__EnableCulling(TRUE);
451
}
452
453
if(RS_VALUE(m_RenderStateChanges[GFXRS_FRONTFACE])!= FrontFace_)
454
{
455
HW__SetFrontFace(FrontFace_);
456
}
457
458
if(RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACE]) != Cullface_)
459
{
460
HW__SetCullFace(Cullface_);
461
}
462
}
463
else
464
{
465
HW__EnableCulling(FALSE);
466
HW__SetFrontFace(FrontFace_);
467
HW__SetCullFace(Cullface_);
468
}
469
}
470
471
inline void GLRenderStates::SetDepthTest(UBOOL EnableDepthTest,
472
UBOOL WriteEnable_,
473
DWORD DepthFunc_)
474
{
475
if(EnableDepthTest)
476
{
477
if(!RS_VALUE(m_RenderStateChanges[GFXRS_ZTESTENABLE]))
478
{
479
HW__SetEnableDepthTest(TRUE);
480
}
481
482
if(RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE])!= WriteEnable_)
483
{
484
HW__SetDepthMask(WriteEnable_);
485
}
486
487
if(RS_VALUE(m_RenderStateChanges[GFXRS_ZFUNC]) != DepthFunc_)
488
{
489
HW__SetDepthFunc(DepthFunc_);
490
}
491
}
492
else
493
{
494
HW__SetEnableDepthTest(FALSE);
495
HW__SetDepthMask(WriteEnable_);
496
HW__SetDepthFunc(DepthFunc_);
497
}
498
}
499
500
inline void GLRenderStates::SetDepthRange(FLOAT zNear, FLOAT zFar)
501
{
502
if((RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR]) != static_cast<UINT>(zNear)) ||
503
(RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR]) != static_cast<UINT>(zFar)))
504
{
505
HW__SetDepthRange(zNear, zFar);
506
}
507
}
508
509
inline void GLRenderStates::SetStencilFrontFace(
510
UBOOL EnableStencil_, // GL_TRUE enable stencil test
511
DWORD Func_,
512
DWORD FailOp_,
513
DWORD ZFailOp_,
514
DWORD ZPassOp_,
515
DWORD Ref_,
516
DWORD Mask_)
517
{
518
if(EnableStencil_)
519
{
520
if(!RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE]))
521
{
522
HW__EnableStencil(TRUE);
523
}
524
525
if(
526
(RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC])!= Func_) ||
527
(RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != Ref_) ||
528
(RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != Mask_) ||
529
(RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != FailOp_) ||
530
(RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]) != ZFailOp_) ||
531
(RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) != ZPassOp_)
532
)
533
{
534
HW__SetFrontFaceStencilFunc(Func_, Ref_, Mask_);
535
HW__SetFrontFaceStencilOp(FailOp_, ZFailOp_, ZPassOp_);
536
}
537
}
538
else
539
{
540
HW__EnableStencil(FALSE);
541
HW__SetFrontFaceStencilFunc(Func_, Ref_, Mask_);
542
HW__SetFrontFaceStencilOp(FailOp_, ZFailOp_, ZPassOp_);
543
}
544
}
545
546
inline void GLRenderStates::SetStencilBackFace(
547
UBOOL EnableTwoSideStencil_, // GL_TRUE enable Two Sided Stencil test
548
DWORD Func_,
549
DWORD FailOp_,
550
DWORD ZFailOp_,
551
DWORD ZPassOp_,
552
DWORD Ref_,
553
DWORD Mask_)
554
{
555
if(EnableTwoSideStencil_)
556
{
557
if(!RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE]))
558
{
559
HW__EnableStencil(TRUE);
560
}
561
562
if(!RS_VALUE(m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE]))
563
{
564
HW__EnableTwoSidedStencil(TRUE);
565
}
566
567
if(
568
(RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFUNC])!= Func_) ||
569
(RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILREF]) != Ref_) ||
570
(RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILMASK]) != Mask_) ||
571
(RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFAIL]) != FailOp_) ||
572
(RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL]) != ZFailOp_) ||
573
(RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZPASS]) != ZPassOp_)
574
)
575
{
576
HW__SetBackFaceStencilFunc(Func_, Ref_, Mask_);
577
HW__SetBackFaceStencilOp(FailOp_, ZFailOp_, ZPassOp_);
578
}
579
}
580
else
581
{
582
HW__EnableTwoSidedStencil(FALSE);
583
HW__SetBackFaceStencilFunc(Func_, Ref_, Mask_);
584
HW__SetBackFaceStencilOp(FailOp_, ZFailOp_, ZPassOp_);
585
}
586
}
587
588
inline void GLRenderStates::SetFrontFaceStencilWriteMask(
589
DWORD WriteMask_)
590
{
591
HW__SetStencilFrontFaceWriteMask(WriteMask_);
592
}
593
594
inline void GLRenderStates::SetBackFaceStencilWriteMask(
595
DWORD WriteMask_)
596
{
597
HW__SetStencilBackFaceWriteMask(WriteMask_);
598
}
599
600
inline void GLRenderStates::EnableLineSmooth(
601
UBOOL EnableLineSmooth,
602
UINT LineWidth,
603
UINT Hint)
604
{
605
if(EnableLineSmooth)
606
{
607
if(!RS_VALUE(m_RenderStateChanges[GFXRS_LINESMOOTHENABLE]))
608
{
609
HW__EnableLineSmooth(GL_TRUE);
610
}
611
612
if((RS_VALUE(m_RenderStateChanges[GFXRS_LINEWIDTH]) != LineWidth) ||
613
(RS_VALUE(m_RenderStateChanges[GFXRS_LINEHINT]) != Hint))
614
{
615
HW__SetLineWidth(LineWidth, Hint);
616
}
617
}
618
else
619
{
620
HW__EnableLineSmooth(GL_FALSE);
621
HW__SetLineWidth(LineWidth, Hint);
622
}
623
}
624
625
inline void GLRenderStates::EnablePointSmooth(
626
UBOOL EnablePointSmooth,
627
UINT PointSize,
628
UINT Hint)
629
{
630
if(EnablePointSmooth)
631
{
632
if(!RS_VALUE(m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE]))
633
{
634
HW__EnablePointSmooth(GL_TRUE);
635
}
636
637
if((RS_VALUE(m_RenderStateChanges[GFXRS_POINTSIZE]) != PointSize) ||
638
(RS_VALUE(m_RenderStateChanges[GFXRS_POINTHINT]) != Hint))
639
{
640
HW__SetLineWidth(PointSize, Hint);
641
}
642
}
643
else
644
{
645
HW__EnablePointSmooth(GL_FALSE);
646
HW__SetLineWidth(PointSize, Hint);
647
}
648
}
649
650
inline void GLRenderStates::SetColorMask(
651
UBOOL bRed,
652
UBOOL bGreen,
653
UBOOL bBlue,
654
UBOOL bAlpha)
655
{
656
if((RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]) != bRed) ||
657
(RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]) != bGreen) ||
658
(RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]) != bBlue) ||
659
(RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]) != bAlpha))
660
{
661
HW__SetColorMask(bRed, bGreen, bBlue, bAlpha);
662
}
663
664
}
665
666
inline void GLRenderStates::SetDepthMask(UBOOL bDepth)
667
{
668
if((RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != bDepth))
669
{
670
HW__SetDepthMask(bDepth);
671
}
672
}
673
674
inline void GLRenderStates::EnableScissor(UBOOL bScissor)
675
{
676
if((RS_VALUE(m_RenderStateChanges[GFXRS_SCISSORTESTENABLE]) != bScissor))
677
{
678
HW__EnableScissor(bScissor);
679
}
680
}
681
682
inline void GLRenderStates::EnableFog(UBOOL bFog)
683
{
684
if((RS_VALUE(m_RenderStateChanges[GFXRS_FOGENABLE]) != bFog))
685
{
686
HW__EnableFog(bFog);
687
}
688
}
689
690
inline void GLRenderStates::SetPolygonMode(UINT FrontMode, UINT BackMode)
691
{
692
if((RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]) != FrontMode) ||
693
(RS_VALUE(m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]) != BackMode))
694
{
695
HW__SetPolygonMode(FrontMode, BackMode);
696
}
697
}
698
699
inline void GLRenderStates::SetPolygonOffset(UBOOL bEnable,
700
FLOAT Factor, FLOAT Units)
701
{
702
if(bEnable)
703
{
704
if(!RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETENABLE]))
705
{
706
HW__EnablePolygonOffset(GL_TRUE);
707
}
708
709
if((RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]) != static_cast<UINT>(Factor)) ||
710
(RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]) != static_cast<UINT>(Units)))
711
{
712
HW__SetPolygonOffset(Factor, Units);
713
}
714
}
715
else
716
{
717
HW__EnablePolygonOffset(GL_FALSE);
718
}
719
}
720
721
722
//////////////////////////////////////
723
inline void GLRenderStates::HW__EnableAlphaTest(UBOOL b)
724
{
725
if(b)
726
{
727
CHECKGL(glEnable(GL_ALPHA_TEST));
728
}
729
else
730
{
731
CHECKGL(glDisable(GL_ALPHA_TEST));
732
}
733
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTENABLE], b ? GL_TRUE : GL_FALSE);
734
}
735
736
inline void GLRenderStates::HW__SetAlphaTestFunc(DWORD AlphaTestFunc_,
737
BYTE AlphaTestRef_)
738
{
739
nuxAssertMsg(
740
(AlphaTestFunc_ == GL_NEVER) ||
741
(AlphaTestFunc_ == GL_LESS) ||
742
(AlphaTestFunc_ == GL_EQUAL) ||
743
(AlphaTestFunc_ == GL_LEQUAL) ||
744
(AlphaTestFunc_ == GL_GREATER) ||
745
(AlphaTestFunc_ == GL_NOTEQUAL) ||
746
(AlphaTestFunc_ == GL_GEQUAL) ||
747
(AlphaTestFunc_ == GL_ALWAYS),
748
TEXT("Error(HW__SetAlphaTestFunc): Invalid Alpha Test Function RenderState"));
749
750
CHECKGL(glAlphaFunc(AlphaTestFunc_, (FLOAT)AlphaTestRef_ * (1.0f / 255.0f)));
751
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTFUNC], AlphaTestFunc_);
752
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHATESTREF], AlphaTestRef_);
753
}
754
755
inline void GLRenderStates::HW__EnableAlphaBlend(UBOOL b)
756
{
757
if(b)
758
{
759
CHECKGL(glEnable(GL_BLEND));
760
}
761
else
762
{
763
CHECKGL(glDisable(GL_BLEND));
764
}
765
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE], b ? GL_TRUE : GL_FALSE);
766
}
767
768
inline void GLRenderStates::HW__SetSeparateAlphaBlendFactors(
769
DWORD SrcBlendFactor_,
770
DWORD DestBlendFactor_,
771
DWORD SrcFactorAlpha_,
772
DWORD DestFactorAlpha_)
773
{
774
nuxAssertMsg((SrcBlendFactor_ == GL_ZERO) || (SrcBlendFactor_ == GL_ONE) || (SrcBlendFactor_ == GL_SRC_COLOR) || (SrcBlendFactor_ == GL_ONE_MINUS_SRC_COLOR) ||(SrcBlendFactor_ == GL_DST_COLOR) ||(SrcBlendFactor_ == GL_ONE_MINUS_DST_COLOR) || (SrcBlendFactor_ == GL_SRC_ALPHA) ||(SrcBlendFactor_ == GL_ONE_MINUS_SRC_ALPHA) ||(SrcBlendFactor_ == GL_DST_ALPHA) ||(SrcBlendFactor_ == GL_ONE_MINUS_DST_ALPHA) ||(SrcBlendFactor_ == GL_CONSTANT_COLOR) ||(SrcBlendFactor_ == GL_ONE_MINUS_CONSTANT_COLOR) ||(SrcBlendFactor_ == GL_CONSTANT_ALPHA) ||(SrcBlendFactor_ == GL_ONE_MINUS_CONSTANT_ALPHA) ||(SrcBlendFactor_ == GL_SRC_ALPHA_SATURATE),
775
TEXT("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState"));
776
nuxAssertMsg((DestBlendFactor_ == GL_ZERO) || (DestBlendFactor_ == GL_ONE) || (DestBlendFactor_ == GL_SRC_COLOR) || (DestBlendFactor_ == GL_ONE_MINUS_SRC_COLOR) ||(DestBlendFactor_ == GL_DST_COLOR) ||(DestBlendFactor_ == GL_ONE_MINUS_DST_COLOR) || (DestBlendFactor_ == GL_SRC_ALPHA) ||(DestBlendFactor_ == GL_ONE_MINUS_SRC_ALPHA) ||(DestBlendFactor_ == GL_DST_ALPHA) ||(DestBlendFactor_ == GL_ONE_MINUS_DST_ALPHA) ||(DestBlendFactor_ == GL_CONSTANT_COLOR) ||(DestBlendFactor_ == GL_ONE_MINUS_CONSTANT_COLOR) ||(DestBlendFactor_ == GL_CONSTANT_ALPHA) ||(DestBlendFactor_ == GL_ONE_MINUS_CONSTANT_ALPHA),
777
TEXT("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState"));
778
nuxAssertMsg((SrcFactorAlpha_ == GL_ZERO) || (SrcFactorAlpha_ == GL_ONE) || (SrcFactorAlpha_ == GL_SRC_COLOR) || (SrcFactorAlpha_ == GL_ONE_MINUS_SRC_COLOR) ||(SrcFactorAlpha_ == GL_DST_COLOR) ||(SrcFactorAlpha_ == GL_ONE_MINUS_DST_COLOR) || (SrcFactorAlpha_ == GL_SRC_ALPHA) ||(SrcFactorAlpha_ == GL_ONE_MINUS_SRC_ALPHA) ||(SrcFactorAlpha_ == GL_DST_ALPHA) ||(SrcFactorAlpha_ == GL_ONE_MINUS_DST_ALPHA) ||(SrcFactorAlpha_ == GL_CONSTANT_COLOR) ||(SrcFactorAlpha_ == GL_ONE_MINUS_CONSTANT_COLOR) ||(SrcFactorAlpha_ == GL_CONSTANT_ALPHA) ||(SrcFactorAlpha_ == GL_ONE_MINUS_CONSTANT_ALPHA) ||(SrcFactorAlpha_ == GL_SRC_ALPHA_SATURATE),
779
TEXT("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState"));
780
nuxAssertMsg((DestFactorAlpha_ == GL_ZERO) || (DestFactorAlpha_ == GL_ONE) || (DestFactorAlpha_ == GL_SRC_COLOR) || (DestFactorAlpha_ == GL_ONE_MINUS_SRC_COLOR) ||(DestFactorAlpha_ == GL_DST_COLOR) ||(DestFactorAlpha_ == GL_ONE_MINUS_DST_COLOR) || (DestFactorAlpha_ == GL_SRC_ALPHA) ||(DestFactorAlpha_ == GL_ONE_MINUS_SRC_ALPHA) ||(DestFactorAlpha_ == GL_DST_ALPHA) ||(DestFactorAlpha_ == GL_ONE_MINUS_DST_ALPHA) ||(DestFactorAlpha_ == GL_CONSTANT_COLOR) ||(DestFactorAlpha_ == GL_ONE_MINUS_CONSTANT_COLOR) ||(DestFactorAlpha_ == GL_CONSTANT_ALPHA) ||(DestFactorAlpha_ == GL_ONE_MINUS_CONSTANT_ALPHA),
781
TEXT("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState"));
782
783
CHECKGL(glBlendFuncSeparate(
784
SrcBlendFactor_,
785
DestBlendFactor_,
786
SrcFactorAlpha_,
787
DestFactorAlpha_));
788
789
SET_RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND], SrcBlendFactor_);
790
SET_RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLEND], DestBlendFactor_);
791
SET_RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLENDALPHA], SrcFactorAlpha_);
792
SET_RS_VALUE(m_RenderStateChanges[GFXRS_DESTBLENDALPHA], DestFactorAlpha_);
793
}
794
795
inline void GLRenderStates::HW__SetAlphaBlendOp(
796
DWORD BlendOpRGB_,
797
DWORD BlendOpAlpha_)
798
{
799
nuxAssertMsg(
800
(BlendOpRGB_ == GL_FUNC_ADD) ||
801
(BlendOpRGB_ == GL_FUNC_SUBTRACT) ||
802
(BlendOpRGB_ == GL_FUNC_REVERSE_SUBTRACT) ||
803
(BlendOpRGB_ == GL_MIN) ||
804
(BlendOpRGB_ == GL_MAX),
805
TEXT("Error(HW__SetAlphaBlendOp): Invalid Blend Equation RenderState"));
806
nuxAssertMsg(
807
(BlendOpAlpha_ == GL_FUNC_ADD) ||
808
(BlendOpAlpha_ == GL_FUNC_SUBTRACT) ||
809
(BlendOpAlpha_ == GL_FUNC_REVERSE_SUBTRACT) ||
810
(BlendOpAlpha_ == GL_MIN) ||
811
(BlendOpAlpha_ == GL_MAX),
812
TEXT("Error(HW__SetAlphaBlendOp): Invalid Blend Equation RenderState"));
813
814
CHECKGL(glBlendEquationSeparateEXT(BlendOpRGB_, BlendOpAlpha_));
815
816
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP], BlendOpRGB_);
817
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA], BlendOpAlpha_);
818
}
819
820
inline void GLRenderStates::HW__EnableCulling(UBOOL b)
821
{
822
if(b)
823
{
824
CHECKGL(glEnable(GL_CULL_FACE));
825
}
826
else
827
{
828
CHECKGL(glDisable(GL_CULL_FACE));
829
}
830
SET_RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACEENABLE], b ? GL_TRUE : GL_FALSE);
831
}
832
833
834
inline void GLRenderStates::HW__SetFrontFace(DWORD FrontFace_)
835
{
836
nuxAssertMsg(
837
(FrontFace_ == GL_CW) ||
838
(FrontFace_ == GL_CCW),
839
TEXT("Error(HW__SetFrontFace): Invalid Front Face RenderState"));
840
841
CHECKGL(glFrontFace(FrontFace_));
842
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONTFACE], FrontFace_);
843
}
844
845
inline void GLRenderStates::HW__SetCullFace(DWORD CullFace_)
846
{
847
nuxAssertMsg(
848
(CullFace_ == GL_FRONT) ||
849
(CullFace_ == GL_BACK) ||
850
(CullFace_ == GL_FRONT_AND_BACK),
851
TEXT("Error(HW__SetCullFace): Invalid Cull Face RenderState"));
852
853
CHECKGL(glCullFace(CullFace_));
854
SET_RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACE], CullFace_);
855
}
856
857
inline void GLRenderStates::HW__SetEnableDepthTest(UBOOL b)
858
{
859
if(b)
860
{
861
CHECKGL(glEnable(GL_DEPTH_TEST));
862
}
863
else
864
{
865
CHECKGL(glDisable(GL_DEPTH_TEST));
866
}
867
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZTESTENABLE], b ? GL_TRUE : GL_FALSE);
868
}
869
870
inline void GLRenderStates::HW__SetDepthRange(FLOAT zNear, FLOAT zFar)
871
{
872
CHECKGL(glDepthRange(zNear, zFar));
873
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR], static_cast<UINT>(Clamp(zNear, 0.0f, 1.0f)));
874
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR], static_cast<UINT>(Clamp(zFar, 0.0f, 1.0f)));
875
}
876
877
inline void GLRenderStates::HW__SetDepthFunc(DWORD Func)
878
{
879
nuxAssertMsg(
880
(Func == GL_NEVER) ||
881
(Func == GL_LESS) ||
882
(Func == GL_EQUAL) ||
883
(Func == GL_LEQUAL) ||
884
(Func == GL_GREATER) ||
885
(Func == GL_NOTEQUAL) ||
886
(Func == GL_GEQUAL) ||
887
(Func == GL_ALWAYS),
888
TEXT("Error(HW__SetDepthFunc): Invalid Depth Func RenderState"));
889
890
CHECKGL(glDepthFunc(Func));
891
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZFUNC], Func);
892
}
893
894
inline void GLRenderStates::HW__EnableStencil(UBOOL b)
895
{
896
if(b)
897
{
898
CHECKGL(glEnable(GL_STENCIL_TEST));
899
}
900
else
901
{
902
CHECKGL(glDisable(GL_STENCIL_TEST));
903
}
904
905
SET_RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE], b ? GL_TRUE : GL_FALSE);
906
}
907
908
inline void GLRenderStates::HW__EnableTwoSidedStencil(UBOOL b)
909
{
910
if(b)
911
{
912
if(m_BoardVendor == BOARD_ATI)
913
{
914
CHECKGL(glEnable(GL_STENCIL_TEST));
915
}
916
else
917
{
918
CHECKGL(glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT));
919
}
920
}
921
else
922
{
923
if(m_BoardVendor == BOARD_ATI)
924
{
925
CHECKGL(glDisable(GL_STENCIL_TEST));
926
}
927
else
928
{
929
CHECKGL(glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT));
930
}
931
}
932
933
SET_RS_VALUE(m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE], b ? GL_TRUE : GL_FALSE);
934
}
935
936
inline void GLRenderStates::HW__SetStencilFrontFaceWriteMask(DWORD WriteMask_)
937
{
938
CHECKGL(glActiveStencilFaceEXT(GL_FRONT));
939
CHECKGL(glStencilMask(WriteMask_));
940
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK], WriteMask_);
941
}
942
943
inline void GLRenderStates::HW__SetStencilBackFaceWriteMask(DWORD WriteMask_)
944
{
945
CHECKGL(glActiveStencilFaceEXT(GL_BACK));
946
CHECKGL(glStencilMask(WriteMask_));
947
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK], WriteMask_);
948
}
949
950
951
inline void GLRenderStates::HW__SetFrontFaceStencilFunc(DWORD Func_,
952
DWORD Ref_,
953
DWORD Mask_)
954
{
955
nuxAssertMsg(
956
(Func_ == GL_NEVER) ||
957
(Func_ == GL_LESS) ||
958
(Func_ == GL_EQUAL) ||
959
(Func_ == GL_LEQUAL) ||
960
(Func_ == GL_GREATER) ||
961
(Func_ == GL_NOTEQUAL) ||
962
(Func_ == GL_GEQUAL) ||
963
(Func_ == GL_ALWAYS),
964
TEXT("Error(HW__SetFrontFaceStencilFunc): Invalid Stencil Function RenderState"));
965
966
CHECKGL(glActiveStencilFaceEXT(GL_FRONT));
967
CHECKGL(glStencilFunc(Func_, Ref_, Mask_));
968
969
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC], Func_);
970
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF], Ref_);
971
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], Mask_);
972
}
973
974
inline void GLRenderStates::HW__SetBackFaceStencilFunc(
975
DWORD Func_,
976
DWORD Ref_,
977
DWORD Mask_)
978
{
979
nuxAssertMsg(
980
(Func_ == GL_NEVER) ||
981
(Func_ == GL_LESS) ||
982
(Func_ == GL_EQUAL) ||
983
(Func_ == GL_LEQUAL) ||
984
(Func_ == GL_GREATER) ||
985
(Func_ == GL_NOTEQUAL) ||
986
(Func_ == GL_GEQUAL) ||
987
(Func_ == GL_ALWAYS),
988
TEXT("Error(HW__SetBackFaceStencilFunc): Invalid Stencil Function RenderState"));
989
990
if(m_BoardVendor == BOARD_ATI)
991
{
992
CHECKGL(glStencilFuncSeparateATI(Func_/*Front function*/, Func_/*Back function*/, Ref_, Mask_)); // incorrect
993
}
994
else
995
{
996
CHECKGL(glActiveStencilFaceEXT(GL_BACK));
997
CHECKGL(glStencilFunc(Func_, Ref_, Mask_));
998
}
999
1000
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFUNC], Func_);
1001
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILREF], Ref_);
1002
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILMASK], Mask_);
1003
}
1004
1005
inline void GLRenderStates::HW__SetFrontFaceStencilOp(
1006
DWORD FailOp_,
1007
DWORD ZFailOp_,
1008
DWORD ZPassOp_)
1009
{
1010
nuxAssertMsg(
1011
(FailOp_ == GL_KEEP) ||
1012
(FailOp_ == GL_ZERO) ||
1013
(FailOp_ == GL_REPLACE) ||
1014
(FailOp_ == GL_INCR) ||
1015
(FailOp_ == GL_INCR_WRAP) ||
1016
(FailOp_ == GL_DECR) ||
1017
(FailOp_ == GL_DECR_WRAP) ||
1018
(FailOp_ == GL_INVERT),
1019
TEXT("Error(HW__SetFrontFaceStencilOp): Invalid FailOp RenderState"));
1020
1021
nuxAssertMsg(
1022
(ZFailOp_ == GL_KEEP) ||
1023
(ZFailOp_ == GL_ZERO) ||
1024
(ZFailOp_ == GL_REPLACE) ||
1025
(ZFailOp_ == GL_INCR) ||
1026
(ZFailOp_ == GL_INCR_WRAP) ||
1027
(ZFailOp_ == GL_DECR) ||
1028
(ZFailOp_ == GL_DECR_WRAP) ||
1029
(ZFailOp_ == GL_INVERT),
1030
TEXT("Error(HW__SetFrontFaceStencilOp): Invalid ZFailOp RenderState"));
1031
1032
nuxAssertMsg(
1033
(ZPassOp_ == GL_KEEP) ||
1034
(ZPassOp_ == GL_ZERO) ||
1035
(ZPassOp_ == GL_REPLACE) ||
1036
(ZPassOp_ == GL_INCR) ||
1037
(ZPassOp_ == GL_INCR_WRAP) ||
1038
(ZPassOp_ == GL_DECR) ||
1039
(ZPassOp_ == GL_DECR_WRAP) ||
1040
(ZPassOp_ == GL_INVERT),
1041
TEXT("Error(HW__SetFrontFaceStencilOp): Invalid ZPassOp RenderState"));
1042
1043
if(m_BoardVendor == BOARD_ATI)
1044
{
1045
CHECKGL(glStencilOpSeparateATI(GL_FRONT, FailOp_, ZFailOp_, ZPassOp_));
1046
}
1047
else
1048
{
1049
CHECKGL(glActiveStencilFaceEXT(GL_FRONT));
1050
CHECKGL(glStencilOp(FailOp_, ZFailOp_, ZPassOp_));
1051
}
1052
1053
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL], FailOp_);
1054
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL], ZFailOp_);
1055
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS], ZPassOp_);
1056
}
1057
1058
inline void GLRenderStates::HW__SetBackFaceStencilOp(
1059
DWORD FailOp_,
1060
DWORD ZFailOp_,
1061
DWORD ZPassOp_)
1062
{
1063
nuxAssertMsg(
1064
(FailOp_ == GL_KEEP) ||
1065
(FailOp_ == GL_ZERO) ||
1066
(FailOp_ == GL_REPLACE) ||
1067
(FailOp_ == GL_INCR) ||
1068
(FailOp_ == GL_INCR_WRAP) ||
1069
(FailOp_ == GL_DECR) ||
1070
(FailOp_ == GL_DECR_WRAP) ||
1071
(FailOp_ == GL_INVERT),
1072
TEXT("Error(HW__SetBackFaceStencilOp): Invalid FailOp RenderState"));
1073
1074
nuxAssertMsg(
1075
(ZFailOp_ == GL_KEEP) ||
1076
(ZFailOp_ == GL_ZERO) ||
1077
(ZFailOp_ == GL_REPLACE) ||
1078
(ZFailOp_ == GL_INCR) ||
1079
(ZFailOp_ == GL_INCR_WRAP) ||
1080
(ZFailOp_ == GL_DECR) ||
1081
(ZFailOp_ == GL_DECR_WRAP) ||
1082
(ZFailOp_ == GL_INVERT),
1083
TEXT("Error(HW__SetBackFaceStencilOp): Invalid ZFailOp RenderState"));
1084
1085
nuxAssertMsg(
1086
(ZPassOp_ == GL_KEEP) ||
1087
(ZPassOp_ == GL_ZERO) ||
1088
(ZPassOp_ == GL_REPLACE) ||
1089
(ZPassOp_ == GL_INCR) ||
1090
(ZPassOp_ == GL_INCR_WRAP) ||
1091
(ZPassOp_ == GL_DECR) ||
1092
(ZPassOp_ == GL_DECR_WRAP) ||
1093
(ZPassOp_ == GL_INVERT),
1094
TEXT("Error(HW__SetBackFaceStencilOp): Invalid ZPassOp RenderState"));
1095
1096
if(m_BoardVendor == BOARD_ATI)
1097
{
1098
CHECKGL(glStencilOpSeparateATI(GL_BACK, FailOp_, ZFailOp_, ZPassOp_));
1099
}
1100
else
1101
{
1102
CHECKGL(glActiveStencilFaceEXT(GL_BACK));
1103
CHECKGL(glStencilOp(FailOp_, ZFailOp_, ZPassOp_));
1104
}
1105
1106
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILFAIL], FailOp_);
1107
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL], ZFailOp_);
1108
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILZPASS], ZPassOp_);
1109
}
1110
1111
inline void GLRenderStates::HW__EnableLineSmooth(UBOOL EnableLineSmooth)
1112
{
1113
if(EnableLineSmooth)
1114
{
1115
CHECKGL(glEnable(GL_LINE_SMOOTH));
1116
}
1117
else
1118
{
1119
CHECKGL(glDisable(GL_LINE_SMOOTH));
1120
}
1121
SET_RS_VALUE(m_RenderStateChanges[GFXRS_LINESMOOTHENABLE], EnableLineSmooth ? GL_TRUE : GL_FALSE);
1122
}
1123
1124
inline void GLRenderStates::HW__SetLineWidth(UINT width, UINT Hint)
1125
{
1126
nuxAssertMsg(
1127
(Hint == GL_NICEST) ||
1128
(Hint == GL_FASTEST) ||
1129
(Hint == GL_DONT_CARE),
1130
TEXT("Error(HW__SetLineWidth): Invalid Line Hint RenderState"));
1131
1132
CHECKGL(glLineWidth(width));
1133
CHECKGL(glHint(GL_LINE_SMOOTH_HINT, Hint));
1134
SET_RS_VALUE(m_RenderStateChanges[GFXRS_LINEWIDTH], width);
1135
SET_RS_VALUE(m_RenderStateChanges[GFXRS_LINEHINT], Hint);
1136
}
1137
1138
inline void GLRenderStates::HW__EnablePointSmooth(UBOOL EnablePointSmooth)
1139
{
1140
if(EnablePointSmooth)
1141
{
1142
CHECKGL(glEnable(GL_POINT_SMOOTH));
1143
}
1144
else
1145
{
1146
CHECKGL(glDisable(GL_POINT_SMOOTH));
1147
}
1148
SET_RS_VALUE(m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE], EnablePointSmooth ? GL_TRUE : GL_FALSE);
1149
}
1150
1151
inline void GLRenderStates::HW__SetPointSize(UINT size, UINT Hint)
1152
{
1153
nuxAssertMsg(
1154
(Hint == GL_NICEST) ||
1155
(Hint == GL_FASTEST) ||
1156
(Hint == GL_DONT_CARE),
1157
TEXT("Error(HW__SetPointSize): Invalid Point Hint RenderState"));
1158
1159
CHECKGL(glPointSize(size));
1160
CHECKGL(glHint(GL_POINT_SMOOTH_HINT, Hint);)
1161
SET_RS_VALUE(m_RenderStateChanges[GFXRS_POINTSIZE], size);
1162
SET_RS_VALUE(m_RenderStateChanges[GFXRS_POINTHINT], Hint);
1163
}
1164
1165
inline void GLRenderStates::HW__SetColorMask(
1166
UBOOL bRed,
1167
UBOOL bGreen,
1168
UBOOL bBlue,
1169
UBOOL bAlpha)
1170
{
1171
CHECKGL(glColorMask(bRed, bGreen, bBlue, bAlpha));
1172
SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R], bRed);
1173
SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G], bGreen);
1174
SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B], bBlue);
1175
SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A], bAlpha);
1176
}
1177
1178
inline void GLRenderStates::HW__SetDepthMask(UBOOL bDepth)
1179
{
1180
CHECKGL(glDepthMask(bDepth));
1181
SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE], bDepth);
1182
}
1183
1184
inline void GLRenderStates::HW__EnableScissor(UBOOL bScissor)
1185
{
1186
if(bScissor)
1187
{
1188
CHECKGL(glEnable(GL_SCISSOR_TEST));
1189
}
1190
else
1191
{
1192
CHECKGL(glDisable(GL_SCISSOR_TEST));
1193
}
1194
1195
SET_RS_VALUE(m_RenderStateChanges[GFXRS_SCISSORTESTENABLE], bScissor ? GL_TRUE : GL_FALSE);
1196
}
1197
1198
inline void GLRenderStates::HW__EnableFog(UBOOL bFog)
1199
{
1200
if(bFog)
1201
{
1202
CHECKGL(glEnable(GL_FOG));
1203
}
1204
else
1205
{
1206
CHECKGL(glDisable(GL_FOG));
1207
}
1208
1209
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FOGENABLE], bFog ? GL_TRUE : GL_FALSE);
1210
}
1211
1212
inline void GLRenderStates::HW__SetPolygonMode(UINT FrontMode, UINT BackMode)
1213
{
1214
nuxAssertMsg(
1215
(FrontMode == GL_FILL) ||
1216
(FrontMode == GL_LINE) ||
1217
(FrontMode == GL_POINT),
1218
TEXT("Error(HW__SetPolygonMode): Invalid Point Hint RenderState"));
1219
1220
nuxAssertMsg(
1221
(BackMode == GL_FILL) ||
1222
(BackMode == GL_LINE) ||
1223
(BackMode == GL_POINT),
1224
TEXT("Error(HW__SetPolygonMode): Invalid Point Hint RenderState"));
1225
1226
CHECKGL(glPolygonMode(GL_FRONT, FrontMode));
1227
CHECKGL(glPolygonMode(GL_BACK, BackMode));
1228
1229
SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE], FrontMode);
1230
SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_POLYGONMODE], BackMode);
1231
}
1232
1233
inline void GLRenderStates::HW__EnablePolygonOffset(UBOOL EnablePolygonOffset)
1234
{
1235
if(EnablePolygonOffset)
1236
{
1237
CHECKGL(glEnable(GL_POLYGON_OFFSET_FILL));
1238
}
1239
else
1240
{
1241
CHECKGL(glDisable(GL_POLYGON_OFFSET_FILL));
1242
}
1243
1244
SET_RS_VALUE(m_RenderStateChanges[GL_POLYGON_OFFSET_FILL], EnablePolygonOffset ? GL_TRUE : GL_FALSE);
1245
}
1246
1247
inline void GLRenderStates::HW__SetPolygonOffset(FLOAT Factor, FLOAT Units)
1248
{
1249
CHECKGL(glPolygonOffset(Factor, Units));
1250
1251
SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR], static_cast<UINT>(Factor));
1252
SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS], static_cast<UINT>(Units));
1253
}
1254
1255
#undef SET_RS_VALUE
1256
#undef RS_VALUE
1257
1258
//#undef SET_RS_VALUE_FLOAT
1259
//#undef RS_VALUE_FLOAT
1260
1261
NAMESPACE_END_OGL
1262
1263
#endif // GLRENDERSTATES_H
1264
Loggerhead is a web-based interface for Breezy
Version: 2.0.1