← Back to branch summary

~haggai-eran/nux/rtl-rebased

« back to all changes in this revision

Viewing changes to NuxGraphics/GLRenderStates.h

  • Committer: Jay Taoko
  • Date: 2011-10-21 23:49:15 UTC
  • mfrom: (508.1.2 nux-20)
  • Revision ID: jay.taoko@canonical.com-20111021234915-hnzakb5ndebica8i
* Removed custom Nux types: t_u32, t_s32, t_bool, ...

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxGraphics/GLRenderStates.h
131
131
 
132
132
  struct RenderStateMap
133
133
  {
134
 
    t_u32   Checked;
135
 
    t_u32    State;
136
 
    t_u32    iValue;
 
134
    unsigned int   Checked;
 
135
    unsigned int    State;
 
136
    unsigned int    iValue;
137
137
    float   fValue;
138
138
  };
139
139
 
153
153
    void CheckRenderStatesConformity();
154
154
 
155
155
 
156
 
    void SetRenderStates(t_u32 rs, t_u32 value);
 
156
    void SetRenderStates(unsigned int rs, unsigned int value);
157
157
 
158
158
    // Render states
159
159
    inline void SetAlphaTest(
160
160
      bool EnableAlphaTest_,
161
 
      t_u32 AlphaTestFunc_    = GL_ALWAYS,
 
161
      unsigned int AlphaTestFunc_    = GL_ALWAYS,
162
162
      BYTE  AlphaTestRef_     = 0);
163
163
 
164
164
    inline void SetBlend(bool AlphaBlendEnable_);
165
165
    inline void SetBlend(bool AlphaBlendEnable_,
166
 
                          t_u32 SrcBlendFactor_   /*= GL_ONE*/,
167
 
                          t_u32 DestBlendFactor_  /*= GL_ZERO*/);
 
166
                          unsigned int SrcBlendFactor_   /*= GL_ONE*/,
 
167
                          unsigned int DestBlendFactor_  /*= GL_ZERO*/);
168
168
 
169
 
    inline void GetBlend(t_u32& AlphaBlendEnable_,
170
 
                      t_u32& SrcBlendFactor_,
171
 
                      t_u32& DestBlendFactor_);
 
169
    inline void GetBlend(unsigned int& AlphaBlendEnable_,
 
170
                      unsigned int& SrcBlendFactor_,
 
171
                      unsigned int& DestBlendFactor_);
172
172
    
173
173
    inline void SetSeparateBlend(bool _bEnable,
174
 
                                  t_u32 SrcBlendFactor_   /*= GL_ONE*/,
175
 
                                  t_u32 DestBlendFactor_  /*= GL_ZERO*/,
176
 
                                  t_u32 SrcFactorAlpha_   /*= GL_ONE*/,
177
 
                                  t_u32 DestFactorAlpha_  /*= GL_ZERO*/);
 
174
                                  unsigned int SrcBlendFactor_   /*= GL_ONE*/,
 
175
                                  unsigned int DestBlendFactor_  /*= GL_ZERO*/,
 
176
                                  unsigned int SrcFactorAlpha_   /*= GL_ONE*/,
 
177
                                  unsigned int DestFactorAlpha_  /*= GL_ZERO*/);
178
178
 
179
179
    inline void SetPremultipliedBlend(PorterDuffOperator op);
180
180
 
181
181
    inline void SetBlendOp(
182
 
      t_u32 BlendOp       = GL_FUNC_ADD);
 
182
      unsigned int BlendOp       = GL_FUNC_ADD);
183
183
 
184
184
    inline void SetSeparateBlendOp(
185
 
      t_u32 BlendOpRGB_       = GL_FUNC_ADD,
186
 
      t_u32 BlendOpAlpha_     = GL_FUNC_ADD);
 
185
      unsigned int BlendOpRGB_       = GL_FUNC_ADD,
 
186
      unsigned int BlendOpAlpha_     = GL_FUNC_ADD);
187
187
 
188
188
    inline void SetCullMode(bool EnableCullFace,
189
 
                             t_u32 FrontFace_        = GL_CCW,
190
 
                             t_u32 Cullface_         = GL_BACK);
 
189
                             unsigned int FrontFace_        = GL_CCW,
 
190
                             unsigned int Cullface_         = GL_BACK);
191
191
 
192
192
    inline void SetDepthTest(bool EnableDepthTest,
193
 
                              t_u32 WriteEnable_      = GL_TRUE,
194
 
                              t_u32 DepthFunc_        = GL_LEQUAL);
 
193
                              unsigned int WriteEnable_      = GL_TRUE,
 
194
                              unsigned int DepthFunc_        = GL_LEQUAL);
195
195
 
196
196
    inline void SetDepthRange(
197
197
      float zNear = 0.0f,
199
199
 
200
200
 
201
201
    inline void SetStencil(bool enable_stencil);
202
 
    inline void SetStencilFunc(t_u32 func, int ref, t_u32 mask);
203
 
    inline void SetStencilOp(t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass);
 
202
    inline void SetStencilFunc(unsigned int func, int ref, unsigned int mask);
 
203
    inline void SetStencilOp(unsigned int stencil_fail, unsigned int stencil_pass_depth_fail, unsigned int stencil_pass_depth_pass);
204
204
 
205
205
#if 0
206
206
    // If two sided stencil is not activated, the setting is also used for the back face.
207
207
    inline void SetStencilFrontFace(
208
208
      bool EnableStencil_,                            // GL_TRUE enable stencil test
209
 
      t_u32 Func_             = GL_ALWAYS,
210
 
      t_u32 FailOp_           = GL_KEEP,
211
 
      t_u32 ZFailOp_          = GL_KEEP,
212
 
      t_u32 ZPassOp_          = GL_KEEP,
213
 
      t_u32 Ref_              = 0,
214
 
      t_u32 Mask_             = 0xffffffff);
 
209
      unsigned int Func_             = GL_ALWAYS,
 
210
      unsigned int FailOp_           = GL_KEEP,
 
211
      unsigned int ZFailOp_          = GL_KEEP,
 
212
      unsigned int ZPassOp_          = GL_KEEP,
 
213
      unsigned int Ref_              = 0,
 
214
      unsigned int Mask_             = 0xffffffff);
215
215
 
216
216
    // Set stencil test for the back face.
217
217
    inline void SetStencilBackFace(
218
218
      bool EnableTwoSideStencil_,                     // GL_TRUE enable Two Sided Stencil test
219
 
      t_u32 Func_             = GL_ALWAYS,
220
 
      t_u32 FailOp_           = GL_KEEP,
221
 
      t_u32 ZFailOp_          = GL_KEEP,
222
 
      t_u32 ZPassOp_          = GL_KEEP,
223
 
      t_u32 Ref_              = 0,
224
 
      t_u32 Mask_             = 0xffffffff);
 
219
      unsigned int Func_             = GL_ALWAYS,
 
220
      unsigned int FailOp_           = GL_KEEP,
 
221
      unsigned int ZFailOp_          = GL_KEEP,
 
222
      unsigned int ZPassOp_          = GL_KEEP,
 
223
      unsigned int Ref_              = 0,
 
224
      unsigned int Mask_             = 0xffffffff);
225
225
 
226
226
    inline void SetFrontFaceStencilWriteMask(
227
 
      t_u32 WriteMask_        = 0xffffffff);
 
227
      unsigned int WriteMask_        = 0xffffffff);
228
228
 
229
229
    inline void SetBackFaceStencilWriteMask(
230
 
      t_u32 WriteMask_        = 0xffffffff);
 
230
      unsigned int WriteMask_        = 0xffffffff);
231
231
#endif
232
232
 
233
233
    inline void EnableLineSmooth(
234
234
      bool EnableLineSmooth = TRUE,
235
 
      t_u32  LineWidth = 1,
236
 
      t_u32 HINT = GL_FASTEST);
 
235
      unsigned int  LineWidth = 1,
 
236
      unsigned int HINT = GL_FASTEST);
237
237
 
238
238
    inline void EnablePointSmooth(
239
239
      bool EnablePointSmooth = TRUE,
240
 
      t_u32  PointSize = 1,
241
 
      t_u32 HINT = GL_FASTEST);
 
240
      unsigned int  PointSize = 1,
 
241
      unsigned int HINT = GL_FASTEST);
242
242
 
243
243
    inline void SetColorMask(
244
 
      t_u32 bRed      = TRUE,
245
 
      t_u32 bGreen    = TRUE,
246
 
      t_u32 bBlue     = TRUE,
247
 
      t_u32 bAlpha    = TRUE);
 
244
      unsigned int bRed      = TRUE,
 
245
      unsigned int bGreen    = TRUE,
 
246
      unsigned int bBlue     = TRUE,
 
247
      unsigned int bAlpha    = TRUE);
248
248
 
249
249
    inline void GetColorMask(
250
 
      t_u32& bRed,
251
 
      t_u32& bGreen,
252
 
      t_u32& bBlue,
253
 
      t_u32& bAlpha);
 
250
      unsigned int& bRed,
 
251
      unsigned int& bGreen,
 
252
      unsigned int& bBlue,
 
253
      unsigned int& bAlpha);
254
254
    
255
 
    inline void SetDepthMask(t_u32 bDepth = TRUE);
 
255
    inline void SetDepthMask(unsigned int bDepth = TRUE);
256
256
 
257
 
    inline void EnableScissor(t_u32 bScissor = FALSE);
258
 
    inline void EnableFog(t_u32 bFog = FALSE);
 
257
    inline void EnableScissor(unsigned int bScissor = FALSE);
 
258
    inline void EnableFog(unsigned int bFog = FALSE);
259
259
#ifndef NUX_OPENGLES_20
260
 
    inline void SetPolygonMode(t_u32 FrontMode = GL_FILL, t_u32 BackMode = GL_FILL);
 
260
    inline void SetPolygonMode(unsigned int FrontMode = GL_FILL, unsigned int BackMode = GL_FILL);
261
261
#else
262
 
    inline void SetPolygonMode(t_u32 FrontMode, t_u32 BackMode);
 
262
    inline void SetPolygonMode(unsigned int FrontMode, unsigned int BackMode);
263
263
#endif
264
264
 
265
 
    inline void SetPolygonOffset(t_u32 bEnable,
 
265
    inline void SetPolygonOffset(unsigned int bEnable,
266
266
                                  float Factor = 0.0f, float Units = 0.0f);
267
267
 
268
268
  private:
270
270
    GpuBrand _gpu_brand;
271
271
    GpuInfo *_gpu_info;
272
272
 
273
 
    inline void HW__EnableAlphaTest(t_u32 b);
 
273
    inline void HW__EnableAlphaTest(unsigned int b);
274
274
 
275
275
    inline void HW__SetAlphaTestFunc(
276
 
      t_u32 AlphaTestFunc_,
 
276
      unsigned int AlphaTestFunc_,
277
277
      BYTE  AlphaTestRef_);
278
278
 
279
 
    inline void HW__EnableAlphaBlend(t_u32 b);
 
279
    inline void HW__EnableAlphaBlend(unsigned int b);
280
280
 
281
 
    inline void HW__SetSeparateAlphaBlend_Enable(t_u32 b);
 
281
    inline void HW__SetSeparateAlphaBlend_Enable(unsigned int b);
282
282
 
283
283
    inline void HW__SetSeparateAlphaBlendFactors(
284
 
      t_u32 SrcBlendFactor_,
285
 
      t_u32 DestBlendFactor_,
286
 
      t_u32 SrcFactorAlpha_,
287
 
      t_u32 DestFactorAlpha_);
288
 
 
289
 
    inline void HW__SetAlphaBlendOp(t_u32 BlendOpRGB_,
290
 
                                     t_u32 BlendOpAlpha_);
291
 
 
292
 
    inline void HW__EnableCulling(t_u32 b);
293
 
 
294
 
    inline void HW__SetFrontFace(t_u32 FrontFace_);
295
 
 
296
 
    inline void HW__SetCullFace(t_u32 CullFace_);
297
 
 
298
 
    inline void HW__SetEnableDepthTest(t_u32 b);
299
 
    inline void HW__SetDepthFunc(t_u32 Func);
 
284
      unsigned int SrcBlendFactor_,
 
285
      unsigned int DestBlendFactor_,
 
286
      unsigned int SrcFactorAlpha_,
 
287
      unsigned int DestFactorAlpha_);
 
288
 
 
289
    inline void HW__SetAlphaBlendOp(unsigned int BlendOpRGB_,
 
290
                                     unsigned int BlendOpAlpha_);
 
291
 
 
292
    inline void HW__EnableCulling(unsigned int b);
 
293
 
 
294
    inline void HW__SetFrontFace(unsigned int FrontFace_);
 
295
 
 
296
    inline void HW__SetCullFace(unsigned int CullFace_);
 
297
 
 
298
    inline void HW__SetEnableDepthTest(unsigned int b);
 
299
    inline void HW__SetDepthFunc(unsigned int Func);
300
300
    inline void HW__SetDepthRange(float zNear, float zFar);
301
301
 
302
302
 
303
 
    inline void HW__EnableStencil(t_u32 b);
304
 
    inline void HW__SetStencilOp(t_u32 FailOp_, t_u32 ZFailOp_, t_u32 ZPassOp_);
305
 
    inline void HW__SetStencilFunc(t_u32 func, int ref, t_u32 mask);
 
303
    inline void HW__EnableStencil(unsigned int b);
 
304
    inline void HW__SetStencilOp(unsigned int FailOp_, unsigned int ZFailOp_, unsigned int ZPassOp_);
 
305
    inline void HW__SetStencilFunc(unsigned int func, int ref, unsigned int mask);
306
306
 
307
307
#if 0
308
 
    inline void HW__EnableTwoSidedStencil(t_u32 b);
309
 
    inline void HW__SetStencilFrontFaceWriteMask(t_u32 WriteMask_);
310
 
    inline void HW__SetStencilBackFaceWriteMask(t_u32 WriteMask_);
 
308
    inline void HW__EnableTwoSidedStencil(unsigned int b);
 
309
    inline void HW__SetStencilFrontFaceWriteMask(unsigned int WriteMask_);
 
310
    inline void HW__SetStencilBackFaceWriteMask(unsigned int WriteMask_);
311
311
 
312
 
    inline void HW__SetFrontFaceStencilFunc(t_u32 Func_,
313
 
        t_u32 Ref_,
314
 
        t_u32 Mask_);
 
312
    inline void HW__SetFrontFaceStencilFunc(unsigned int Func_,
 
313
        unsigned int Ref_,
 
314
        unsigned int Mask_);
315
315
 
316
316
    inline void HW__SetBackFaceStencilFunc(
317
 
      t_u32 Func_,
318
 
      t_u32 Ref_,
319
 
      t_u32 Mask_);
 
317
      unsigned int Func_,
 
318
      unsigned int Ref_,
 
319
      unsigned int Mask_);
320
320
 
321
321
    inline void HW__SetFrontFaceStencilOp(
322
 
      t_u32 FailOp_,
323
 
      t_u32 ZFailOp_,
324
 
      t_u32 ZPassOp_);
 
322
      unsigned int FailOp_,
 
323
      unsigned int ZFailOp_,
 
324
      unsigned int ZPassOp_);
325
325
 
326
326
    inline void HW__SetBackFaceStencilOp(
327
 
      t_u32 FailOp_,
328
 
      t_u32 ZFailOp_,
329
 
      t_u32 ZPassOp_);
 
327
      unsigned int FailOp_,
 
328
      unsigned int ZFailOp_,
 
329
      unsigned int ZPassOp_);
330
330
#endif
331
331
 
332
 
    inline void HW__EnableLineSmooth(t_u32 EnableLineSmooth);
333
 
    inline void HW__SetLineWidth(t_u32 width, t_u32 HINT);
334
 
 
335
 
    inline void HW__EnablePointSmooth(t_u32 EnablePointSmooth);
336
 
    inline void HW__SetPointSize(t_u32 size, t_u32 HINT);
337
 
 
338
 
    inline void HW__SetColorMask(t_u32 bRed, t_u32 bGreen, t_u32 bBlue, t_u32 bAlpha);
339
 
    inline void HW__SetDepthMask(t_u32 bDepth);
340
 
 
341
 
    inline void HW__EnableScissor(t_u32 bScissor);
342
 
    inline void HW__EnableFog(t_u32 bFog);
343
 
 
344
 
    inline void HW__SetPolygonMode(t_u32 FrontMode, t_u32 BackMode);
345
 
    inline void HW__EnablePolygonOffset(t_u32 EnablePolygonOffset);
 
332
    inline void HW__EnableLineSmooth(unsigned int EnableLineSmooth);
 
333
    inline void HW__SetLineWidth(unsigned int width, unsigned int HINT);
 
334
 
 
335
    inline void HW__EnablePointSmooth(unsigned int EnablePointSmooth);
 
336
    inline void HW__SetPointSize(unsigned int size, unsigned int HINT);
 
337
 
 
338
    inline void HW__SetColorMask(unsigned int bRed, unsigned int bGreen, unsigned int bBlue, unsigned int bAlpha);
 
339
    inline void HW__SetDepthMask(unsigned int bDepth);
 
340
 
 
341
    inline void HW__EnableScissor(unsigned int bScissor);
 
342
    inline void HW__EnableFog(unsigned int bFog);
 
343
 
 
344
    inline void HW__SetPolygonMode(unsigned int FrontMode, unsigned int BackMode);
 
345
    inline void HW__EnablePolygonOffset(unsigned int EnablePolygonOffset);
346
346
    inline void HW__SetPolygonOffset(float Factor, float Units);
347
347
 
348
348
  private:
361
361
 
362
362
  inline void GpuRenderStates::SetAlphaTest(
363
363
    bool EnableAlphaTest_,
364
 
    t_u32 AlphaTestFunc_,
 
364
    unsigned int AlphaTestFunc_,
365
365
    BYTE AlphaTestRef_)
366
366
  {
367
367
    if (EnableAlphaTest_)
403
403
  }
404
404
 
405
405
  inline void GpuRenderStates::SetBlend(bool AlphaBlendEnable_,
406
 
                                        t_u32 SrcBlendFactor_,
407
 
                                        t_u32 DestBlendFactor_)
 
406
                                        unsigned int SrcBlendFactor_,
 
407
                                        unsigned int DestBlendFactor_)
408
408
  {
409
409
    SetBlend(AlphaBlendEnable_);
410
410
 
419
419
    }
420
420
  }
421
421
 
422
 
  inline void GpuRenderStates::GetBlend(t_u32& AlphaBlendEnable_,
423
 
                    t_u32& SrcBlendFactor_,
424
 
                    t_u32& DestBlendFactor_)
 
422
  inline void GpuRenderStates::GetBlend(unsigned int& AlphaBlendEnable_,
 
423
                    unsigned int& SrcBlendFactor_,
 
424
                    unsigned int& DestBlendFactor_)
425
425
  {
426
426
    AlphaBlendEnable_ = RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]);
427
427
    SrcBlendFactor_   = RS_VALUE(m_RenderStateChanges[GFXRS_SRCBLEND]);
429
429
  }
430
430
    
431
431
  inline void GpuRenderStates::SetSeparateBlend(bool EnableSeparateAlphaBlend,
432
 
      t_u32 SrcBlendFactor_,
433
 
      t_u32 DestBlendFactor_,
434
 
      t_u32 SrcBlendFactorAlpha_,
435
 
      t_u32 DestBlendFactorAlpha_)
 
432
      unsigned int SrcBlendFactor_,
 
433
      unsigned int DestBlendFactor_,
 
434
      unsigned int SrcBlendFactorAlpha_,
 
435
      unsigned int DestBlendFactorAlpha_)
436
436
  {
437
437
    SetBlend(EnableSeparateAlphaBlend);
438
438
 
471
471
  {
472
472
    static const struct
473
473
    {
474
 
      const t_u32 src_blend;
475
 
      const t_u32 dst_blend;
 
474
      const unsigned int src_blend;
 
475
      const unsigned int dst_blend;
476
476
    } factor[13] =
477
477
    {
478
478
      { GL_ZERO,                GL_ZERO                }, // CLEAR
501
501
    }
502
502
  }
503
503
 
504
 
  inline void GpuRenderStates::SetBlendOp(t_u32 BlendOp)
 
504
  inline void GpuRenderStates::SetBlendOp(unsigned int BlendOp)
505
505
  {
506
506
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOp))
507
507
    {
510
510
  }
511
511
 
512
512
  inline void GpuRenderStates::SetSeparateBlendOp(
513
 
    t_u32 BlendOpRGB_,
514
 
    t_u32 BlendOpAlpha_)
 
513
    unsigned int BlendOpRGB_,
 
514
    unsigned int BlendOpAlpha_)
515
515
  {
516
516
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOpRGB_) ||
517
517
         (RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA]) != BlendOpAlpha_))
521
521
  }
522
522
 
523
523
  inline void GpuRenderStates::SetCullMode(bool EnableCullFace,
524
 
      t_u32 FrontFace_,
525
 
      t_u32 Cullface_)
 
524
      unsigned int FrontFace_,
 
525
      unsigned int Cullface_)
526
526
  {
527
527
    if (EnableCullFace)
528
528
    {
550
550
  }
551
551
 
552
552
  inline void GpuRenderStates::SetDepthTest(bool EnableDepthTest,
553
 
      t_u32 WriteEnable_,
554
 
      t_u32 DepthFunc_)
 
553
      unsigned int WriteEnable_,
 
554
      unsigned int DepthFunc_)
555
555
  {
556
556
    if (EnableDepthTest)
557
557
    {
580
580
 
581
581
  inline void GpuRenderStates::SetDepthRange(float zNear, float zFar)
582
582
  {
583
 
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR]) != static_cast<t_u32> (zNear)) ||
584
 
         (RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR]) != static_cast<t_u32> (zFar)))
 
583
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR]) != static_cast<unsigned int> (zNear)) ||
 
584
         (RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR]) != static_cast<unsigned int> (zFar)))
585
585
    {
586
586
      HW__SetDepthRange(zNear, zFar);
587
587
    }
602
602
    }
603
603
  }
604
604
 
605
 
  void GpuRenderStates::SetStencilFunc(t_u32 func, int ref, t_u32 mask)
 
605
  void GpuRenderStates::SetStencilFunc(unsigned int func, int ref, unsigned int mask)
606
606
  {
607
607
    if (
608
608
      (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]) != func) ||
609
 
      (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != (t_u32)ref) ||
 
609
      (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != (unsigned int)ref) ||
610
610
      (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != mask)
611
611
      )
612
612
    {
614
614
    }
615
615
  }
616
616
 
617
 
  void GpuRenderStates::SetStencilOp(t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass)
 
617
  void GpuRenderStates::SetStencilOp(unsigned int stencil_fail, unsigned int stencil_pass_depth_fail, unsigned int stencil_pass_depth_pass)
618
618
  {
619
619
    if (
620
620
      (RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != stencil_fail) ||
629
629
#if 0
630
630
  inline void GpuRenderStates::SetStencilFrontFace(
631
631
    bool EnableStencil_,                            // GL_TRUE enable stencil test
632
 
    t_u32 Func_,
633
 
    t_u32 FailOp_,
634
 
    t_u32 ZFailOp_,
635
 
    t_u32 ZPassOp_,
636
 
    t_u32 Ref_,
637
 
    t_u32 Mask_)
 
632
    unsigned int Func_,
 
633
    unsigned int FailOp_,
 
634
    unsigned int ZFailOp_,
 
635
    unsigned int ZPassOp_,
 
636
    unsigned int Ref_,
 
637
    unsigned int Mask_)
638
638
  {
639
639
    if (EnableStencil_)
640
640
    {
666
666
 
667
667
  inline void GpuRenderStates::SetStencilBackFace(
668
668
    bool EnableTwoSideStencil_,                     // GL_TRUE enable Two Sided Stencil test
669
 
    t_u32 Func_,
670
 
    t_u32 FailOp_,
671
 
    t_u32 ZFailOp_,
672
 
    t_u32 ZPassOp_,
673
 
    t_u32 Ref_,
674
 
    t_u32 Mask_)
 
669
    unsigned int Func_,
 
670
    unsigned int FailOp_,
 
671
    unsigned int ZFailOp_,
 
672
    unsigned int ZPassOp_,
 
673
    unsigned int Ref_,
 
674
    unsigned int Mask_)
675
675
  {
676
676
    if (EnableTwoSideStencil_)
677
677
    {
707
707
  }
708
708
 
709
709
  inline void GpuRenderStates::SetFrontFaceStencilWriteMask(
710
 
    t_u32 WriteMask_)
 
710
    unsigned int WriteMask_)
711
711
  {
712
712
    HW__SetStencilFrontFaceWriteMask(WriteMask_);
713
713
  }
714
714
 
715
715
  inline void GpuRenderStates::SetBackFaceStencilWriteMask(
716
 
    t_u32 WriteMask_)
 
716
    unsigned int WriteMask_)
717
717
  {
718
718
    HW__SetStencilBackFaceWriteMask(WriteMask_);
719
719
  }
721
721
 
722
722
  inline void GpuRenderStates::EnableLineSmooth(
723
723
    bool EnableLineSmooth,
724
 
    t_u32  LineWidth,
725
 
    t_u32 Hint)
 
724
    unsigned int  LineWidth,
 
725
    unsigned int Hint)
726
726
  {
727
727
    if (EnableLineSmooth)
728
728
    {
746
746
 
747
747
  inline void GpuRenderStates::EnablePointSmooth(
748
748
    bool EnablePointSmooth,
749
 
    t_u32  PointSize,
750
 
    t_u32 Hint)
 
749
    unsigned int  PointSize,
 
750
    unsigned int Hint)
751
751
  {
752
752
    if (EnablePointSmooth)
753
753
    {
770
770
  }
771
771
 
772
772
  inline void GpuRenderStates::SetColorMask(
773
 
    t_u32 bRed,
774
 
    t_u32 bGreen,
775
 
    t_u32 bBlue,
776
 
    t_u32 bAlpha)
 
773
    unsigned int bRed,
 
774
    unsigned int bGreen,
 
775
    unsigned int bBlue,
 
776
    unsigned int bAlpha)
777
777
  {
778
778
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]) != bRed) ||
779
779
         (RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]) != bGreen) ||
786
786
  }
787
787
 
788
788
  inline void GpuRenderStates::GetColorMask(
789
 
    t_u32& bRed,
790
 
    t_u32& bGreen,
791
 
    t_u32& bBlue,
792
 
    t_u32& bAlpha)
 
789
    unsigned int& bRed,
 
790
    unsigned int& bGreen,
 
791
    unsigned int& bBlue,
 
792
    unsigned int& bAlpha)
793
793
  {
794
794
    bRed    = RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]);
795
795
    bGreen  = RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]);
797
797
    bAlpha  = RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]);
798
798
  }
799
799
  
800
 
  inline void GpuRenderStates::SetDepthMask(t_u32 bDepth)
 
800
  inline void GpuRenderStates::SetDepthMask(unsigned int bDepth)
801
801
  {
802
802
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != bDepth))
803
803
    {
805
805
    }
806
806
  }
807
807
 
808
 
  inline void GpuRenderStates::EnableScissor(t_u32 bScissor)
 
808
  inline void GpuRenderStates::EnableScissor(unsigned int bScissor)
809
809
  {
810
810
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_SCISSORTESTENABLE]) != bScissor))
811
811
    {
813
813
    }
814
814
  }
815
815
 
816
 
  inline void GpuRenderStates::EnableFog(t_u32 bFog)
 
816
  inline void GpuRenderStates::EnableFog(unsigned int bFog)
817
817
  {
818
818
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_FOGENABLE]) != bFog))
819
819
    {
821
821
    }
822
822
  }
823
823
 
824
 
  inline void GpuRenderStates::SetPolygonMode(t_u32 FrontMode, t_u32 BackMode)
 
824
  inline void GpuRenderStates::SetPolygonMode(unsigned int FrontMode, unsigned int BackMode)
825
825
  {
826
826
    if ((RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]) != FrontMode) ||
827
827
         (RS_VALUE(m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]) != BackMode))
830
830
    }
831
831
  }
832
832
 
833
 
  inline void GpuRenderStates::SetPolygonOffset(t_u32 bEnable,
 
833
  inline void GpuRenderStates::SetPolygonOffset(unsigned int bEnable,
834
834
      float Factor, float Units)
835
835
  {
836
836
    if (bEnable)
840
840
        HW__EnablePolygonOffset(GL_TRUE);
841
841
      }
842
842
 
843
 
      if ((RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]) != static_cast<t_u32> (Factor)) ||
844
 
           (RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]) != static_cast<t_u32> (Units)))
 
843
      if ((RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]) != static_cast<unsigned int> (Factor)) ||
 
844
           (RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]) != static_cast<unsigned int> (Units)))
845
845
      {
846
846
        HW__SetPolygonOffset(Factor, Units);
847
847
      }
854
854
 
855
855
 
856
856
//////////////////////////////////////
857
 
  inline void GpuRenderStates::HW__EnableAlphaTest(t_u32 b)
 
857
  inline void GpuRenderStates::HW__EnableAlphaTest(unsigned int b)
858
858
  {
859
859
#ifndef NUX_OPENGLES_20
860
860
    if (b)
870
870
#endif
871
871
  }
872
872
 
873
 
  inline void GpuRenderStates::HW__SetAlphaTestFunc(t_u32 AlphaTestFunc_,
 
873
  inline void GpuRenderStates::HW__SetAlphaTestFunc(unsigned int AlphaTestFunc_,
874
874
      BYTE  AlphaTestRef_)
875
875
  {
876
876
#ifndef NUX_OPENGLES_20
891
891
#endif
892
892
  }
893
893
 
894
 
  inline void GpuRenderStates::HW__EnableAlphaBlend(t_u32 b)
 
894
  inline void GpuRenderStates::HW__EnableAlphaBlend(unsigned int b)
895
895
  {
896
896
    if (b)
897
897
    {
906
906
  }
907
907
 
908
908
  inline void GpuRenderStates::HW__SetSeparateAlphaBlendFactors(
909
 
    t_u32 SrcBlendFactor_,
910
 
    t_u32 DestBlendFactor_,
911
 
    t_u32 SrcFactorAlpha_,
912
 
    t_u32 DestFactorAlpha_)
 
909
    unsigned int SrcBlendFactor_,
 
910
    unsigned int DestBlendFactor_,
 
911
    unsigned int SrcFactorAlpha_,
 
912
    unsigned int DestFactorAlpha_)
913
913
  {
914
914
    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),
915
915
                   "Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState");
933
933
  }
934
934
 
935
935
  inline void GpuRenderStates::HW__SetAlphaBlendOp(
936
 
    t_u32 BlendOpRGB_,
937
 
    t_u32 BlendOpAlpha_)
 
936
    unsigned int BlendOpRGB_,
 
937
    unsigned int BlendOpAlpha_)
938
938
  {
939
939
#ifdef NUX_OPENGLES_20
940
940
    nuxAssertMsg(
984
984
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_BLENDOPALPHA], BlendOpAlpha_);
985
985
  }
986
986
 
987
 
  inline void GpuRenderStates::HW__EnableCulling(t_u32 b)
 
987
  inline void GpuRenderStates::HW__EnableCulling(unsigned int b)
988
988
  {
989
989
    if (b)
990
990
    {
999
999
  }
1000
1000
 
1001
1001
 
1002
 
  inline void GpuRenderStates::HW__SetFrontFace(t_u32 FrontFace_)
 
1002
  inline void GpuRenderStates::HW__SetFrontFace(unsigned int FrontFace_)
1003
1003
  {
1004
1004
    nuxAssertMsg(
1005
1005
      (FrontFace_ == GL_CW) ||
1010
1010
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONTFACE], FrontFace_);
1011
1011
  }
1012
1012
 
1013
 
  inline void GpuRenderStates::HW__SetCullFace(t_u32 CullFace_)
 
1013
  inline void GpuRenderStates::HW__SetCullFace(unsigned int CullFace_)
1014
1014
  {
1015
1015
    nuxAssertMsg(
1016
1016
      (CullFace_ == GL_FRONT) ||
1022
1022
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_CULLFACE], CullFace_);
1023
1023
  }
1024
1024
 
1025
 
  inline void GpuRenderStates::HW__SetEnableDepthTest(t_u32 b)
 
1025
  inline void GpuRenderStates::HW__SetEnableDepthTest(unsigned int b)
1026
1026
  {
1027
1027
    if (b)
1028
1028
    {
1039
1039
  inline void GpuRenderStates::HW__SetDepthRange(float zNear, float zFar)
1040
1040
  {
1041
1041
    CHECKGL(glDepthRange(zNear, zFar));
1042
 
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR], static_cast<t_u32> (Clamp(zNear, 0.0f, 1.0f)));
1043
 
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR], static_cast<t_u32> (Clamp(zFar, 0.0f, 1.0f)));
 
1042
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZNEAR], static_cast<unsigned int> (Clamp(zNear, 0.0f, 1.0f)));
 
1043
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZFAR], static_cast<unsigned int> (Clamp(zFar, 0.0f, 1.0f)));
1044
1044
  }
1045
1045
 
1046
 
  inline void GpuRenderStates::HW__SetDepthFunc(t_u32 Func)
 
1046
  inline void GpuRenderStates::HW__SetDepthFunc(unsigned int Func)
1047
1047
  {
1048
1048
    nuxAssertMsg(
1049
1049
      (Func == GL_NEVER) ||
1060
1060
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZFUNC], Func);
1061
1061
  }
1062
1062
 
1063
 
  inline void GpuRenderStates::HW__EnableStencil(t_u32 b)
 
1063
  inline void GpuRenderStates::HW__EnableStencil(unsigned int b)
1064
1064
  {
1065
1065
    if (b)
1066
1066
    {
1074
1074
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_STENCILENABLE], b ? GL_TRUE : GL_FALSE);
1075
1075
  }
1076
1076
 
1077
 
  inline void GpuRenderStates::HW__SetStencilFunc(t_u32 func, int ref, t_u32 mask)
 
1077
  inline void GpuRenderStates::HW__SetStencilFunc(unsigned int func, int ref, unsigned int mask)
1078
1078
  {
1079
1079
    nuxAssertMsg(
1080
1080
      (func == GL_NEVER) ||
1094
1094
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], mask);
1095
1095
  }
1096
1096
 
1097
 
  inline void GpuRenderStates::HW__SetStencilOp(t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass)
 
1097
  inline void GpuRenderStates::HW__SetStencilOp(unsigned int stencil_fail, unsigned int stencil_pass_depth_fail, unsigned int stencil_pass_depth_pass)
1098
1098
  {
1099
1099
    nuxAssertMsg(
1100
1100
      (stencil_fail == GL_KEEP) ||
1137
1137
  }
1138
1138
 
1139
1139
#if 0
1140
 
  inline void GpuRenderStates::HW__EnableTwoSidedStencil(t_u32 b)
 
1140
  inline void GpuRenderStates::HW__EnableTwoSidedStencil(unsigned int b)
1141
1141
  {
1142
1142
    if (b)
1143
1143
    {
1165
1165
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE], b ? GL_TRUE : GL_FALSE);
1166
1166
  }
1167
1167
 
1168
 
  inline void GpuRenderStates::HW__SetStencilFrontFaceWriteMask(t_u32 WriteMask_)
 
1168
  inline void GpuRenderStates::HW__SetStencilFrontFaceWriteMask(unsigned int WriteMask_)
1169
1169
  {
1170
1170
    CHECKGL(glActiveStencilFaceEXT(GL_FRONT));
1171
1171
    CHECKGL(glStencilMask(WriteMask_));
1172
1172
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK], WriteMask_);
1173
1173
  }
1174
1174
 
1175
 
  inline void GpuRenderStates::HW__SetStencilBackFaceWriteMask(t_u32 WriteMask_)
 
1175
  inline void GpuRenderStates::HW__SetStencilBackFaceWriteMask(unsigned int WriteMask_)
1176
1176
  {
1177
1177
    CHECKGL(glActiveStencilFaceEXT(GL_BACK));
1178
1178
    CHECKGL(glStencilMask(WriteMask_));
1179
1179
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK], WriteMask_);
1180
1180
  }
1181
1181
 
1182
 
  inline void GpuRenderStates::HW__SetFrontFaceStencilFunc(t_u32 Func_,
1183
 
      t_u32 Ref_,
1184
 
      t_u32 Mask_)
 
1182
  inline void GpuRenderStates::HW__SetFrontFaceStencilFunc(unsigned int Func_,
 
1183
      unsigned int Ref_,
 
1184
      unsigned int Mask_)
1185
1185
  {
1186
1186
    nuxAssertMsg(
1187
1187
      (Func_ == GL_NEVER) ||
1203
1203
  }
1204
1204
 
1205
1205
  inline void GpuRenderStates::HW__SetBackFaceStencilFunc(
1206
 
    t_u32 Func_,
1207
 
    t_u32 Ref_,
1208
 
    t_u32 Mask_)
 
1206
    unsigned int Func_,
 
1207
    unsigned int Ref_,
 
1208
    unsigned int Mask_)
1209
1209
  {
1210
1210
    nuxAssertMsg(
1211
1211
      (Func_ == GL_NEVER) ||
1234
1234
  }
1235
1235
 
1236
1236
  inline void GpuRenderStates::HW__SetFrontFaceStencilOp(
1237
 
    t_u32 FailOp_,
1238
 
    t_u32 ZFailOp_,
1239
 
    t_u32 ZPassOp_)
 
1237
    unsigned int FailOp_,
 
1238
    unsigned int ZFailOp_,
 
1239
    unsigned int ZPassOp_)
1240
1240
  {
1241
1241
    nuxAssertMsg(
1242
1242
      (FailOp_ == GL_KEEP) ||
1287
1287
  }
1288
1288
 
1289
1289
  inline void GpuRenderStates::HW__SetBackFaceStencilOp(
1290
 
    t_u32 FailOp_,
1291
 
    t_u32 ZFailOp_,
1292
 
    t_u32 ZPassOp_)
 
1290
    unsigned int FailOp_,
 
1291
    unsigned int ZFailOp_,
 
1292
    unsigned int ZPassOp_)
1293
1293
  {
1294
1294
    nuxAssertMsg(
1295
1295
      (FailOp_ == GL_KEEP) ||
1340
1340
  }
1341
1341
#endif
1342
1342
 
1343
 
  inline void GpuRenderStates::HW__EnableLineSmooth(t_u32 EnableLineSmooth)
 
1343
  inline void GpuRenderStates::HW__EnableLineSmooth(unsigned int EnableLineSmooth)
1344
1344
  {
1345
1345
#ifndef NUX_OPENGLES_20
1346
1346
    if (EnableLineSmooth)
1356
1356
#endif
1357
1357
  }
1358
1358
 
1359
 
  inline void GpuRenderStates::HW__SetLineWidth(t_u32 width,  t_u32 Hint)
 
1359
  inline void GpuRenderStates::HW__SetLineWidth(unsigned int width,  unsigned int Hint)
1360
1360
  {
1361
1361
    nuxAssertMsg(
1362
1362
      (Hint == GL_NICEST) ||
1373
1373
#endif
1374
1374
  }
1375
1375
 
1376
 
  inline void GpuRenderStates::HW__EnablePointSmooth(t_u32 EnablePointSmooth)
 
1376
  inline void GpuRenderStates::HW__EnablePointSmooth(unsigned int EnablePointSmooth)
1377
1377
  {
1378
1378
#ifndef NUX_OPENGLES_20
1379
1379
    if (EnablePointSmooth)
1389
1389
#endif
1390
1390
  }
1391
1391
 
1392
 
  inline void GpuRenderStates::HW__SetPointSize(t_u32 size,  t_u32 Hint)
 
1392
  inline void GpuRenderStates::HW__SetPointSize(unsigned int size,  unsigned int Hint)
1393
1393
  {
1394
1394
#ifndef NUX_OPENGLES_20
1395
1395
    nuxAssertMsg(
1406
1406
  }
1407
1407
 
1408
1408
  inline void GpuRenderStates::HW__SetColorMask(
1409
 
    t_u32 bRed,
1410
 
    t_u32 bGreen,
1411
 
    t_u32 bBlue,
1412
 
    t_u32 bAlpha)
 
1409
    unsigned int bRed,
 
1410
    unsigned int bGreen,
 
1411
    unsigned int bBlue,
 
1412
    unsigned int bAlpha)
1413
1413
  {
1414
1414
    CHECKGL(glColorMask(bRed, bGreen, bBlue, bAlpha));
1415
1415
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R], bRed);
1418
1418
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A], bAlpha);
1419
1419
  }
1420
1420
 
1421
 
  inline void GpuRenderStates::HW__SetDepthMask(t_u32 bDepth)
 
1421
  inline void GpuRenderStates::HW__SetDepthMask(unsigned int bDepth)
1422
1422
  {
1423
1423
    CHECKGL(glDepthMask(bDepth));
1424
1424
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_ZWRITEENABLE], bDepth);
1425
1425
  }
1426
1426
 
1427
 
  inline void GpuRenderStates::HW__EnableScissor(t_u32 bScissor)
 
1427
  inline void GpuRenderStates::HW__EnableScissor(unsigned int bScissor)
1428
1428
  {
1429
1429
    if (bScissor)
1430
1430
    {
1438
1438
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_SCISSORTESTENABLE], bScissor ? GL_TRUE : GL_FALSE);
1439
1439
  }
1440
1440
 
1441
 
  inline void GpuRenderStates::HW__EnableFog(t_u32 bFog)
 
1441
  inline void GpuRenderStates::HW__EnableFog(unsigned int bFog)
1442
1442
  {
1443
1443
#ifndef NUX_OPENGLES_20
1444
1444
    if (bFog)
1454
1454
#endif
1455
1455
  }
1456
1456
 
1457
 
  inline void GpuRenderStates::HW__SetPolygonMode(t_u32 FrontMode, t_u32 BackMode)
 
1457
  inline void GpuRenderStates::HW__SetPolygonMode(unsigned int FrontMode, unsigned int BackMode)
1458
1458
  {
1459
1459
#ifndef NUX_OPENGLES_20
1460
1460
    nuxAssertMsg(
1477
1477
#endif
1478
1478
  }
1479
1479
 
1480
 
  inline void GpuRenderStates::HW__EnablePolygonOffset(t_u32 EnablePolygonOffset)
 
1480
  inline void GpuRenderStates::HW__EnablePolygonOffset(unsigned int EnablePolygonOffset)
1481
1481
  {
1482
1482
    if (EnablePolygonOffset)
1483
1483
    {
1495
1495
  {
1496
1496
    CHECKGL(glPolygonOffset(Factor, Units));
1497
1497
 
1498
 
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR], static_cast<t_u32> (Factor));
1499
 
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS], static_cast<t_u32> (Units));
 
1498
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR], static_cast<unsigned int> (Factor));
 
1499
    SET_RS_VALUE(m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS], static_cast<unsigned int> (Units));
1500
1500
  }
1501
1501
 
1502
1502
#undef SET_RS_VALUE