Visualization Library

A lightweight C++ OpenGL middleware for 2D/3D graphics 		[Home] [Tutorials] [All Classes] [Grouped Classes]

X:/dropbox/visualizationlibrary/src/vlGraphics/Shader.hpp

Go to the documentation of this file.
00001 /**************************************************************************************/
00002 /*                                                                                    */
00003 /*  Visualization Library                                                             */
00004 /*  http://www.visualizationlibrary.org                                               */
00005 /*                                                                                    */
00006 /*  Copyright (c) 2005-2011, Michele Bosi                                             */
00007 /*  All rights reserved.                                                              */
00008 /*                                                                                    */
00009 /*  Redistribution and use in source and binary forms, with or without modification,  */
00010 /*  are permitted provided that the following conditions are met:                     */
00011 /*                                                                                    */
00012 /*  - Redistributions of source code must retain the above copyright notice, this     */
00013 /*  list of conditions and the following disclaimer.                                  */
00014 /*                                                                                    */
00015 /*  - Redistributions in binary form must reproduce the above copyright notice, this  */
00016 /*  list of conditions and the following disclaimer in the documentation and/or       */
00017 /*  other materials provided with the distribution.                                   */
00018 /*                                                                                    */
00019 /*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
00020 /*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
00021 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
00022 /*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
00023 /*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
00024 /*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
00025 /*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
00026 /*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
00027 /*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
00028 /*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
00029 /*                                                                                    */
00030 /**************************************************************************************/
00031 
00032 #ifndef Shader_INCLUDE_ONCE
00033 #define Shader_INCLUDE_ONCE
00034 
00035 #include <vlCore/Vector4.hpp>
00036 #include <vlCore/Matrix4.hpp>
00037 #include <vlGraphics/link_config.hpp>
00038 #include <vlGraphics/RenderState.hpp>
00039 #include <vlGraphics/RenderStateSet.hpp>
00040 #include <vlGraphics/EnableSet.hpp>
00041 #include <vlGraphics/UniformSet.hpp>
00042 #include <vlGraphics/Texture.hpp>
00043 #include <vlGraphics/Scissor.hpp>
00044 #include <vlGraphics/Light.hpp>
00045 #include <vlGraphics/ClipPlane.hpp>
00046 #include <vector>
00047 
00048 namespace vl
00049 {
00050   class Light;
00051   class ClipPlane;
00052   class Shader;
00053   //------------------------------------------------------------------------------
00054   // VertexAttrib
00055   //------------------------------------------------------------------------------
00059   // todo: would be nice to support double, int and uint types as well.
00060   class VLGRAPHICS_EXPORT VertexAttrib: public RenderStateIndexed
00061   {
00062     VL_INSTRUMENT_CLASS(vl::VertexAttrib, RenderStateIndexed)
00063 
00064   public:
00065     VertexAttrib(): mValue( fvec4(0,0,0,0) ) 
00066     {
00067       VL_DEBUG_SET_OBJECT_NAME()
00068     }
00069 
00070     virtual ERenderState type() const { return RS_VertexAttrib; }
00071 
00072     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00073 
00074     void setValue(const fvec4& value) { mValue = value; }
00075 
00076     const fvec4& value() const { return mValue; }
00077 
00078     virtual ref<RenderState> clone() const
00079     {
00080       ref<VertexAttrib> rs = new VertexAttrib;
00081       *rs = *this;
00082       return rs;
00083     }
00084 
00085   protected:
00086     fvec4 mValue;
00087   };
00088   //------------------------------------------------------------------------------
00089   // Color
00090   //------------------------------------------------------------------------------
00094   class VLGRAPHICS_EXPORT Color: public RenderStateNonIndexed
00095   {
00096     VL_INSTRUMENT_CLASS(vl::Color, RenderStateNonIndexed)
00097 
00098   public:
00099     Color(): mColor( fvec4(1,1,1,1) )
00100     {
00101       VL_DEBUG_SET_OBJECT_NAME()
00102     }
00103 
00104     virtual ERenderState type() const { return RS_Color; }
00105 
00106     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00107 
00108     void setValue(const fvec4& color) { mColor = color; }
00109 
00110     const fvec4& value() const { return mColor; }
00111 
00112     virtual ref<RenderState> clone() const
00113     {
00114       ref<Color> rs = new Color;
00115       *rs = *this;
00116       return rs;
00117     }
00118 
00119   protected:
00120     fvec4 mColor;
00121   };
00122   //------------------------------------------------------------------------------
00123   // SecondaryColor
00124   //------------------------------------------------------------------------------
00128   class VLGRAPHICS_EXPORT SecondaryColor: public RenderStateNonIndexed
00129   {
00130     VL_INSTRUMENT_CLASS(vl::SecondaryColor, RenderStateNonIndexed)
00131 
00132   public:
00133     SecondaryColor(): mSecondaryColor( fvec3(1,1,1) )
00134     {
00135       VL_DEBUG_SET_OBJECT_NAME()
00136     }
00137 
00138     virtual ERenderState type() const { return RS_SecondaryColor; }
00139 
00140     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00141 
00142     void setValue(const fvec3& color) { mSecondaryColor = color; }
00143 
00144     const fvec3& value() const { return mSecondaryColor; }
00145 
00146     virtual ref<RenderState> clone() const
00147     {
00148       ref<SecondaryColor> rs = new SecondaryColor;
00149       *rs = *this;
00150       return rs;
00151     }
00152 
00153   protected:
00154     fvec3 mSecondaryColor;
00155   };
00156   //------------------------------------------------------------------------------
00157   // Normal
00158   //------------------------------------------------------------------------------
00162   class VLGRAPHICS_EXPORT Normal: public RenderStateNonIndexed
00163   {
00164     VL_INSTRUMENT_CLASS(vl::Normal, RenderStateNonIndexed)
00165 
00166   public:
00167     Normal(): mNormal( fvec3(0,1,0) )
00168     {
00169       VL_DEBUG_SET_OBJECT_NAME()
00170     }
00171 
00172     virtual ERenderState type() const { return RS_Normal; }
00173 
00174     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00175 
00176     void setValue(const fvec3& color) { mNormal = color; }
00177 
00178     const fvec3& value() const { return mNormal; }
00179 
00180     virtual ref<RenderState> clone() const
00181     {
00182       ref<Normal> rs = new Normal;
00183       *rs = *this;
00184       return rs;
00185     }
00186 
00187   protected:
00188     fvec3 mNormal;
00189   };
00190   //------------------------------------------------------------------------------
00191   // PixelTransfer
00192   //------------------------------------------------------------------------------
00196   class VLGRAPHICS_EXPORT PixelTransfer: public RenderStateNonIndexed
00197   {
00198     VL_INSTRUMENT_CLASS(vl::PixelTransfer, RenderStateNonIndexed)
00199 
00200   public:
00201     PixelTransfer()
00202     {
00203       VL_DEBUG_SET_OBJECT_NAME()
00204       mMapColor    = false;
00205       mMapStencil  = false;
00206       mIndexShift  = 0;
00207       mIndexOffset = 0;
00208       mRedScale    = 1;
00209       mGreenScale  = 1;
00210       mBlueScale   = 1;
00211       mAlphaScale  = 1;
00212       mDepthScale  = 1;
00213       mRedBias     = 0;
00214       mGreenBias   = 0;
00215       mBlueBias    = 0;
00216       mAlphaBias   = 0;
00217       mDepthBias   = 0;
00218       mPostColorMatrixRedScale   = 1;
00219       mPostColorMatrixGreenScale = 1;
00220       mPostColorMatrixBlueScale  = 1;
00221       mPostColorMatrixAlphaScale = 1;
00222       mPostColorMatrixRedBias    = 0;
00223       mPostColorMatrixGreenBias  = 0;
00224       mPostColorMatrixBlueBias   = 0;
00225       mPostColorMatrixAlphaBias  = 0;
00226       mPostConvolutionRedScale   = 1;
00227       mPostConvolutionGreenScale = 1;
00228       mPostConvolutionBlueScale  = 1;
00229       mPostConvolutionAlphaScale = 1;
00230       mPostConvolutionRedBias    = 0;
00231       mPostConvolutionGreenBias  = 0;
00232       mPostConvolutionBlueBias   = 0;
00233       mPostConvolutionAlphaBias  = 0;
00234     }
00235 
00236     virtual ERenderState type() const { return RS_PixelTransfer; }
00237 
00238     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00239 
00240     bool mapColor() const { return mMapColor; }
00241     bool mapStencil() const { return mMapStencil; }
00242     int indexShift() const { return mIndexShift; }
00243     int indexOffset() const { return mIndexOffset; }
00244     float redScale() const { return mRedScale; }
00245     float greenScale() const { return mGreenScale; }
00246     float blueScale() const { return mBlueScale; }
00247     float alphaScale() const { return mAlphaScale; }
00248     float depthScale() const { return mDepthScale; }
00249     float redBias() const { return mRedBias; }
00250     float greenBias() const { return mGreenBias; }
00251     float blueBias() const { return mBlueBias; }
00252     float alphaBias() const { return mAlphaBias; }
00253     float depthBias() const { return mDepthBias; }
00254     float postColorMatrixRedScale() const { return mPostColorMatrixRedScale; }
00255     float postColorMatrixGreenScale() const { return mPostColorMatrixGreenScale; }
00256     float postColorMatrixBlueScale() const { return mPostColorMatrixBlueScale; }
00257     float postColorMatrixAlphaScale() const { return mPostColorMatrixAlphaScale; }
00258     float postColorMatrixRedBias() const { return mPostColorMatrixRedBias; }
00259     float postColorMatrixGreenBias() const { return mPostColorMatrixGreenBias; }
00260     float postColorMatrixBlueBias() const { return mPostColorMatrixBlueBias; }
00261     float postColorMatrixAlphaBias() const { return mPostColorMatrixAlphaBias; }
00262     float postConvolutionRedScale() const { return mPostConvolutionRedScale; }
00263     float postConvolutionGreenScale() const { return mPostConvolutionGreenScale; }
00264     float postConvolutionBlueScale() const { return mPostConvolutionBlueScale; }
00265     float postConvolutionAlphaScale() const { return mPostConvolutionAlphaScale; }
00266     float postConvolutionRedBias() const { return mPostConvolutionRedBias; }
00267     float postConvolutionGreenBias() const { return mPostConvolutionGreenBias; }
00268     float postConvolutionBlueBias() const { return mPostConvolutionBlueBias; }
00269     float postConvolutionAlphaBias() const { return mPostConvolutionAlphaBias; }
00270 
00271     void setMapColor(bool map_color) {  mMapColor = map_color; }
00272     void setMapStencil(bool map_stencil) {  mMapStencil = map_stencil; }
00273     void setIndexShift(int index_shift) {  mIndexShift = index_shift; }
00274     void setIndexOffset(int index_offset) {  mIndexOffset = index_offset; }
00275     void setRedScale(float red_scale) {  mRedScale = red_scale; }
00276     void setGreenScale(float green_scale) {  mGreenScale = green_scale; }
00277     void setBlueScale(float blue_scale) {  mBlueScale = blue_scale; }
00278     void setAlphaScale(float alpha_scale) {  mAlphaScale = alpha_scale; }
00279     void setDepthScale(float depth_scale) {  mDepthScale = depth_scale; }
00280     void setRedBias(float red_bias) {  mRedBias = red_bias; }
00281     void setGreenBias(float green_bias) {  mGreenBias = green_bias; }
00282     void setBlueBias(float blue_bias) {  mBlueBias = blue_bias; }
00283     void setAlphaBias(float alpha_bias) {  mAlphaBias = alpha_bias; }
00284     void setDepthBias(float depth_bias) {  mDepthBias = depth_bias; }
00285     void setPostColorMatrixRedScale(float scale) {  mPostColorMatrixRedScale = scale; }
00286     void setPostColorMatrixGreenScale(float scale) {  mPostColorMatrixGreenScale = scale; }
00287     void setPostColorMatrixBlueScale(float scale) {  mPostColorMatrixBlueScale = scale; }
00288     void setPostColorMatrixAlphaScale(float scale) {  mPostColorMatrixAlphaScale = scale; }
00289     void setPostColorMatrixRedBias(float bias) {  mPostColorMatrixRedBias = bias; }
00290     void setPostColorMatrixGreenBias(float bias) {  mPostColorMatrixGreenBias = bias; }
00291     void setPostColorMatrixBlueBias(float bias) {  mPostColorMatrixBlueBias = bias; }
00292     void setPostColorMatrixAlphaBias(float bias) {  mPostColorMatrixAlphaBias = bias; }
00293     void setPostConvolutionRedScale(float scale) {  mPostConvolutionRedScale = scale; }
00294     void setPostConvolutionGreenScale(float scale) {  mPostConvolutionGreenScale = scale; }
00295     void setPostConvolutionBlueScale(float scale) {  mPostConvolutionBlueScale = scale; }
00296     void setPostConvolutionAlphaScale(float scale) {  mPostConvolutionAlphaScale = scale; }
00297     void setPostConvolutionRedBias(float bias) {  mPostConvolutionRedBias = bias; }
00298     void setPostConvolutionGreenBias(float bias) {  mPostConvolutionGreenBias = bias; }
00299     void setPostConvolutionBlueBias(float bias) {  mPostConvolutionBlueBias = bias; }
00300     void setPostConvolutionAlphaBias(float bias) {  mPostConvolutionAlphaBias = bias; }
00301 
00302     virtual ref<RenderState> clone() const
00303     {
00304       ref<PixelTransfer> rs = new PixelTransfer;
00305       *rs = *this;
00306       return rs;
00307     }
00308 
00309   protected:
00310     bool mMapColor;
00311     bool mMapStencil;
00312     int mIndexShift;
00313     int mIndexOffset;
00314     float mRedScale;
00315     float mGreenScale;
00316     float mBlueScale;
00317     float mAlphaScale;
00318     float mDepthScale;
00319     float mRedBias;
00320     float mGreenBias;
00321     float mBlueBias;
00322     float mAlphaBias;
00323     float mDepthBias;
00324     float mPostColorMatrixRedScale;
00325     float mPostColorMatrixGreenScale;
00326     float mPostColorMatrixBlueScale;
00327     float mPostColorMatrixAlphaScale;
00328     float mPostColorMatrixRedBias;
00329     float mPostColorMatrixGreenBias;
00330     float mPostColorMatrixBlueBias;
00331     float mPostColorMatrixAlphaBias;
00332     float mPostConvolutionRedScale;
00333     float mPostConvolutionGreenScale;
00334     float mPostConvolutionBlueScale;
00335     float mPostConvolutionAlphaScale;
00336     float mPostConvolutionRedBias;
00337     float mPostConvolutionGreenBias;
00338     float mPostConvolutionBlueBias;
00339     float mPostConvolutionAlphaBias;
00340   };
00341   //------------------------------------------------------------------------------
00342   // Hint
00343   //------------------------------------------------------------------------------
00346   class VLGRAPHICS_EXPORT Hint: public RenderStateNonIndexed
00347   {
00348     VL_INSTRUMENT_CLASS(vl::Hint, RenderStateNonIndexed)
00349 
00350   public:
00351     Hint(): mPerspectiveCorrectionHint(HM_DONT_CARE), mPointSmoothHint(HM_DONT_CARE), mLineSmoothHint(HM_DONT_CARE),
00352             mPolygonSmoothHint(HM_DONT_CARE), mFogHint(HM_DONT_CARE), mGenerateMipmapHint(HM_DONT_CARE)
00353     {
00354       VL_DEBUG_SET_OBJECT_NAME()
00355     }
00356 
00357     virtual ERenderState type() const { return RS_Hint; }
00358 
00359     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00360 
00361     void setPerspectiveCorrectionHint(EHintMode mode) { mPerspectiveCorrectionHint = mode; }
00362     void setPolygonSmoohtHint(EHintMode mode) { mPolygonSmoothHint = mode; }
00363     void setLineSmoothHint(EHintMode mode) { mLineSmoothHint = mode; }
00364     void setPointSmoothHint(EHintMode mode) { mPointSmoothHint = mode; }
00365     void setFogHint(EHintMode mode) { mFogHint = mode; }
00366     void setGenerateMipmapHint(EHintMode mode) { mGenerateMipmapHint = mode; }
00367 
00368     EHintMode perspectiveCorrectionHint() const { return mPerspectiveCorrectionHint; }
00369     EHintMode polygonSmoohtHint() const { return mPolygonSmoothHint; }
00370     EHintMode lineSmoothHint() const { return mLineSmoothHint; }
00371     EHintMode pointSmoothHint() const { return mPointSmoothHint; }
00372     EHintMode fogHint() const { return mFogHint; }
00373     EHintMode generateMipmapHint() const { return mGenerateMipmapHint; }
00374 
00375     virtual ref<RenderState> clone() const
00376     {
00377       ref<Hint> rs = new Hint;
00378       *rs = *this;
00379       return rs;
00380     }
00381 
00382   protected:
00383     EHintMode mPerspectiveCorrectionHint;
00384     EHintMode mPointSmoothHint;
00385     EHintMode mLineSmoothHint;
00386     EHintMode mPolygonSmoothHint;
00387     EHintMode mFogHint;
00388     EHintMode mGenerateMipmapHint;
00389   };
00390   //------------------------------------------------------------------------------
00391   // CullFace
00392   //------------------------------------------------------------------------------
00395   class VLGRAPHICS_EXPORT CullFace: public RenderStateNonIndexed
00396   {
00397     VL_INSTRUMENT_CLASS(vl::CullFace, RenderStateNonIndexed)
00398 
00399   public:
00400     CullFace(EPolygonFace cullface=PF_BACK): mFaceMode(cullface)
00401     {
00402       VL_DEBUG_SET_OBJECT_NAME()
00403     }
00404 
00405     virtual ERenderState type() const { return RS_CullFace; }
00406 
00407     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00408 
00409     void set(EPolygonFace facemode) { mFaceMode = facemode; }
00410 
00411     EPolygonFace faceMode() const { return mFaceMode; }
00412 
00413     virtual ref<RenderState> clone() const
00414     {
00415       ref<CullFace> rs = new CullFace;
00416       *rs = *this;
00417       return rs;
00418     }
00419 
00420   protected:
00421     EPolygonFace mFaceMode;
00422   };
00423   //------------------------------------------------------------------------------
00424   // FrontFace
00425   //------------------------------------------------------------------------------
00428   class VLGRAPHICS_EXPORT FrontFace: public RenderStateNonIndexed
00429   {
00430     VL_INSTRUMENT_CLASS(vl::FrontFace, RenderStateNonIndexed)
00431 
00432   public:
00433     FrontFace(EFrontFace frontface=FF_CCW): mFrontFace(frontface)
00434     {
00435       VL_DEBUG_SET_OBJECT_NAME()
00436     }
00437 
00438     virtual ERenderState type() const { return RS_FrontFace; }
00439 
00440     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00441 
00442     void set(EFrontFace frontface) { mFrontFace = frontface; }
00443 
00444     EFrontFace frontFace() const { return mFrontFace; }
00445 
00446     virtual ref<RenderState> clone() const
00447     {
00448       ref<FrontFace> rs = new FrontFace;
00449       *rs = *this;
00450       return rs;
00451     }
00452 
00453   protected:
00454     EFrontFace mFrontFace;
00455   };
00456   //------------------------------------------------------------------------------
00457   // DepthFunc
00458   //------------------------------------------------------------------------------
00461   class VLGRAPHICS_EXPORT DepthFunc: public RenderStateNonIndexed
00462   {
00463     VL_INSTRUMENT_CLASS(vl::DepthFunc, RenderStateNonIndexed)
00464 
00465   public:
00466     DepthFunc(EFunction depthfunc=FU_LESS): mDepthFunc(depthfunc)
00467     {
00468       VL_DEBUG_SET_OBJECT_NAME()
00469     }
00470     
00471     virtual ERenderState type() const { return RS_DepthFunc; }
00472     
00473     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00474     
00475     void set(EFunction depthfunc) { mDepthFunc = depthfunc; }
00476     
00477     EFunction depthFunc() const { return mDepthFunc; }
00478   
00479     virtual ref<RenderState> clone() const
00480     {
00481       ref<DepthFunc> rs = new DepthFunc;
00482       *rs = *this;
00483       return rs;
00484     }
00485 
00486   protected:
00487     EFunction mDepthFunc;
00488   };
00489   //------------------------------------------------------------------------------
00490   // DepthMask
00491   //------------------------------------------------------------------------------
00494   class VLGRAPHICS_EXPORT DepthMask: public RenderStateNonIndexed
00495   {
00496     VL_INSTRUMENT_CLASS(vl::DepthMask, RenderStateNonIndexed)
00497 
00498   public:
00499     DepthMask(bool depthmask=true): mDepthMask(depthmask)
00500     {
00501       VL_DEBUG_SET_OBJECT_NAME()
00502     }
00503 
00504     virtual ERenderState type() const { return RS_DepthMask; }
00505 
00506     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00507 
00508     void set(bool depthmask) { mDepthMask = depthmask; }
00509 
00510     bool depthMask() const { return mDepthMask; }
00511 
00512     virtual ref<RenderState> clone() const
00513     {
00514       ref<DepthMask> rs = new DepthMask;
00515       *rs = *this;
00516       return rs;
00517     }
00518 
00519   protected:
00520     bool mDepthMask;
00521   };
00522   //------------------------------------------------------------------------------
00523   // PolygonMode
00524   //------------------------------------------------------------------------------
00527   class VLGRAPHICS_EXPORT PolygonMode: public RenderStateNonIndexed
00528   {
00529     VL_INSTRUMENT_CLASS(vl::PolygonMode, RenderStateNonIndexed)
00530 
00531   public:
00532     PolygonMode(EPolygonMode frontface=PM_FILL, EPolygonMode backface=PM_FILL): mFrontFace(frontface), mBackFace(backface)
00533     {
00534       VL_DEBUG_SET_OBJECT_NAME()
00535     }
00536     
00537     virtual ERenderState type() const { return RS_PolygonMode; }
00538     
00539     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00540     
00541     void set(EPolygonMode frontface, EPolygonMode backface) { mFrontFace = frontface; mBackFace = backface; }
00542     
00543     void setFrontFace(EPolygonMode frontface) { mFrontFace = frontface; }
00544     
00545     void setBackFace(EPolygonMode backface) { mBackFace = backface; }
00546     
00547     EPolygonMode frontFace() const { return mFrontFace; }
00548     
00549     EPolygonMode backFace() const { return mBackFace; }
00550 
00551     virtual ref<RenderState> clone() const
00552     {
00553       ref<PolygonMode> rs = new PolygonMode;
00554       *rs = *this;
00555       return rs;
00556     }
00557 
00558   protected:
00559     EPolygonMode mFrontFace;
00560     EPolygonMode mBackFace;
00561   };
00562   //------------------------------------------------------------------------------
00563   // ShadeModel
00564   //------------------------------------------------------------------------------
00567   class VLGRAPHICS_EXPORT ShadeModel: public RenderStateNonIndexed
00568   {
00569     VL_INSTRUMENT_CLASS(vl::ShadeModel, RenderStateNonIndexed)
00570 
00571   public:
00572     ShadeModel(EShadeModel shademodel=SM_SMOOTH): mShadeModel(shademodel)
00573     {
00574       VL_DEBUG_SET_OBJECT_NAME()
00575     }
00576 
00577     virtual ERenderState type() const { return RS_ShadeModel; }
00578 
00579     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00580 
00581     void set(EShadeModel shademodel) { mShadeModel = shademodel; }
00582 
00583     EShadeModel shadeModel() const { return mShadeModel; }
00584 
00585     virtual ref<RenderState> clone() const
00586     {
00587       ref<ShadeModel> rs = new ShadeModel;
00588       *rs = *this;
00589       return rs;
00590     }
00591 
00592   protected:
00593     EShadeModel mShadeModel;
00594   };
00595   //------------------------------------------------------------------------------
00596   // BlendFunc
00597   //------------------------------------------------------------------------------
00600   class VLGRAPHICS_EXPORT BlendFunc: public RenderStateNonIndexed
00601   {
00602     VL_INSTRUMENT_CLASS(vl::BlendFunc, RenderStateNonIndexed)
00603 
00604   public:
00605     BlendFunc(EBlendFactor src_rgb=BF_SRC_ALPHA, EBlendFactor dst_rgb=BF_ONE_MINUS_SRC_ALPHA, EBlendFactor src_alpha=BF_SRC_ALPHA, EBlendFactor dst_alpha=BF_ONE_MINUS_SRC_ALPHA):
00606       mSrcRGB(src_rgb), mDstRGB(dst_rgb), mSrcAlpha(src_alpha), mDstAlpha(dst_alpha)
00607     {
00608       VL_DEBUG_SET_OBJECT_NAME()
00609     }
00610     
00611     virtual ERenderState type() const { return RS_BlendFunc; }
00612     
00613     // if glBlendFuncSeparate is not supported uses RGB factor for both RGB and Alpha
00614     
00615     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00616     
00617     void set(EBlendFactor src_rgb, EBlendFactor dst_rgb, EBlendFactor src_alpha, EBlendFactor dst_alpha) { mSrcRGB = src_rgb; mSrcAlpha = src_alpha; mDstRGB = dst_rgb; mDstAlpha = dst_alpha; }
00618     
00619     void set(EBlendFactor src_rgba, EBlendFactor dst_rgba) { mSrcRGB = src_rgba; mSrcAlpha = src_rgba; mDstRGB = dst_rgba; mDstAlpha = dst_rgba; }
00620     
00621     void setSrcRGB(EBlendFactor factor) { mSrcRGB = factor; }
00622     
00623     void setDstRGB(EBlendFactor factor) { mDstRGB = factor; }
00624     
00625     void setSrcAlpha(EBlendFactor factor) { mSrcAlpha = factor; }
00626     
00627     void setDstAlpha(EBlendFactor factor) { mDstAlpha = factor; }
00628     
00629     EBlendFactor srcRGB() const { return mSrcRGB; }
00630     
00631     EBlendFactor dstRGB() const { return mDstRGB; }
00632     
00633     EBlendFactor srcAlpha() const { return mSrcAlpha; }
00634     
00635     EBlendFactor dstAlpha() const { return mDstAlpha; }
00636 
00637     virtual ref<RenderState> clone() const
00638     {
00639       ref<BlendFunc> rs = new BlendFunc;
00640       *rs = *this;
00641       return rs;
00642     }
00643 
00644   protected:
00645     EBlendFactor mSrcRGB;
00646     EBlendFactor mDstRGB;
00647     EBlendFactor mSrcAlpha;
00648     EBlendFactor mDstAlpha;
00649   };
00650   //------------------------------------------------------------------------------
00651   // BlendEquation
00652   //------------------------------------------------------------------------------
00657   class VLGRAPHICS_EXPORT BlendEquation: public RenderStateNonIndexed
00658   {
00659     VL_INSTRUMENT_CLASS(vl::BlendEquation, RenderStateNonIndexed)
00660 
00661   public:
00662     BlendEquation(EBlendEquation mode_rgb=BE_FUNC_ADD, EBlendEquation mode_alpha=BE_FUNC_ADD): mModeRGB(mode_rgb), mModeAlpha(mode_alpha)
00663     {
00664       VL_DEBUG_SET_OBJECT_NAME()
00665     }
00666     
00667     virtual ERenderState type() const { return RS_BlendEquation; }
00668     
00669     // if glBlendEquationSeparate is not supported uses RGB mode for both RGB and Alpha
00670     
00671     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00672     
00673     void set(EBlendEquation mode_rgba) { mModeRGB = mode_rgba; mModeAlpha = mode_rgba; }
00674     
00675     void set(EBlendEquation mode_rgb, EBlendEquation mode_alpha) { mModeRGB = mode_rgb; mModeAlpha = mode_alpha; }
00676     
00677     EBlendEquation modeRGB() const { return mModeRGB; }
00678     
00679     EBlendEquation modeAlpha() const { return mModeAlpha; }
00680 
00681     virtual ref<RenderState> clone() const
00682     {
00683       ref<BlendEquation> rs = new BlendEquation;
00684       *rs = *this;
00685       return rs;
00686     }
00687 
00688   protected:
00689     EBlendEquation mModeRGB;
00690     EBlendEquation mModeAlpha;
00691   };
00692   //------------------------------------------------------------------------------
00693   // SampleCoverage
00694   //------------------------------------------------------------------------------
00697   class VLGRAPHICS_EXPORT SampleCoverage: public RenderStateNonIndexed
00698   {
00699     VL_INSTRUMENT_CLASS(vl::SampleCoverage, RenderStateNonIndexed)
00700 
00701   public:
00702     SampleCoverage(GLclampf value=1.0f, bool invert=false): mValue(value), mInvert(invert)
00703     {
00704       VL_DEBUG_SET_OBJECT_NAME()
00705     }
00706     
00707     virtual ERenderState type() const { return RS_SampleCoverage; }
00708     
00709     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00710     
00711     void set(GLclampf value, bool invert) { mValue = value; mInvert = invert; }
00712     
00713     void setValue(GLclampf value) { mValue = value; }
00714     
00715     void setInvert(bool invert) { mInvert = invert; }
00716     
00717     GLclampf value() const { return mValue; }
00718     
00719     bool invert() const { return mInvert; }
00720 
00721     virtual ref<RenderState> clone() const
00722     {
00723       ref<SampleCoverage> rs = new SampleCoverage;
00724       *rs = *this;
00725       return rs;
00726     }
00727 
00728   protected:
00729     GLclampf mValue;
00730     bool mInvert;
00731   };
00732   //------------------------------------------------------------------------------
00733   // AlphaFunc
00734   //------------------------------------------------------------------------------
00737   class VLGRAPHICS_EXPORT AlphaFunc: public RenderStateNonIndexed
00738   {
00739     VL_INSTRUMENT_CLASS(vl::AlphaFunc, RenderStateNonIndexed)
00740 
00741   public:
00742     AlphaFunc(EFunction alphafunc=FU_ALWAYS, float refvalue=0): mRefValue(refvalue), mAlphaFunc(alphafunc)
00743     {
00744       VL_DEBUG_SET_OBJECT_NAME()
00745     }
00746     
00747     virtual ERenderState type() const { return RS_AlphaFunc; }
00748     
00749     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00750     
00751     void set(EFunction alphafunc, float ref_value) { mAlphaFunc = alphafunc; mRefValue = ref_value; }
00752     
00753     EFunction alphaFunc() const { return mAlphaFunc; }
00754     
00755     float refValue() const { return mRefValue; }
00756 
00757     virtual ref<RenderState> clone() const
00758     {
00759       ref<AlphaFunc> rs = new AlphaFunc;
00760       *rs = *this;
00761       return rs;
00762     }
00763 
00764   protected:
00765     float mRefValue;
00766     EFunction mAlphaFunc;
00767   };
00768   //------------------------------------------------------------------------------
00769   // Material
00770   //------------------------------------------------------------------------------
00774   class VLGRAPHICS_EXPORT Material: public RenderStateNonIndexed
00775   {
00776     VL_INSTRUMENT_CLASS(vl::Material, RenderStateNonIndexed)
00777 
00778   public:
00779     Material();
00780     virtual ERenderState type() const { return RS_Material; }
00781     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00782 
00783     void multiplyTransparency(float alpha);
00784     float getMinimumAlpha() const;
00785 
00786     void setTransparency(float alpha);
00787     void setFrontTransparency(float alpha);
00788     void setBackTransparency(float alpha);
00789     void setFrontFlatColor(const fvec4& color);
00790     void setBackFlatColor(const fvec4& color);
00791     void setFlatColor(const fvec4& color);
00792 
00793     void setAmbient(fvec4 color)       { mFrontAmbient   = mBackAmbient   = color; }
00794     void setDiffuse(fvec4 color)       { mFrontDiffuse   = mBackDiffuse   = color; }
00795     void setSpecular(fvec4 color)      { mFrontSpecular  = mBackSpecular  = color; }
00796     void setEmission(fvec4 color)      { mFrontEmission  = mBackEmission  = color; }
00797     void setShininess(float shininess) { mFrontShininess = mBackShininess = shininess; }
00798 
00799     void setFrontAmbient(fvec4 color)  { mFrontAmbient = color; }
00800     void setFrontDiffuse(fvec4 color)  { mFrontDiffuse = color; }
00801     void setFrontSpecular(fvec4 color) { mFrontSpecular = color; }
00802     void setFrontEmission(fvec4 color) { mFrontEmission = color; }
00803     void setFrontShininess(float shininess) { mFrontShininess=shininess; }
00804 
00805     fvec4 frontAmbient() const   { return mFrontAmbient; }
00806     fvec4 frontDiffuse() const   { return mFrontDiffuse; }
00807     fvec4 frontSpecular() const  { return mFrontSpecular; }
00808     fvec4 frontEmission() const  { return mFrontEmission; }
00809     float frontShininess() const { return mFrontShininess; }
00810 
00811     void setBackAmbient(fvec4 color)  { mBackAmbient = color; }
00812     void setBackDiffuse(fvec4 color)  { mBackDiffuse = color; }
00813     void setBackSpecular(fvec4 color) { mBackSpecular = color; }
00814     void setBackEmission(fvec4 color) { mBackEmission = color; }
00815     void setBackShininess(float shininess) { mBackShininess=shininess; }
00816 
00817     fvec4 backAmbient() const   { return mBackAmbient; }
00818     fvec4 backDiffuse() const   { return mBackDiffuse; }
00819     fvec4 backSpecular() const  { return mBackSpecular; }
00820     fvec4 backEmission() const  { return mBackEmission; }
00821     float backShininess() const { return mBackShininess; }
00822 
00823     // color material
00824 
00825     void setColorMaterial(EPolygonFace face, EColorMaterial color) { mColorMaterialFace = face; mColorMaterial = color; }
00826     EPolygonFace colorMaterialFace() const { return mColorMaterialFace; }
00827     EColorMaterial colorMaterial() const { return mColorMaterial; }
00828     void setColorMaterialEnabled(bool enabled) { mColorMaterialEnabled = enabled; }
00829     bool colorMaterialEnabled() const { return mColorMaterialEnabled; }
00830 
00831     virtual ref<RenderState> clone() const
00832     {
00833       ref<Material> rs = new Material;
00834       *rs = *this;
00835       return rs;
00836     }
00837 
00838   protected:
00839     fvec4 mFrontAmbient;
00840     fvec4 mFrontDiffuse;
00841     fvec4 mFrontSpecular;
00842     fvec4 mFrontEmission;
00843     fvec4 mBackAmbient;
00844     fvec4 mBackDiffuse;
00845     fvec4 mBackSpecular;
00846     fvec4 mBackEmission;
00847     float mBackShininess;
00848     float mFrontShininess;
00849     // color material
00850     EPolygonFace mColorMaterialFace;
00851     EColorMaterial mColorMaterial;
00852     bool mColorMaterialEnabled;
00853   };
00854   //------------------------------------------------------------------------------
00855   // LightModel
00856   //------------------------------------------------------------------------------
00859   class VLGRAPHICS_EXPORT LightModel: public RenderStateNonIndexed
00860   {
00861     VL_INSTRUMENT_CLASS(vl::LightModel, RenderStateNonIndexed)
00862 
00863   public:
00864     LightModel(): mAmbientColor(0.2f,0.2f,0.2f,1.0f), mColorControl(CC_SINGLE_COLOR), mLocalViewer(false), mTwoSide(false)
00865     {
00866       VL_DEBUG_SET_OBJECT_NAME()
00867     }
00868     
00869     virtual ERenderState type() const { return RS_LightModel; }
00870     
00871     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00872     
00873     void setLocalViewer(bool localviewer) { mLocalViewer = localviewer; }
00874     
00875     void setTwoSide(bool twoside) { mTwoSide = twoside; }
00876     
00877     void setColorControl(EColorControl colorcontrol) { mColorControl = colorcontrol; }
00878     
00879     void setAmbientColor(fvec4 ambientcolor) { mAmbientColor = ambientcolor; }
00880     
00881     bool localViewer() const { return mLocalViewer; }
00882     
00883     bool twoSide() const { return mTwoSide; }
00884     
00885     EColorControl colorControl() const { return mColorControl; }
00886     
00887     fvec4 ambientColor() const { return mAmbientColor; }
00888 
00889     virtual ref<RenderState> clone() const
00890     {
00891       ref<LightModel> rs = new LightModel;
00892       *rs = *this;
00893       return rs;
00894     }
00895 
00896   protected:
00897     fvec4 mAmbientColor;
00898     EColorControl mColorControl;
00899     bool mLocalViewer;
00900     bool mTwoSide;
00901   };
00902   //------------------------------------------------------------------------------
00903   // Fog
00904   //------------------------------------------------------------------------------
00907   class VLGRAPHICS_EXPORT Fog: public RenderStateNonIndexed
00908   {
00909     VL_INSTRUMENT_CLASS(vl::Fog, RenderStateNonIndexed)
00910 
00911   public:
00912     Fog(EFogMode mode=FM_LINEAR, fvec4 color=fvec4(0,0,0,0), float density=1, float start=0, float end=1):
00913       mColor(color), mMode(mode), mDensity(density), mStart(start), mEnd(end)
00914     {
00915       VL_DEBUG_SET_OBJECT_NAME()
00916     }
00917     
00918     virtual ERenderState type() const { return RS_Fog; }
00919     
00920     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00921     
00922     void set(EFogMode mode, fvec4 color, float density, float start, float end) { mColor = color; mMode = mode; mDensity = density; mStart = start; mEnd = end; }
00923     
00924     void setColor(fvec4 color) { mColor = color; }
00925     
00926     void setMode(EFogMode mode) { mMode = mode; }
00927     
00928     void setDensity(float density) { mDensity = density; }
00929     
00930     void setStart(float start) { mStart = start; }
00931     
00932     void setEnd(float end) { mEnd = end; }
00933     
00934     fvec4 color() const { return mColor; }
00935     
00936     EFogMode mode() const { return mMode; }
00937     
00938     float density() const { return mDensity; }
00939     
00940     float start() const { return mStart; }
00941     
00942     float end() const { return mEnd; }
00943 
00944     virtual ref<RenderState> clone() const
00945     {
00946       ref<Fog> rs = new Fog;
00947       *rs = *this;
00948       return rs;
00949     }
00950 
00951   protected:
00952     fvec4 mColor;
00953     EFogMode mMode;
00954     float mDensity;
00955     float mStart;
00956     float mEnd;
00957   };
00958   //------------------------------------------------------------------------------
00959   // PolygonOffset
00960   //------------------------------------------------------------------------------
00963   class VLGRAPHICS_EXPORT PolygonOffset: public RenderStateNonIndexed
00964   {
00965     VL_INSTRUMENT_CLASS(vl::PolygonOffset, RenderStateNonIndexed)
00966 
00967   public:
00968     PolygonOffset(): mFactor(0.0f), mUnits(0.0f)
00969     {
00970       VL_DEBUG_SET_OBJECT_NAME()
00971     }
00972     
00973     virtual ERenderState type() const { return RS_PolygonOffset; }
00974     
00975     PolygonOffset(float factor, float units): mFactor(factor), mUnits(units) {}
00976     
00977     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
00978     
00979     void set(float factor, float units) { mFactor = factor; mUnits = units; }
00980     
00981     void setFactor(float factor) { mFactor = factor; }
00982     
00983     void setUnits(float units) { mUnits = units; }
00984     
00985     float factor() const { return mFactor; }
00986     
00987     float units() const { return mUnits; }
00988 
00989     virtual ref<RenderState> clone() const
00990     {
00991       ref<PolygonOffset> rs = new PolygonOffset;
00992       *rs = *this;
00993       return rs;
00994     }
00995 
00996   protected:
00997     float mFactor;
00998     float mUnits;
00999   };
01000   //------------------------------------------------------------------------------
01001   // LogicOp
01002   //------------------------------------------------------------------------------
01005   class VLGRAPHICS_EXPORT LogicOp: public RenderStateNonIndexed
01006   {
01007     VL_INSTRUMENT_CLASS(vl::LogicOp, RenderStateNonIndexed)
01008 
01009   public:
01010     LogicOp(ELogicOp logicop=LO_COPY): mLogicOp(logicop)
01011     {
01012       VL_DEBUG_SET_OBJECT_NAME()
01013     }
01014     
01015     virtual ERenderState type() const { return RS_LogicOp; }
01016     
01017     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01018     
01019     void set(ELogicOp logicop) { mLogicOp = logicop; }
01020     
01021     ELogicOp logicOp() const { return mLogicOp; }
01022 
01023     virtual ref<RenderState> clone() const
01024     {
01025       ref<LogicOp> rs = new LogicOp;
01026       *rs = *this;
01027       return rs;
01028     }
01029 
01030   protected:
01031     ELogicOp mLogicOp;
01032   };
01033   //------------------------------------------------------------------------------
01034   // DepthRange
01035   //------------------------------------------------------------------------------
01038   class VLGRAPHICS_EXPORT DepthRange: public RenderStateNonIndexed
01039   {
01040     VL_INSTRUMENT_CLASS(vl::DepthRange, RenderStateNonIndexed)
01041 
01042   public:
01043     DepthRange(): mZNear(0), mZFar(1.0f)
01044     {
01045       VL_DEBUG_SET_OBJECT_NAME()
01046     }
01047     
01048     DepthRange(float znear, float zfar): mZNear(znear), mZFar(zfar)
01049     {
01050       VL_DEBUG_SET_OBJECT_NAME()
01051     }
01052     
01053     virtual ERenderState type() const { return RS_DepthRange; }
01054     
01055     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01056     
01057     void set(float znear, float zfar) { mZNear = znear; mZFar = zfar; }
01058     
01059     void setZNear(float znear) { mZNear = znear; }
01060     
01061     void setZFar(float zfar) { mZFar = zfar; }
01062     
01063     float zNear() const { return mZNear; }
01064     
01065     float zFar() const { return mZFar; }
01066 
01067     virtual ref<RenderState> clone() const
01068     {
01069       ref<DepthRange> rs = new DepthRange;
01070       *rs = *this;
01071       return rs;
01072     }
01073 
01074   protected:
01075     float mZNear;
01076     float mZFar;
01077   };
01078   //------------------------------------------------------------------------------
01079   // LineWidth
01080   //------------------------------------------------------------------------------
01083   class VLGRAPHICS_EXPORT LineWidth: public RenderStateNonIndexed
01084   {
01085     VL_INSTRUMENT_CLASS(vl::LineWidth, RenderStateNonIndexed)
01086 
01087   public:
01088     LineWidth(float linewidth=1.0f): mLineWidth(linewidth)
01089     {
01090       VL_DEBUG_SET_OBJECT_NAME()
01091     }
01092     
01093     virtual ERenderState type() const { return RS_LineWidth; }
01094     
01095     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01096     
01097     void set(float linewidth) { mLineWidth = linewidth; }
01098     
01099     float lineWidth() const { return mLineWidth; }
01100 
01101     virtual ref<RenderState> clone() const
01102     {
01103       ref<LineWidth> rs = new LineWidth;
01104       *rs = *this;
01105       return rs;
01106     }
01107 
01108   protected:
01109     float mLineWidth;
01110   };
01111   //------------------------------------------------------------------------------
01112   // PointSize
01113   //------------------------------------------------------------------------------
01116   class VLGRAPHICS_EXPORT PointSize: public RenderStateNonIndexed
01117   {
01118     VL_INSTRUMENT_CLASS(vl::PointSize, RenderStateNonIndexed)
01119 
01120   public:
01121     PointSize(float pointsize=1.0f): mPointSize(pointsize)
01122     {
01123       VL_DEBUG_SET_OBJECT_NAME()
01124     }
01125     
01126     virtual ERenderState type() const { return RS_PointSize; }
01127     
01128     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01129     
01130     void set(float pointsize) { mPointSize = pointsize; }
01131     
01132     float pointSize() const { return mPointSize; }
01133 
01134     virtual ref<RenderState> clone() const
01135     {
01136       ref<PointSize> rs = new PointSize;
01137       *rs = *this;
01138       return rs;
01139     }
01140 
01141   protected:
01142     float mPointSize;
01143   };
01144   //------------------------------------------------------------------------------
01145   // PolygonStipple
01146   //------------------------------------------------------------------------------
01149   class VLGRAPHICS_EXPORT PolygonStipple: public RenderStateNonIndexed
01150   {
01151     VL_INSTRUMENT_CLASS(vl::PolygonStipple, RenderStateNonIndexed)
01152 
01153   public:
01154     PolygonStipple();
01155     
01156     PolygonStipple(const unsigned char* mask);
01157     
01158     virtual ERenderState type() const { return RS_PolygonStipple; }
01159     
01160     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01161     
01162     void set(const unsigned char* mask);
01163     
01164     const unsigned char* mask() const { return mMask; }
01165 
01166     virtual ref<RenderState> clone() const
01167     {
01168       ref<PolygonStipple> rs = new PolygonStipple;
01169       *rs = *this;
01170       return rs;
01171     }
01172 
01173   protected:
01174     unsigned char mMask[32*32/8];
01175   };
01176   //------------------------------------------------------------------------------
01177   // LineStipple
01178   //------------------------------------------------------------------------------
01181   class VLGRAPHICS_EXPORT LineStipple: public RenderStateNonIndexed
01182   {
01183     VL_INSTRUMENT_CLASS(vl::LineStipple, RenderStateNonIndexed)
01184 
01185   public:
01186     LineStipple(int factor=1, GLushort pattern=~(GLushort)0): mFactor(factor), mPattern(pattern)
01187     {
01188       VL_DEBUG_SET_OBJECT_NAME()
01189     }
01190     
01191     virtual ERenderState type() const { return RS_LineStipple; }
01192     
01193     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01194     
01195     void set(int factor, GLushort pattern) { mFactor = factor; mPattern = pattern; }
01196     
01197     void setFactor(int factor) { mFactor = factor; }
01198     
01199     void setPattern(GLushort pattern) { mPattern = pattern; }
01200     
01201     int factor() const { return mFactor; }
01202     
01203     GLushort pattern() const { return mPattern; }
01204 
01205     virtual ref<RenderState> clone() const
01206     {
01207       ref<LineStipple> rs = new LineStipple;
01208       *rs = *this;
01209       return rs;
01210     }
01211 
01212   protected:
01213     int mFactor;
01214     GLushort mPattern;
01215   };
01216   //------------------------------------------------------------------------------
01217   // PointParameter
01218   //------------------------------------------------------------------------------
01221   class VLGRAPHICS_EXPORT PointParameter: public RenderStateNonIndexed
01222   {
01223     VL_INSTRUMENT_CLASS(vl::PointParameter, RenderStateNonIndexed)
01224 
01225   public:
01226     PointParameter(float sizemin=0, float sizemax=1024.0f, float fadethresholdsize=1.0f, fvec3 distanceattenuation=fvec3(1,0,0)):
01227       mDistanceAttenuation(distanceattenuation), mSizeMin(sizemin), mSizeMax(sizemax), mFadeThresholdSize(fadethresholdsize),
01228       mPointSpriteCoordOrigin(PPCO_UPPER_LEFT)
01229     {
01230       VL_DEBUG_SET_OBJECT_NAME()
01231     }
01232     virtual ERenderState type() const { return RS_PointParameter; }
01233     
01234     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01235     
01236     void set(float sizemin, float sizemax, float fadethresholdsize, fvec3 distanceattenuation) { mDistanceAttenuation = distanceattenuation; mSizeMin = sizemin; mSizeMax = sizemax; mFadeThresholdSize = fadethresholdsize; }
01237     
01238     void setDistanceAttenuation(fvec3 attenuation) { mDistanceAttenuation = attenuation; }
01239     
01240     void setSizeMin(float sizemin) { mSizeMin = sizemin; }
01241     
01242     void setSizeMax(float sizemax) { mSizeMax = sizemax; }
01243     
01244     void setFadeThresholdSize(float threshold) { mFadeThresholdSize = threshold; }
01245     
01246     fvec3 distanceAttenuation() const { return mDistanceAttenuation; }
01247     
01248     float sizeMin() const { return mSizeMin; }
01249     
01250     float sizeMax() const { return mSizeMax; }
01251     
01252     float fadeThresholdSize() const { return mFadeThresholdSize; }
01253     
01254     EPointSpriteCoordOrigin pointSpriteCoordOrigin() const { return mPointSpriteCoordOrigin; }
01255     
01256     void setPointSpriteCoordOrigin(EPointSpriteCoordOrigin orig) { mPointSpriteCoordOrigin = orig; }
01257 
01258     virtual ref<RenderState> clone() const
01259     {
01260       ref<PointParameter> rs = new PointParameter;
01261       *rs = *this;
01262       return rs;
01263     }
01264 
01265   protected:
01266     fvec3 mDistanceAttenuation;
01267     float mSizeMin;
01268     float mSizeMax;
01269     float mFadeThresholdSize;
01270     EPointSpriteCoordOrigin mPointSpriteCoordOrigin;
01271   };
01272   //------------------------------------------------------------------------------
01273   // StencilFunc
01274   //------------------------------------------------------------------------------
01279   class VLGRAPHICS_EXPORT StencilFunc: public RenderStateNonIndexed
01280   {
01281     VL_INSTRUMENT_CLASS(vl::StencilFunc, RenderStateNonIndexed)
01282 
01283   public:
01284     StencilFunc(EFunction function=FU_ALWAYS, int refvalue=0, unsigned int mask=~(unsigned int)0): 
01285         mFunction_Front(function), mFunction_Back(function), 
01286         mRefValue_Front(refvalue), mRefValue_Back(refvalue), 
01287         mMask_Front(mask),         mMask_Back(mask)
01288     {
01289       VL_DEBUG_SET_OBJECT_NAME()
01290     }
01291 
01292     virtual ERenderState type() const { return RS_StencilFunc; }
01293     
01294     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01295     
01296     void set(EPolygonFace face, EFunction function, int refvalue, unsigned int mask) 
01297     { 
01298       if (face == PF_FRONT || face == PF_FRONT_AND_BACK)
01299       {
01300         mFunction_Front = function; 
01301         mRefValue_Front = refvalue; 
01302         mMask_Front     = mask; 
01303       }
01304       if (face == PF_BACK || face == PF_FRONT_AND_BACK)
01305       {
01306         mFunction_Back = function; 
01307         mRefValue_Back = refvalue; 
01308         mMask_Back     = mask; 
01309       }
01310     }
01311     
01312     EFunction function_Front() const { return mFunction_Front; }
01313     
01314     int refValue_Front() const { return mRefValue_Front; }
01315     
01316     unsigned int mask_Front() const { return mMask_Front; }
01317     
01318     EFunction function_Back() const { return mFunction_Back; }
01319     
01320     int refValue_Back() const { return mRefValue_Back; }
01321     
01322     unsigned int mask_Back() const { return mMask_Back; }
01323 
01324     virtual ref<RenderState> clone() const
01325     {
01326       ref<StencilFunc> rs = new StencilFunc;
01327       *rs = *this;
01328       return rs;
01329     }
01330 
01331   protected:
01332     EFunction mFunction_Front;
01333     EFunction mFunction_Back;
01334     int     mRefValue_Front;
01335     int     mRefValue_Back;
01336     unsigned int    mMask_Front;
01337     unsigned int    mMask_Back;
01338   };
01339   //------------------------------------------------------------------------------
01340   // StencilOp
01341   //------------------------------------------------------------------------------
01346   class VLGRAPHICS_EXPORT StencilOp: public RenderStateNonIndexed
01347   {
01348     VL_INSTRUMENT_CLASS(vl::StencilOp, RenderStateNonIndexed)
01349 
01350   public:
01351     StencilOp(EStencilOp sfail=SO_KEEP, EStencilOp dpfail=SO_KEEP, EStencilOp dppass=SO_KEEP): 
01352         mSFail_Front(sfail),   mSFail_Back(sfail), 
01353         mDpFail_Front(dpfail), mDpFail_Back(dpfail), 
01354         mDpPass_Front(dppass), mDpPass_Back(dppass)
01355     {
01356       VL_DEBUG_SET_OBJECT_NAME()
01357     }
01358 
01359     virtual ERenderState type() const { return RS_StencilOp; }
01360     
01361     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01362     
01363     void set(EPolygonFace face, EStencilOp sfail, EStencilOp dpfail, EStencilOp dppass) 
01364     { 
01365       if (face == PF_FRONT || face == PF_FRONT_AND_BACK)
01366       {
01367         mSFail_Front  = sfail; 
01368         mDpFail_Front = dpfail; 
01369         mDpPass_Front = dppass; 
01370       }
01371       if (face == PF_BACK || face == PF_FRONT_AND_BACK)
01372       {
01373         mSFail_Back  = sfail; 
01374         mDpFail_Back = dpfail; 
01375         mDpPass_Back = dppass; 
01376       }
01377     }
01378     
01379     EStencilOp sFail_Front()  const { return mSFail_Front;  }
01380     
01381     EStencilOp dpFail_Front() const { return mDpFail_Front; }
01382     
01383     EStencilOp dpPass_Front() const { return mDpPass_Front; }
01384     
01385     EStencilOp sFail_Back()   const { return mSFail_Front;  }
01386     
01387     EStencilOp dpFail_Back()  const { return mDpFail_Front; }
01388     
01389     EStencilOp dpPass_Back()  const { return mDpPass_Front; }
01390 
01391     virtual ref<RenderState> clone() const
01392     {
01393       ref<StencilOp> rs = new StencilOp;
01394       *rs = *this;
01395       return rs;
01396     }
01397 
01398   protected:
01399     EStencilOp mSFail_Front;
01400     EStencilOp mSFail_Back;
01401     EStencilOp mDpFail_Front;
01402     EStencilOp mDpFail_Back;
01403     EStencilOp mDpPass_Front;
01404     EStencilOp mDpPass_Back;
01405   };
01406   //------------------------------------------------------------------------------
01407   // StencilMask
01408   //------------------------------------------------------------------------------
01413   class VLGRAPHICS_EXPORT StencilMask: public RenderStateNonIndexed
01414   {
01415     VL_INSTRUMENT_CLASS(vl::StencilMask, RenderStateNonIndexed)
01416 
01417   public:
01418     StencilMask(unsigned int mask=~(unsigned int)0): mMask_Front(mask), mMask_Back(mask)
01419     {
01420       VL_DEBUG_SET_OBJECT_NAME()
01421     }
01422 
01423     virtual ERenderState type() const { return RS_StencilMask; }
01424 
01425     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01426 
01427     void set(EPolygonFace face, unsigned int mask) 
01428     { 
01429       if (face == PF_FRONT || face == PF_FRONT_AND_BACK)
01430         mMask_Front = mask; 
01431       if (face == PF_BACK  || face == PF_FRONT_AND_BACK)
01432         mMask_Back = mask;       
01433     }
01434 
01435     unsigned int mask_Front() const { return mMask_Front; }
01436 
01437     unsigned int mask_Back() const { return mMask_Back; }
01438 
01439     virtual ref<RenderState> clone() const
01440     {
01441       ref<StencilMask> rs = new StencilMask;
01442       *rs = *this;
01443       return rs;
01444     }
01445 
01446   protected:
01447     unsigned int mMask_Front;
01448     unsigned int mMask_Back;
01449   };
01450   //------------------------------------------------------------------------------
01451   // BlendColor
01452   //------------------------------------------------------------------------------
01455   class VLGRAPHICS_EXPORT BlendColor: public RenderStateNonIndexed
01456   {
01457     VL_INSTRUMENT_CLASS(vl::BlendColor, RenderStateNonIndexed)
01458 
01459   public:
01460     BlendColor(fvec4 blendcolor=fvec4(0,0,0,0)): mBlendColor(blendcolor)
01461     {
01462       VL_DEBUG_SET_OBJECT_NAME()
01463     }
01464 
01465     virtual ERenderState type() const { return RS_BlendColor; }
01466 
01467     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01468 
01469     void set(fvec4 blendcolor) { mBlendColor = blendcolor; }
01470 
01471     fvec4 blendColor() const { return mBlendColor; }
01472 
01473     virtual ref<RenderState> clone() const
01474     {
01475       ref<BlendColor> rs = new BlendColor;
01476       *rs = *this;
01477       return rs;
01478     }
01479 
01480   protected:
01481     fvec4 mBlendColor;
01482   };
01483   //------------------------------------------------------------------------------
01484   // ColorMask
01485   //------------------------------------------------------------------------------
01488   class VLGRAPHICS_EXPORT ColorMask: public RenderStateNonIndexed
01489   {
01490     VL_INSTRUMENT_CLASS(vl::ColorMask, RenderStateNonIndexed)
01491 
01492   public:
01493     ColorMask(bool red=true, bool green=true, bool blue=true, bool alpha=true): mRed(red), mGreen(green), mBlue(blue), mAlpha(alpha)
01494     {
01495       VL_DEBUG_SET_OBJECT_NAME()
01496     }
01497 
01498     virtual ERenderState type() const { return RS_ColorMask; }
01499     
01500     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01501     
01502     void set(bool red, bool green, bool blue, bool alpha) { mRed = red; mGreen = green; mBlue = blue; mAlpha = alpha; }
01503     
01504     void setRed(bool red) { mRed = red; }
01505     
01506     void setGreen(bool green) { mGreen = green; }
01507     
01508     void setBlue(bool blue) { mBlue = blue; }
01509     
01510     void setAlpha(bool alpha) { mAlpha = alpha; }
01511     
01512     bool red() const { return mRed; }
01513     
01514     bool green() const { return mGreen; }
01515     
01516     bool blue() const { return mBlue; }
01517     
01518     bool alpha() const { return mAlpha; }
01519 
01520     virtual ref<RenderState> clone() const
01521     {
01522       ref<ColorMask> rs = new ColorMask;
01523       *rs = *this;
01524       return rs;
01525     }
01526 
01527   protected:
01528     bool mRed;
01529     bool mGreen;
01530     bool mBlue;
01531     bool mAlpha;
01532   };
01533   //------------------------------------------------------------------------------
01534   // TextureMatrix
01535   //------------------------------------------------------------------------------
01539   class VLGRAPHICS_EXPORT TextureMatrix: public RenderStateIndexed
01540   {
01541     VL_INSTRUMENT_CLASS(vl::TextureMatrix, RenderStateIndexed)
01542 
01543   public:
01544     TextureMatrix() { mUseCameraRotationInverse = false; }
01545     
01546     virtual ERenderState type() const { return RS_TextureMatrix; }
01547     
01548     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01549     
01550     const fmat4& matrix() const { return mMatrix; }
01551     
01552     const TextureMatrix& setMatrix(const fmat4& matrix)
01553     {
01554       mMatrix = matrix;
01555       return *this;
01556     }
01557     
01564     void setUseCameraRotationInverse(bool use) { mUseCameraRotationInverse = use; }
01565     
01566     bool useCameraRotationInverse() const { return mUseCameraRotationInverse; }
01567 
01568     virtual ref<RenderState> clone() const
01569     {
01570       ref<TextureMatrix> rs = new TextureMatrix;
01571       *rs = *this;
01572       return rs;
01573     }
01574 
01575   protected:
01576     fmat4 mMatrix;
01577     bool mUseCameraRotationInverse;
01578   };
01579   //------------------------------------------------------------------------------
01580   // TexEnv
01581   //------------------------------------------------------------------------------
01589   class VLGRAPHICS_EXPORT TexEnv: public RenderStateIndexed
01590   {
01591     VL_INSTRUMENT_CLASS(vl::TexEnv, RenderStateIndexed)
01592 
01593   public:
01594     TexEnv();
01595     virtual ERenderState type() const { return RS_TexEnv; }
01596     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01597 
01598     void setMode(ETexEnvMode mode) { mMode = mode; }
01599     ETexEnvMode mode() const { return mMode; }
01600     void setCombineRGB(ETexEnvMode combineRGB) { mCombineRGB = combineRGB; }
01601     ETexEnvMode combineRGB() const { return mCombineRGB; }
01602     void setCombineAlpha(ETexEnvMode combineAlpha) { mCombineAlpha = combineAlpha; }
01603     ETexEnvMode combineAlpha() const { return mCombineAlpha; }
01604     void setColor(fvec4 color) { mColor = color; }
01605     fvec4 color() const { return mColor; }
01606     void setRGBScale(float rgbscale) { mRGBScale = rgbscale; }
01607     float rgbScale() const { return mRGBScale; }
01608     void setAlphaScale(float alphascale) { mAlphaScale = alphascale; }
01609     float alphaScale() const { return mAlphaScale; }
01610 
01611     void setSource0RGB(ETexEnvSource source) { mSource0RGB = source; }
01612     void setSource1RGB(ETexEnvSource source) { mSource1RGB = source; }
01613     void setSource2RGB(ETexEnvSource source) { mSource2RGB = source; }
01614     ETexEnvSource source0RGB() const { return mSource0RGB; }
01615     ETexEnvSource source1RGB() const { return mSource1RGB; }
01616     ETexEnvSource source2RGB() const { return mSource2RGB; }
01617     void setSource0Alpha(ETexEnvSource source) { mSource0Alpha = source; }
01618     void setSource1Alpha(ETexEnvSource source) { mSource1Alpha = source; }
01619     void setSource2Alpha(ETexEnvSource source) { mSource2Alpha = source; }
01620     ETexEnvSource source0Alpha() const { return mSource0Alpha; }
01621     ETexEnvSource source1Alpha() const { return mSource1Alpha; }
01622     ETexEnvSource source2Alpha() const { return mSource2Alpha; }
01623 
01624     void setOperand0RGB(ETexEnvOperand operand) { mOperand0RGB = operand; }
01625     void setOperand1RGB(ETexEnvOperand operand) { mOperand1RGB = operand; }
01626     void setOperand2RGB(ETexEnvOperand operand) { mOperand2RGB = operand; }
01627     ETexEnvOperand operand0RGB() const { return mOperand0RGB; }
01628     ETexEnvOperand operand1RGB() const { return mOperand1RGB; }
01629     ETexEnvOperand operand2RGB() const { return mOperand2RGB; }
01630     void setOperand0Alpha(ETexEnvOperand operand) { mOperand0Alpha = operand; }
01631     void setOperand1Alpha(ETexEnvOperand operand) { mOperand1Alpha = operand; }
01632     void setOperand2Alpha(ETexEnvOperand operand) { mOperand2Alpha = operand; }
01633     ETexEnvOperand operand0Alpha() const { return mOperand0Alpha; }
01634     ETexEnvOperand operand1Alpha() const { return mOperand1Alpha; }
01635     ETexEnvOperand operand2Alpha() const { return mOperand2Alpha; }
01636 
01637     void setPointSpriteCoordReplace(bool replace) { mPointSpriteCoordReplace = replace; }
01638     bool pointSpriteCoordReplace() const { return mPointSpriteCoordReplace; }
01639 
01640     void setLodBias(float lodbias) { mLodBias = lodbias; }
01641     float lodBias() const { return mLodBias; }
01642 
01643     virtual ref<RenderState> clone() const
01644     {
01645       ref<TexEnv> rs = new TexEnv;
01646       *rs = *this;
01647       return rs;
01648     }
01649 
01650   public:
01651     fvec4 mColor;
01652     float mRGBScale;
01653     float mAlphaScale;
01654     ETexEnvMode mMode;
01655     ETexEnvMode mCombineRGB;
01656     ETexEnvMode mCombineAlpha;
01657     ETexEnvSource mSource0RGB;
01658     ETexEnvSource mSource1RGB;
01659     ETexEnvSource mSource2RGB;
01660     ETexEnvSource mSource0Alpha;
01661     ETexEnvSource mSource1Alpha;
01662     ETexEnvSource mSource2Alpha;
01663     ETexEnvOperand mOperand0RGB;
01664     ETexEnvOperand mOperand1RGB;
01665     ETexEnvOperand mOperand2RGB;
01666     ETexEnvOperand mOperand0Alpha;
01667     ETexEnvOperand mOperand1Alpha;
01668     ETexEnvOperand mOperand2Alpha;
01669     float mLodBias;
01670     bool mPointSpriteCoordReplace;
01671   };
01672   //------------------------------------------------------------------------------
01673   // TexGen
01674   //------------------------------------------------------------------------------
01682   class VLGRAPHICS_EXPORT TexGen: public RenderStateIndexed
01683   {
01684     VL_INSTRUMENT_CLASS(vl::TexGen, RenderStateIndexed)
01685 
01686   public:
01687     TexGen();
01688 
01689     virtual ERenderState type() const { return RS_TexGen; }
01690     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01691 
01692     void setEyePlaneS(fvec4 plane) { mEyePlaneS = plane; }
01693     void setObjectPlaneS(fvec4 plane) { mObjectPlaneS = plane; }
01694     void setGenModeS(ETexGenMode mode) { mGenModeS = mode; }
01695     fvec4 eyePlaneS() const { return mEyePlaneS; }
01696     fvec4 objectPlaneS() const { return mObjectPlaneS; }
01697     ETexGenMode genModeS() const { return mGenModeS; }
01698 
01699     void setEyePlaneT(fvec4 plane) { mEyePlaneT = plane; }
01700     void setObjectPlaneT(fvec4 plane) { mObjectPlaneT = plane; }
01701     void setGenModeT(ETexGenMode mode) { mGenModeT = mode; }
01702     fvec4 eyePlaneT() const { return mEyePlaneT; }
01703     fvec4 objectPlaneT() const { return mObjectPlaneT; }
01704     ETexGenMode genModeT() const { return mGenModeT; }
01705 
01706     void setEyePlaneR(fvec4 plane) { mEyePlaneR = plane; }
01707     void setObjectPlaneR(fvec4 plane) { mObjectPlaneR = plane; }
01708     void setGenModeR(ETexGenMode mode) { mGenModeR = mode; }
01709     fvec4 eyePlaneR() const { return mEyePlaneR; }
01710     fvec4 objectPlaneR() const { return mObjectPlaneR; }
01711     ETexGenMode genModeR() const { return mGenModeR; }
01712 
01713     void setEyePlaneQ(fvec4 plane) { mEyePlaneQ = plane; }
01714     void setObjectPlaneQ(fvec4 plane) { mObjectPlaneQ = plane; }
01715     void setGenModeQ(ETexGenMode mode) { mGenModeQ = mode; }
01716     fvec4 eyePlaneQ() const { return mEyePlaneQ; }
01717     fvec4 objectPlaneQ() const { return mObjectPlaneQ; }
01718     ETexGenMode genModeQ() const { return mGenModeQ; }
01719 
01720     virtual ref<RenderState> clone() const
01721     {
01722       ref<TexGen> rs = new TexGen;
01723       *rs = *this;
01724       return rs;
01725     }
01726 
01727   public:
01728     fvec4 mEyePlaneS;
01729     fvec4 mObjectPlaneS;
01730     fvec4 mEyePlaneT;
01731     fvec4 mObjectPlaneT;
01732     fvec4 mEyePlaneR;
01733     fvec4 mObjectPlaneR;
01734     fvec4 mEyePlaneQ;
01735     fvec4 mObjectPlaneQ;
01736     ETexGenMode mGenModeS;
01737     ETexGenMode mGenModeT;
01738     ETexGenMode mGenModeR;
01739     ETexGenMode mGenModeQ;
01740   };
01741   //------------------------------------------------------------------------------
01742   // TextureSampler
01743   //------------------------------------------------------------------------------
01747   class VLGRAPHICS_EXPORT TextureSampler: public RenderStateIndexed
01748   {
01749     VL_INSTRUMENT_CLASS(vl::TextureSampler, RenderStateIndexed)
01750 
01751   public:
01752     TextureSampler()
01753     {
01754       VL_DEBUG_SET_OBJECT_NAME()
01755     }
01756 
01757     virtual ERenderState type() const { return RS_TextureSampler; }
01758     virtual void apply(int index, const Camera*, OpenGLContext* ctx) const;
01759 
01762     void setTexture(Texture* texture) { mTexture = texture; }
01763 
01765     Texture* texture() { return mTexture.get(); }
01766 
01768     const Texture* texture() const { return mTexture.get(); }
01769 
01772     void setTexParameter(TexParameter* tex_param) { mTexParameter = tex_param; }
01773 
01775     TexParameter* getTexParameter() { return mTexParameter.get(); }
01776 
01778     const TexParameter* getTexParameter() const { return mTexParameter.get(); }
01779 
01780     bool hasTexture() const;
01781 
01782     virtual ref<RenderState> clone() const
01783     {
01784       ref<TextureSampler> rs = new TextureSampler;
01785       *rs = *this;
01786       return rs;
01787     }
01788 
01789   protected:
01790     ref<Texture> mTexture;
01791     ref<TexParameter> mTexParameter;
01792   };
01793   //------------------------------------------------------------------------------
01794   // ShaderAnimator
01795   //------------------------------------------------------------------------------
01800   class VLGRAPHICS_EXPORT ShaderAnimator: public Object
01801   {
01802     VL_INSTRUMENT_ABSTRACT_CLASS(vl::ShaderAnimator, Object)
01803 
01804   public:
01805     ShaderAnimator(): mEnabled(true) {}
01806 
01812     virtual void updateShader(Shader* shader, Camera* camera, real cur_time) = 0;
01813 
01815     void setEnabled(bool enable) { mEnabled = enable; }
01816 
01818     bool isEnabled() const { return mEnabled; }
01819 
01820   protected:
01821     bool mEnabled;
01822   };
01823   //------------------------------------------------------------------------------
01824   // Shader
01825   //------------------------------------------------------------------------------
01838   class VLGRAPHICS_EXPORT Shader: public Object
01839   {
01840     VL_INSTRUMENT_CLASS(vl::Shader, Object)
01841 
01842     // use deepCopy() and shallowCopy() instead
01843     Shader(const Shader& other): Object(other) { }
01844     Shader& operator=(const Shader&) { return *this; }
01845 
01846   public:
01848     Shader();
01849 
01851     virtual ~Shader();
01852 
01854     ref<Shader> shallowCopy() const
01855     {
01856       ref<Shader> sh = new Shader;
01857       sh->shallowCopyFrom(*this);
01858       return sh;
01859     }
01860 
01863     Shader& shallowCopyFrom(const Shader& other) 
01864     {
01865       super::operator=(other);
01866 
01867       // we don't copy the update time
01868       // mLastUpdateTime = other.mLastUpdateTime;
01869 
01870       if (other.mRenderStateSet.get())
01871       {
01872         if (mRenderStateSet.get() == NULL)
01873           mRenderStateSet = new RenderStateSet;
01874         mRenderStateSet->shallowCopyFrom( *other.mRenderStateSet );
01875       }
01876       else
01877         mRenderStateSet = NULL;
01878 
01879       if (other.mEnableSet.get())
01880       {
01881         if (mEnableSet.get() == NULL)
01882           mEnableSet = new EnableSet;
01883         *mEnableSet = *other.mEnableSet;
01884       }
01885       else
01886         mEnableSet = NULL;
01887 
01888       if (other.mUniformSet.get())
01889       {
01890         if (mUniformSet.get() == NULL)
01891           mUniformSet = new UniformSet;
01892         mUniformSet->shallowCopyFrom( *other.mUniformSet );
01893       }
01894       else
01895         mUniformSet = NULL;
01896 
01897       mScissor = other.mScissor;
01898 
01899       mShaderAnimator = other.mShaderAnimator;
01900           
01901       #if VL_SHADER_USER_DATA
01902         mShaderUserData = other.mShaderUserData;
01903       #endif
01904 
01905       return *this;
01906     }
01907 
01909     ref<Shader> deepCopy() const
01910     {
01911       ref<Shader> sh = new Shader;
01912       sh->deepCopyFrom(*this);
01913       return sh;
01914     }
01915 
01917     Shader& deepCopyFrom(const Shader& other)
01918     {
01919       super::operator=(other);
01920 
01921       // we don't copy the update time
01922       // mLastUpdateTime = other.mLastUpdateTime;
01923 
01924       if (other.mRenderStateSet.get())
01925       {
01926         if (mRenderStateSet.get() == NULL)
01927           mRenderStateSet = new RenderStateSet;
01928         mRenderStateSet->deepCopyFrom( *other.mRenderStateSet.get() );
01929       }
01930       else
01931         mRenderStateSet = NULL;
01932 
01933       if (other.mEnableSet.get())
01934       {
01935         if (mEnableSet.get() == NULL)
01936           mEnableSet = new EnableSet;
01937         *mEnableSet = *other.mEnableSet; // this is just a vector of ints
01938       }
01939       else
01940         mEnableSet = NULL;
01941 
01942       if (other.mUniformSet.get())
01943       {
01944         if (mUniformSet.get() == NULL)
01945           mUniformSet = new UniformSet;
01946         mUniformSet->deepCopyFrom( *other.mUniformSet.get() );
01947       }
01948       else
01949         mUniformSet = NULL;
01950 
01951       mScissor = new Scissor(*other.mScissor);
01952 
01953       // note: this is shallow copied
01954       mShaderAnimator = other.mShaderAnimator;
01955           
01956       #if VL_SHADER_USER_DATA
01957         mShaderUserData = other.mShaderUserData;
01958       #endif
01959 
01960       return *this;
01961     }
01962 
01964     void reset()
01965     {
01966       disableAll();
01967       eraseAllRenderStates();
01968       eraseAllUniforms();
01969     }
01970 
01971     // state getters
01972 
01974     GLSLProgram* gocGLSLProgram();
01975 
01977     const GLSLProgram* getGLSLProgram() const;
01978 
01980     GLSLProgram* getGLSLProgram();
01981 
01982     PixelTransfer* gocPixelTransfer();
01983     const PixelTransfer* getPixelTransfer() const { if (!getRenderStateSet()) return NULL; else return static_cast<const PixelTransfer*>( getRenderStateSet()->renderState( RS_PixelTransfer ) ); }
01984     PixelTransfer* getPixelTransfer() { if (!getRenderStateSet()) return NULL; else return static_cast<PixelTransfer*>( getRenderStateSet()->renderState( RS_PixelTransfer ) ); }
01985 
01986     Hint* gocHint();
01987     const Hint* getHint() const { if (!getRenderStateSet()) return NULL; else return static_cast<const Hint*>( getRenderStateSet()->renderState( RS_Hint ) ); }
01988     Hint* getHint() { if (!getRenderStateSet()) return NULL; else return static_cast<Hint*>( getRenderStateSet()->renderState( RS_Hint ) ); }
01989 
01990     CullFace* gocCullFace();
01991     const CullFace* getCullFace() const { if (!getRenderStateSet()) return NULL; else return static_cast<const CullFace*>( getRenderStateSet()->renderState( RS_CullFace ) ); }
01992     CullFace* getCullFace() { if (!getRenderStateSet()) return NULL; else return static_cast<CullFace*>( getRenderStateSet()->renderState( RS_CullFace ) ); }
01993 
01994     FrontFace* gocFrontFace();
01995     const FrontFace* getFrontFace() const { if (!getRenderStateSet()) return NULL; else return static_cast<const FrontFace*>( getRenderStateSet()->renderState( RS_FrontFace ) ); }
01996     FrontFace* getFrontFace() { if (!getRenderStateSet()) return NULL; else return static_cast<FrontFace*>( getRenderStateSet()->renderState( RS_FrontFace ) ); }
01997 
01998     DepthFunc* gocDepthFunc();
01999     const DepthFunc* getDepthFunc() const { if (!getRenderStateSet()) return NULL; else return static_cast<const DepthFunc*>( getRenderStateSet()->renderState( RS_DepthFunc ) ); }
02000     DepthFunc* getDepthFunc() { if (!getRenderStateSet()) return NULL; else return static_cast<DepthFunc*>( getRenderStateSet()->renderState( RS_DepthFunc ) ); }
02001 
02002     DepthMask* gocDepthMask();
02003     const DepthMask* getDepthMask() const { if (!getRenderStateSet()) return NULL; else return static_cast<const DepthMask*>( getRenderStateSet()->renderState( RS_DepthMask ) ); }
02004     DepthMask* getDepthMask() { if (!getRenderStateSet()) return NULL; else return static_cast<DepthMask*>( getRenderStateSet()->renderState( RS_DepthMask ) ); }
02005 
02006     Color* gocColor();
02007     const Color* getColor() const { if (!getRenderStateSet()) return NULL; else return static_cast<const Color*>( getRenderStateSet()->renderState( RS_Color ) ); }
02008     Color* getColor() { if (!getRenderStateSet()) return NULL; else return static_cast<Color*>( getRenderStateSet()->renderState( RS_Color ) ); }
02009 
02010     SecondaryColor* gocSecondaryColor();
02011     const SecondaryColor* getSecondaryColor() const { if (!getRenderStateSet()) return NULL; else return static_cast<const SecondaryColor*>( getRenderStateSet()->renderState( RS_SecondaryColor ) ); }
02012     SecondaryColor* getSecondaryColor() { if (!getRenderStateSet()) return NULL; else return static_cast<SecondaryColor*>( getRenderStateSet()->renderState( RS_SecondaryColor ) ); }
02013 
02014     Normal* gocNormal();
02015     const Normal* getNormal() const { if (!getRenderStateSet()) return NULL; else return static_cast<const Normal*>( getRenderStateSet()->renderState( RS_Normal ) ); }
02016     Normal* getNormal() { if (!getRenderStateSet()) return NULL; else return static_cast<Normal*>( getRenderStateSet()->renderState( RS_Normal ) ); }
02017 
02018     ColorMask* gocColorMask();
02019     const ColorMask* getColorMask() const { if (!getRenderStateSet()) return NULL; else return static_cast<const ColorMask*>( getRenderStateSet()->renderState( RS_ColorMask ) ); }
02020     ColorMask* getColorMask() { if (!getRenderStateSet()) return NULL; else return static_cast<ColorMask*>( getRenderStateSet()->renderState( RS_ColorMask ) ); }
02021 
02022     PolygonMode* gocPolygonMode();
02023     const PolygonMode* getPolygonMode() const { if (!getRenderStateSet()) return NULL; else return static_cast<const PolygonMode*>( getRenderStateSet()->renderState( RS_PolygonMode ) ); }
02024     PolygonMode* getPolygonMode() { if (!getRenderStateSet()) return NULL; else return static_cast<PolygonMode*>( getRenderStateSet()->renderState( RS_PolygonMode ) ); }
02025 
02026     ShadeModel* gocShadeModel();
02027     const ShadeModel* getShadeModel() const { if (!getRenderStateSet()) return NULL; else return static_cast<const ShadeModel*>( getRenderStateSet()->renderState( RS_ShadeModel ) ); }
02028     ShadeModel* getShadeModel() { if (!getRenderStateSet()) return NULL; else return static_cast<ShadeModel*>( getRenderStateSet()->renderState( RS_ShadeModel ) ); }
02029 
02030     BlendEquation* gocBlendEquation();
02031     const BlendEquation* getBlendEquation() const { if (!getRenderStateSet()) return NULL; else return static_cast<const BlendEquation*>( getRenderStateSet()->renderState( RS_BlendEquation ) ); }
02032     BlendEquation* getBlendEquation() { if (!getRenderStateSet()) return NULL; else return static_cast<BlendEquation*>( getRenderStateSet()->renderState( RS_BlendEquation ) ); }
02033 
02034     AlphaFunc* gocAlphaFunc();
02035     const AlphaFunc* getAlphaFunc() const { if (!getRenderStateSet()) return NULL; else return static_cast<const AlphaFunc*>( getRenderStateSet()->renderState( RS_AlphaFunc ) ); }
02036     AlphaFunc* getAlphaFunc() { if (!getRenderStateSet()) return NULL; else return static_cast<AlphaFunc*>( getRenderStateSet()->renderState( RS_AlphaFunc ) ); }
02037 
02038     Material* gocMaterial();
02039     const Material* getMaterial() const { if (!getRenderStateSet()) return NULL; else return static_cast<const Material*>( getRenderStateSet()->renderState( RS_Material ) ); }
02040     Material* getMaterial() { if (!getRenderStateSet()) return NULL; else return static_cast<Material*>( getRenderStateSet()->renderState( RS_Material ) ); }
02041 
02042     LightModel* gocLightModel();
02043     const LightModel* getLightModel() const { if (!getRenderStateSet()) return NULL; else return static_cast<const LightModel*>( getRenderStateSet()->renderState( RS_LightModel ) ); }
02044     LightModel* getLightModel() { if (!getRenderStateSet()) return NULL; else return static_cast<LightModel*>( getRenderStateSet()->renderState( RS_LightModel ) ); }
02045 
02046     Fog* gocFog();
02047     const Fog* getFog() const { if (!getRenderStateSet()) return NULL; else return static_cast<const Fog*>( getRenderStateSet()->renderState( RS_Fog ) ); }
02048     Fog* getFog() { if (!getRenderStateSet()) return NULL; else return static_cast<Fog*>( getRenderStateSet()->renderState( RS_Fog ) ); }
02049 
02050     PolygonOffset* gocPolygonOffset();
02051     const PolygonOffset* getPolygonOffset() const { if (!getRenderStateSet()) return NULL; else return static_cast<const PolygonOffset*>( getRenderStateSet()->renderState( RS_PolygonOffset ) ); }
02052     PolygonOffset* getPolygonOffset() { if (!getRenderStateSet()) return NULL; else return static_cast<PolygonOffset*>( getRenderStateSet()->renderState( RS_PolygonOffset ) ); }
02053 
02054     LogicOp* gocLogicOp();
02055     const LogicOp* getLogicOp() const { if (!getRenderStateSet()) return NULL; else return static_cast<const LogicOp*>( getRenderStateSet()->renderState( RS_LogicOp ) ); }
02056     LogicOp* getLogicOp() { if (!getRenderStateSet()) return NULL; else return static_cast<LogicOp*>( getRenderStateSet()->renderState( RS_LogicOp ) ); }
02057 
02058     DepthRange* gocDepthRange();
02059     const DepthRange* getDepthRange() const { if (!getRenderStateSet()) return NULL; else return static_cast<const DepthRange*>( getRenderStateSet()->renderState( RS_DepthRange ) ); }
02060     DepthRange* getDepthRange() { if (!getRenderStateSet()) return NULL; else return static_cast<DepthRange*>( getRenderStateSet()->renderState( RS_DepthRange ) ); }
02061 
02062     LineWidth* gocLineWidth();
02063     const LineWidth* getLineWidth() const { if (!getRenderStateSet()) return NULL; else return static_cast<const LineWidth*>( getRenderStateSet()->renderState( RS_LineWidth ) ); }
02064     LineWidth* getLineWidth() { if (!getRenderStateSet()) return NULL; else return static_cast<LineWidth*>( getRenderStateSet()->renderState( RS_LineWidth ) ); }
02065 
02066     PointSize* gocPointSize();
02067     const PointSize* getPointSize() const { if (!getRenderStateSet()) return NULL; else return static_cast<const PointSize*>( getRenderStateSet()->renderState( RS_PointSize ) ); }
02068     PointSize* getPointSize() { if (!getRenderStateSet()) return NULL; else return static_cast<PointSize*>( getRenderStateSet()->renderState( RS_PointSize ) ); }
02069 
02070     LineStipple* gocLineStipple();
02071     const LineStipple* getLineStipple() const { if (!getRenderStateSet()) return NULL; else return static_cast<const LineStipple*>( getRenderStateSet()->renderState( RS_LineStipple ) ); }
02072     LineStipple* getLineStipple() { if (!getRenderStateSet()) return NULL; else return static_cast<LineStipple*>( getRenderStateSet()->renderState( RS_LineStipple ) ); }
02073 
02074     PolygonStipple* gocPolygonStipple();
02075     const PolygonStipple* getPolygonStipple() const { if (!getRenderStateSet()) return NULL; else return static_cast<const PolygonStipple*>( getRenderStateSet()->renderState( RS_PolygonStipple ) ); }
02076     PolygonStipple* getPolygonStipple() { if (!getRenderStateSet()) return NULL; else return static_cast<PolygonStipple*>( getRenderStateSet()->renderState( RS_PolygonStipple ) ); }
02077 
02078     PointParameter* gocPointParameter();
02079     const PointParameter* getPointParameter() const { if (!getRenderStateSet()) return NULL; else return static_cast<const PointParameter*>( getRenderStateSet()->renderState( RS_PointParameter ) ); }
02080     PointParameter* getPointParameter() { if (!getRenderStateSet()) return NULL; else return static_cast<PointParameter*>( getRenderStateSet()->renderState( RS_PointParameter ) ); }
02081 
02082     StencilFunc* gocStencilFunc();
02083     const StencilFunc* getStencilFunc() const { if (!getRenderStateSet()) return NULL; else return static_cast<const StencilFunc*>( getRenderStateSet()->renderState( RS_StencilFunc ) ); }
02084     StencilFunc* getStencilFunc() { if (!getRenderStateSet()) return NULL; else return static_cast<StencilFunc*>( getRenderStateSet()->renderState( RS_StencilFunc ) ); }
02085 
02086     StencilOp* gocStencilOp();
02087     const StencilOp* getStencilOp() const { if (!getRenderStateSet()) return NULL; else return static_cast<const StencilOp*>( getRenderStateSet()->renderState( RS_StencilOp ) ); }
02088     StencilOp* getStencilOp() { if (!getRenderStateSet()) return NULL; else return static_cast<StencilOp*>( getRenderStateSet()->renderState( RS_StencilOp ) ); }
02089 
02090     StencilMask* gocStencilMask();
02091     const StencilMask* getStencilMask() const { if (!getRenderStateSet()) return NULL; else return static_cast<const StencilMask*>( getRenderStateSet()->renderState( RS_StencilMask ) ); }
02092     StencilMask* getStencilMask() { if (!getRenderStateSet()) return NULL; else return static_cast<StencilMask*>( getRenderStateSet()->renderState( RS_StencilMask ) ); }
02093 
02094     BlendColor* gocBlendColor();
02095     const BlendColor* getBlendColor() const { if (!getRenderStateSet()) return NULL; else return static_cast<const BlendColor*>( getRenderStateSet()->renderState( RS_BlendColor ) ); }
02096     BlendColor* getBlendColor() { if (!getRenderStateSet()) return NULL; else return static_cast<BlendColor*>( getRenderStateSet()->renderState( RS_BlendColor ) ); }
02097 
02098     BlendFunc* gocBlendFunc();
02099     const BlendFunc* getBlendFunc() const { if (!getRenderStateSet()) return NULL; else return static_cast<const BlendFunc*>( getRenderStateSet()->renderState( RS_BlendFunc ) ); }
02100     BlendFunc* getBlendFunc() { if (!getRenderStateSet()) return NULL; else return static_cast<BlendFunc*>( getRenderStateSet()->renderState( RS_BlendFunc ) ); }
02101 
02102     SampleCoverage* gocSampleCoverage();
02103     const SampleCoverage* getSampleCoverage() const { if (!getRenderStateSet()) return NULL; else return static_cast<const SampleCoverage*>( getRenderStateSet()->renderState( RS_SampleCoverage ) ); }
02104     SampleCoverage* getSampleCoverage() { if (!getRenderStateSet()) return NULL; else return static_cast<SampleCoverage*>( getRenderStateSet()->renderState( RS_SampleCoverage ) ); }
02105 
02106     // indexed render states
02107 
02108     // vertex attrib
02109 
02110     VertexAttrib* gocVertexAttrib(int attr_index);
02111     
02112     const VertexAttrib* getVertexAttrib(int attr_index) const;
02113     
02114     VertexAttrib* getVertexAttrib(int attr_index);
02115 
02116     // lights
02117 
02118     Light* gocLight(int light_index);
02119     
02120     const Light* getLight(int light_index) const;
02121     
02122     Light* getLight(int light_index);
02123 
02124     // clip planes
02125 
02126     ClipPlane* gocClipPlane(int plane_index);
02127     
02128     const ClipPlane* getClipPlane(int plane_index) const;
02129     
02130     ClipPlane* getClipPlane(int plane_index);
02131 
02132     // texture unit
02133 
02134     TextureSampler* gocTextureSampler(int unit_index);
02135     
02136     const TextureSampler* getTextureSampler(int unit_index) const { return static_cast<const TextureSampler*>( getRenderStateSet()->renderState( RS_TextureSampler, unit_index ) ); }
02137     
02138     TextureSampler* getTextureSampler(int unit_index) { return static_cast<TextureSampler*>( getRenderStateSet()->renderState( RS_TextureSampler, unit_index ) ); }
02139 
02140     // tex env
02141 
02142     TexEnv* gocTexEnv(int unit_index);
02143     
02144     const TexEnv* getTexEnv(int unit_index) const { return static_cast<const TexEnv*>( getRenderStateSet()->renderState( RS_TexEnv, unit_index ) ); }
02145     
02146     TexEnv* getTexEnv(int unit_index) { return static_cast<TexEnv*>( getRenderStateSet()->renderState( RS_TexEnv, unit_index ) ); }
02147 
02148     // tex gen
02149     
02150     TexGen* gocTexGen(int unit_index);
02151     
02152     const TexGen* getTexGen(int unit_index) const { return static_cast<const TexGen*>( getRenderStateSet()->renderState( RS_TexGen, unit_index ) ); }
02153     
02154     TexGen* getTexGen(int unit_index) { return static_cast<TexGen*>( getRenderStateSet()->renderState( RS_TexGen, unit_index ) ); }
02155 
02156     // texture matrix
02157 
02158     TextureMatrix* gocTextureMatrix(int unit_index);
02159     
02160     const TextureMatrix* getTextureMatrix(int unit_index) const { return static_cast<const TextureMatrix*>( getRenderStateSet()->renderState( RS_TextureMatrix, unit_index ) ); }
02161 
02162     TextureMatrix* getTextureMatrix(int unit_index) { return static_cast<TextureMatrix*>( getRenderStateSet()->renderState( RS_TextureMatrix, unit_index ) ); }
02163 
02164     // enable methods
02165 
02166     void enable(EEnable capability)  { gocEnableSet()->enable(capability); }
02167     
02168     void disable(EEnable capability) { gocEnableSet()->disable(capability); }
02169     
02170     const std::vector<EEnable>& enables() const { return getEnableSet()->enables(); }
02171     
02172     int isEnabled(EEnable capability) const { if (!getEnableSet()) return false; return getEnableSet()->isEnabled(capability); }
02173     
02174     void disableAll() { if (getEnableSet()) getEnableSet()->disableAll(); }
02175     
02176     bool isBlendingEnabled() const { if (!getEnableSet()) return false; return getEnableSet()->isBlendingEnabled(); }
02177 
02178     // render states methods
02179 
02180     void setRenderState(RenderStateNonIndexed* renderstate) { gocRenderStateSet()->setRenderState(renderstate, -1); }
02181     
02182     void setRenderState(RenderState* renderstate, int index) { gocRenderStateSet()->setRenderState(renderstate, index); }
02183     
02184     const RenderState* renderState( ERenderState type, int index=0 ) const { if (!getRenderStateSet()) return NULL; return getRenderStateSet()->renderState(type, index); }
02185     
02186     RenderState* renderState( ERenderState type, int index=0 ) { return gocRenderStateSet()->renderState(type, index); }
02187     
02188     size_t renderStatesCount() const { return getRenderStateSet()->renderStatesCount(); }
02189 
02190     const RenderStateSlot* renderStates() const { return getRenderStateSet()->renderStates(); }
02191 
02192     RenderStateSlot* renderStates() { return getRenderStateSet()->renderStates(); }
02193 
02195     void eraseRenderState(ERenderState type, int index=-1) { gocRenderStateSet()->eraseRenderState(type, index); }
02196     
02197     void eraseRenderState(RenderState* rs, int index) { if (rs) gocRenderStateSet()->eraseRenderState(rs->type(), index); }
02198     
02199     void eraseAllRenderStates() { if(getRenderStateSet()) getRenderStateSet()->eraseAllRenderStates(); }
02200     
02202     const GLSLProgram* glslProgram() const { if (!getRenderStateSet()) return NULL; return getRenderStateSet()->glslProgram(); }
02203 
02205     GLSLProgram* glslProgram() { return gocRenderStateSet()->glslProgram(); }
02206 
02207     // uniforms methods
02208 
02210     void setUniform(Uniform* uniform) { VL_CHECK(uniform); gocUniformSet()->setUniform(uniform); }
02211     
02213     const std::vector< ref<Uniform> >& uniforms() const { return getUniformSet()->uniforms(); }
02214     
02216     void eraseUniform(const char* name) { gocUniformSet()->eraseUniform(name); }
02217     
02219     void eraseUniform(const Uniform* uniform) { gocUniformSet()->eraseUniform(uniform); }
02220     
02222     void eraseAllUniforms() { if (getUniformSet()) getUniformSet()->eraseAllUniforms(); }
02223     
02225     Uniform* gocUniform(const char* name) { return gocUniformSet()->gocUniform(name); }
02226     
02228     Uniform* getUniform(const char* name) { return getUniformSet()->getUniform(name); }
02229     
02231     const Uniform* getUniform(const char* name) const { return getUniformSet()->getUniform(name); }
02232 
02233     // sets
02234 
02235     EnableSet* gocEnableSet() { if (!mEnableSet) mEnableSet = new EnableSet; return mEnableSet.get(); }
02236     
02237     EnableSet* getEnableSet() { return mEnableSet.get(); }
02238     
02239     const EnableSet* getEnableSet() const { return mEnableSet.get(); }
02240     
02241     RenderStateSet* gocRenderStateSet() { if (!mRenderStateSet) mRenderStateSet = new RenderStateSet; return mRenderStateSet.get(); }
02242     
02243     RenderStateSet* getRenderStateSet() { return mRenderStateSet.get(); }
02244     
02245     const RenderStateSet* getRenderStateSet() const { return mRenderStateSet.get(); }
02246     
02257     UniformSet* gocUniformSet() { if (!mUniformSet) mUniformSet = new UniformSet; return mUniformSet.get(); }
02258     
02269     UniformSet* getUniformSet() { return mUniformSet.get(); }
02270     
02281     const UniformSet* getUniformSet() const { return mUniformSet.get(); }
02282 
02283     void setEnableSet(EnableSet* es) { mEnableSet = es; }
02284     
02285     void setRenderStateSet(RenderStateSet* rss) { mRenderStateSet = rss; }
02286     
02297     void setUniformSet(UniformSet* us) { mUniformSet = us; }
02298 
02308     void setScissor(Scissor* scissor) { mScissor = scissor; }
02309     
02317     const Scissor* scissor() const { return mScissor.get(); }
02318     
02326     Scissor* scissor() { return mScissor.get(); }
02327 
02329     void setShaderAnimator(ShaderAnimator* animator) { mShaderAnimator = animator; }
02330 
02332     ShaderAnimator* shaderAnimator() { return mShaderAnimator.get(); }
02333 
02335     const ShaderAnimator* shaderAnimator() const { return mShaderAnimator.get(); }
02336 
02338     real lastUpdateTime() const { return mLastUpdateTime; }
02339 
02341     void setLastUpdateTime(real time) { mLastUpdateTime = time; }
02342 
02343 #if VL_SHADER_USER_DATA
02344   public:
02345     void* shaderUserData() { return mShaderUserData; }
02346     const void* shaderUserData() const { return mShaderUserData; }
02347     void setShaderUserData(void* user_data) { mShaderUserData = user_data; }
02348 
02349   private:
02350     void* mShaderUserData;
02351 #endif
02352 
02353   protected:
02354     ref<RenderStateSet> mRenderStateSet;
02355     ref<EnableSet> mEnableSet;
02356     ref<UniformSet> mUniformSet;
02357     ref<Scissor> mScissor;
02358     ref<ShaderAnimator> mShaderAnimator;
02359     real mLastUpdateTime;
02360   };
02361 }
02362 
02363 #endif
Visualization Library 2011.09.1160 Reference Documentation
Copyright 2005-2011 Michele Bosi. All rights reserved.
Updated on Thu May 2 2013 13:40:41.
Permission is granted to use this page to write and publish articles regarding Visualization Library.