PageRenderTime 60ms CodeModel.GetById 37ms RepoModel.GetById 0ms app.codeStats 1ms

/COLLADAStreamWriter/include/COLLADASWRenderState.h

https://bitbucket.org/ZhangJingGuo/opencollada
C Header | 222 lines | 153 code | 32 blank | 37 comment | 0 complexity | 302cf72de7cefbef8369f057a9512372 MD5 | raw file
    

  1. /*
    2. 

  2.     Copyright (c) 2008-2009 NetAllied Systems GmbH
    3. 

    4. 

  4.     This file is part of COLLADAStreamWriter.
    5. 

    6. 

  6.     Licensed under the MIT Open Source License, 
    7. 

  7.     for details please see LICENSE file or the website
    8. 

  8.     http://www.opensource.org/licenses/mit-license.php
    9. 

  9. */
    10. 

  10. 

  11. #ifndef __COLLADASTREAMWRITER_RENDER_STATE_H__
    12. 

  12. #define __COLLADASTREAMWRITER_RENDER_STATE_H__
    13. 

  13. 

  14. #include "COLLADASWPrerequisites.h"
    15. 

  15. #include "COLLADASWStreamWriter.h"
    16. 

  16. #include "COLLADASWConstants.h"
    17. 

  17. #include "COLLADABUUtils.h"
    18. 

  18. 

  19. namespace COLLADASW
    20. 

  20. {
    21. 

  21. 

  22.     /** Declares the storage for the graphical representation of an object. */
    23. 

  23.     class RenderState
    24. 

  24.     {
    25. 

  25. 

  26.     public:
    27. 

  27. 

  28.         /** Enumerates the COLLADASW render states for effect passes.
    29. 

  29.         Each state description states the structure allocated in FCollada for this state.
    30. 

  30.         For example, ALPHA_FUNC describes: { FUDaePassStateFunction function = ALWAYS, float alphaComparison = 0.0f }.
    31. 

  31.         This implies a 8-byte structure with
    32. 

  32.         1) FUDaePassStateFunction::Function at offset 0; it defaults to the ALWAYS enumerated type.
    33. 

  33.         2) The alpha comparison value at offset 4; it defaults to 0.0f.
    34. 

  34.         All enumerated types are 4 byte in length. */
    35. 

  35.         enum PassState
    36. 

  36.         {
    37. 

  37.             ALPHA_FUNC = 0, /**< { FUDaePassStateFunction function = ALWAYS, float alphaComparison = 0.0f } */
    38. 

  38.             BLEND_FUNC, /**< { FUDaePassStateBlendType sourceBlend = ONE, FUDaePassStateBlendType destinationBlend = ZERO } */
    39. 

  39.             BLEND_FUNC_SEPARATE, /**< { FUDaePassStateBlendType sourceColorBlend = ONE, FUDaePassStateBlendType destinationColorBlend = ZERO, FUDaePassStateBlendType sourceAlphaBlend = ONE, FUDaePassStateBlendType destinationAlphaBlend = ZERO } */
    40. 

  40.             BLEND_EQUATION, /**< { FUDaePassStateBlendEquation blendEquation = ADD } */
    41. 

  41.             BLEND_EQUATION_SEPARATE, /**< { FUDaePassStateBlendEquation colorEquation = ADD, FUDaePassStateBlendEquation alphaEquation = ADD } */
    42. 

  42.             COLOR_MATERIAL, /**< { FUDaePassStateFaceType whichFaces = FRONT_AND_BACK, FUDaePassStateMaterialType material = AMBIENT_AND_DIFFUSE } */
    43. 

  43.             CULL_FACE, /**< { FUDaePassStateFaceType culledFaces = BACK } */
    44. 

  44.             DEPTH_FUNC, /**< { FUDaePassStateFunction depthAcceptFunction = ALWAYS } */
    45. 

  45.             FOG_MODE, /**< { FUDaePassStateFogType fogType = EXP } */
    46. 

  46.             FOG_COORD_SRC, /**< { FUDaePassStateFogCoordinateType type = FOG_COORDINATE } */
    47. 

  47. 

  48.             FRONT_FACE = 10, /**< { FUDaePassStateFrontFaceType frontFaceSide = COUNTER_CLOCKWISE } */
    49. 

  49.             LIGHT_MODEL_COLOR_CONTROL, /**< { FUDaePassStateLightModelColorControlType controlType = SINGLE_COLOR } */
    50. 

  50.             LOGIC_OP, /**< { FUDaePassStateLogicOperation operation = COPY } */
    51. 

  51.             POLYGON_MODE, /**< { FUDaePassStateFaceType whichFaces = FRONT_AND_BACK, FUDaePassStatePolygonMode renderMode = FILL } */
    52. 

  52.             SHADE_MODEL, /**< { FUDaePassStateShadeModel model = SMOOTH } */
    53. 

  53.             STENCIL_FUNC, /**< { FUDaePassStateFunction acceptFunction = ALWAYS, uint8 referenceValue = 0, uint8 mask = 0xFF } */
    54. 

  54.             STENCIL_OP, /**< { FUDaePassStateStencilOperation failOperation = KEEP, FUDaePassStateStencilOperation depthFailOperation = KEEP, FUDaePassStateStencilOperation depthPassOperation = KEEP } */
    55. 

  55.             STENCIL_FUNC_SEPARATE, /**< { FUDaePassStateFunction frontFacesAcceptFunction = ALWAYS, FUDaePassStateFunction backFacesAcceptFunction = ALWAYS, uint8 referenceValue = 0, uint8 mask = 0xFF } */
    56. 

  56.             STENCIL_OP_SEPARATE, /**< { FUDaePassStateFaceType whichFaces = FRONT_AND_BACK, FUDaePassStateStencilOperation failOperation = KEEP, FUDaePassStateStencilOperation depthFailOperation = KEEP, FUDaePassStateStencilOperation depthPassOperation = KEEP } */
    57. 

  57.             STENCIL_MASK_SEPARATE, /**< { FUDaePassStateFaceType whichFaces = FRONT_AND_BACK, uint8 mask = 0xFF } */
    58. 

  58. 

  59.             LIGHT_ENABLE = 20, /**< { uint8 lightIndex = 0, bool enabled = false } */
    60. 

  60.             LIGHT_AMBIENT, /**< { uint8 lightIndex = 0, FMVector4 ambientColor = [0,0,0,1] } */
    61. 

  61.             LIGHT_DIFFUSE, /**< { uint8 lightIndex = 0, FMVector4 diffuseColor = [0,0,0,0] } */
    62. 

  62.             LIGHT_SPECULAR, /**< { uint8 lightIndex = 0, FMVector4 specularColor = [0,0,0,0] } */
    63. 

  63.             LIGHT_POSITION, /**< { uint8 lightIndex = 0, FMVector4 position = [0,0,1,0] } */
    64. 

  64.             LIGHT_CONSTANT_ATTENUATION, /**< { uint8 lightIndex = 0, float constantAttenuation = 1.0f } */
    65. 

  65.             LIGHT_LINEAR_ATTENUATION, /**< { uint8 lightIndex = 0, float linearAttenuation = 0.0f } */
    66. 

  66.             LIGHT_QUADRATIC_ATTENUATION, /**< { uint8 lightIndex = 0, float quadraticAttenuation = 0.0f } */
    67. 

  67.             LIGHT_SPOT_CUTOFF, /**< { uint8 lightIndex = 0, float cutoff = 180.0f } */
    68. 

  68.             LIGHT_SPOT_DIRECTION, /**< { uint8 lightIndex = 0, FMVector4 direction = [0,0,-1] } */
    69. 

  69.             LIGHT_SPOT_EXPONENT = 30, /**< { uint8 lightIndex = 0, float exponent = 0.0f } */
    70. 

  70. 

  71.             TEXTURE1D = 31, /**< { uint8 textureIndex = 0, uint32 textureId = 0 } */ 
    72. 

  72.             TEXTURE2D, /**< { uint8 textureIndex = 0, uint32 textureId = 0 } */
    73. 

  73.             TEXTURE3D, /**< { uint8 textureIndex = 0, uint32 textureId = 0 } */
    74. 

  74.             TEXTURECUBE, /**< { uint8 textureIndex = 0, uint32 textureId = 0 } */
    75. 

  75.             TEXTURERECT, /**< { uint8 textureIndex = 0, uint32 textureId = 0 } */
    76. 

  76.             TEXTUREDEPTH, /**< { uint8 textureIndex = 0, uint32 textureId = 0 } */
    77. 

  77.             TEXTURE1D_ENABLE, /**< { uint8 textureIndex = 0, bool enabled = false } */
    78. 

  78.             TEXTURE2D_ENABLE, /**< { uint8 textureIndex = 0, bool enabled = false } */
    79. 

  79.             TEXTURE3D_ENABLE, /**< { uint8 textureIndex = 0, bool enabled = false } */
    80. 

  80.             TEXTURECUBE_ENABLE, /**< { uint8 textureIndex = 0, bool enabled = false } */
    81. 

  81.             TEXTURERECT_ENABLE, /**< { uint8 textureIndex = 0, bool enabled = false } */
    82. 

  82.             TEXTUREDEPTH_ENABLE, /**< { uint8 textureIndex = 0, bool enabled = false } */
    83. 

  83.             TEXTURE_ENV_COLOR, /**< { uint8 textureIndex = 0, FMVector4 environmentColor = [0,0,0,0] } */
    84. 

  84.             TEXTURE_ENV_MODE, /**< { uint8 textureIndex = 0, char environmentMode[255] = "" } */
    85. 

  85. 

  86.             CLIP_PLANE = 45, /**< { uint8 planeIndex = 0, FMVector4 planeValue = [0,0,0,0] } */
    87. 

  87.             CLIP_PLANE_ENABLE, /**< { uint8 planeIndex = 0, bool enabled = false } */
    88. 

  88.             BLEND_COLOR, /**< { FMVector4 blendColor = [0,0,0,0] } */
    89. 

  89.             CLEAR_COLOR, /**< { FMVector4 clearColor = [0,0,0,0] } */
    90. 

  90.             CLEAR_STENCIL, /**< { uint32 clearStencilValue = 0 } */
    91. 

  91.             CLEAR_DEPTH, /**< { float clearDepthValue = 1.0f } */
    92. 

  92.             COLOR_MASK, /**< { bool redWriteMask = true, bool greenWriteMask = true, bool blueWriteMask = true, bool alphaWriteMask = true } */
    93. 

  93.             DEPTH_BOUNDS, /**< { FMVector2 depthBounds = [0,1] } */
    94. 

  94.             DEPTH_MASK, /**< { bool depthWriteMask = true } */
    95. 

  95.             DEPTH_RANGE, /**< { float minimumDepthValue = 0.0f, float maximumDepthValue = 1.0f } */
    96. 

  96. 

  97.             FOG_DENSITY = 55, /**< { float fogDensity = 1.0f } */
    98. 

  98.             FOG_START, /**< { float fogStartDepthValue = 0.0f } */
    99. 

  99.             FOG_END, /**< { float fogEndDepthValue = 1.0f } */
    100. 

  100.             FOG_COLOR, /**< { FMVector4 fogColor = [0,0,0,0] } */
    101. 

  101.             LIGHT_MODEL_AMBIENT, /**< { FMVector4 ambientColor = [0.2,0.2,0.2,1] } */
    102. 

  102.             LIGHTING_ENABLE, /**< { bool enabled = false } */
    103. 

  103.             LINE_STIPPLE, /**< { uint16 lineStippleStart = 1, uint16 lineStippleEnd = 0xFF } */
    104. 

  104.             LINE_WIDTH, /**< { float lineWidth = 1.0f } */
    105. 

  105. 

  106.             MATERIAL_AMBIENT = 63, /**< { FMVector4 ambientColor = [0.2,0.2,0.2,1] } */
    107. 

  107.             MATERIAL_DIFFUSE, /**< { FMVector4 diffuseColor = [0.8,0.8,0.8,1] } */
    108. 

  108.             MATERIAL_EMISSION, /**< { FMVector4 emissionColor = [0,0,0,1] } */
    109. 

  109.             MATERIAL_SHININESS, /**< { float shininessOrSpecularLevel = 0.0f } */
    110. 

  110.             MATERIAL_SPECULAR, /**< { FMVector4 specularColor = [0,0,0,1] } */
    111. 

  111.             MODEL_VIEW_MATRIX, /**< { FMMatrix44 modelViewMatrix = FMMatrix44::Identity } */
    112. 

  112.             POINT_DISTANCE_ATTENUATION, /**< { FMVector3 attenuation = [1,0,0] } */
    113. 

  113.             POINT_FADE_THRESHOLD_SIZE, /**< { float threshold = 1.0f } */
    114. 

  114.             POINT_SIZE, /**< { float size = 1.0f } */
    115. 

  115.             POINT_SIZE_MIN, /**< { float minimum = 0.0f } */
    116. 

  116.             POINT_SIZE_MAX, /**< { float maximum = 1.0f } */
    117. 

  117. 

  118.             POLYGON_OFFSET = 74, /**< { float factor = 0.0f, float units = 0.0f } */
    119. 

  119.             PROJECTION_MATRIX, /**< { FMMatrix44 projectionMatrix = FMMatrix44::Identity } */
    120. 

  120.             SCISSOR, /**< { FMVector4 scissor = [0,0,0,0] } */
    121. 

  121.             STENCIL_MASK, /**< { uint32 mask = 0xFFFFFFFF } */
    122. 

  122.             ALPHA_TEST_ENABLE, /**< { bool enabled = false } */
    123. 

  123.             AUTO_NORMAL_ENABLE, /**< { bool enabled  = false } */
    124. 

  124.             BLEND_ENABLE, /**< { bool enabled  = false } */
    125. 

  125.             COLOR_LOGIC_OP_ENABLE, /**< { bool enabled  = false } */
    126. 

  126.             COLOR_MATERIAL_ENABLE, /**< { bool enabled  = true } */
    127. 

  127.             CULL_FACE_ENABLE, /**< { bool enabled  = false } */
    128. 

  128. 

  129.             DEPTH_BOUNDS_ENABLE = 84, /**< { bool enabled  = false } */
    130. 

  130.             DEPTH_CLAMP_ENABLE, /**< { bool enabled  = false } */
    131. 

  131.             DEPTH_TEST_ENABLE, /**< { bool enabled  = false } */
    132. 

  132.             DITHER_ENABLE, /**< { bool enabled  = false } */
    133. 

  133.             FOG_ENABLE, /**< { bool enabled  = false } */
    134. 

  134.             LIGHT_MODEL_LOCAL_VIEWER_ENABLE, /**< { bool enabled  = false } */
    135. 

  135.             LIGHT_MODEL_TWO_SIDE_ENABLE, /**< { bool enabled  = false } */
    136. 

  136.             LINE_SMOOTH_ENABLE, /**< { bool enabled  = false } */
    137. 

  137.             LINE_STIPPLE_ENABLE, /**< { bool enabled = false } */
    138. 

  138.             LOGIC_OP_ENABLE, /**< { bool enabled  = false } */
    139. 

  139.             MULTISAMPLE_ENABLE, /**< { bool enabled  = false } */
    140. 

  140. 

  141.             NORMALIZE_ENABLE = 95, /**< { bool enabled  = false } */
    142. 

  142.             POINT_SMOOTH_ENABLE, /**< { bool enabled  = false } */
    143. 

  143.             POLYGON_OFFSET_FILL_ENABLE, /**< { bool enabled  = false } */
    144. 

  144.             POLYGON_OFFSET_LINE_ENABLE, /**< { bool enabled  = false } */
    145. 

  145.             POLYGON_OFFSET_POINT_ENABLE, /**< { bool enabled  = false } */
    146. 

  146.             POLYGON_SMOOTH_ENABLE, /**< { bool enabled  = false } */
    147. 

  147.             POLYGON_STIPPLE_ENABLE, /**< { bool enabled  = false } */
    148. 

  148.             RESCALE_NORMAL_ENABLE, /**< { bool enabled  = false } */
    149. 

  149. 

  150.             SAMPLE_ALPHA_TO_COVERAGE_ENABLE = 103, /**< { bool enabled  = false } */
    151. 

  151.             SAMPLE_ALPHA_TO_ONE_ENABLE, /**< { bool enabled  = false } */
    152. 

  152.             SAMPLE_COVERAGE_ENABLE, /**< { bool enabled  = false } */
    153. 

  153.             SCISSOR_TEST_ENABLE, /**< { bool enabled  = false } */
    154. 

  154.             STENCIL_TEST_ENABLE, /**< { bool enabled  = false } */
    155. 

  155. 

  156.             COUNT = 108, /**< The number of supported render states. */
    157. 

  157.             PASS_STATE_INVALID /**< An invalid render state. */
    158. 

  158.         };
    159. 

  159. 

  160.         /** Enumerates the COLLADASW render state function types.
    161. 

  161.         The usage of this enumeration type depends on the render state.
    162. 

  162.         For the alpha-test and the depth-test, this function determines
    163. 

  163.         when a given pixel will be kept when compared against the
    164. 

  164.         color/depth buffer's current alpha/depth value. */
    165. 

  165.         enum PassStateFunction
    166. 

  166.         {
    167. 

  167.             PASS_STATE_FN_NEVER = 0x0200, /**< Never kept. */
    168. 

  168.             PASS_STATE_FN_LESS = 0x0201, /**< The pixel is kept when its value is lesser to the current value. */
    169. 

  169.             PASS_STATE_FN_EQUAL = 0x0202, /**< The pixel is kept when its value is equal to the current value. */
    170. 

  170.             PASS_STATE_FN_LESS_EQUAL = 0x0203, /**< The pixel is kept when its value is lesser or equal to the current value. */
    171. 

  171.             PASS_STATE_FN_GREATER = 0x0204, /**< The pixel is kept when its value is greater to the current value. */
    172. 

  172.             PASS_STATE_FN_NOT_EQUAL = 0x0205, /**< The pixel is kept when its value is not equal to the current value. */
    173. 

  173.             PASS_STATE_FN_GREATER_EQUAL = 0x0206, /**< The pixel is kept when its value is greater or equal to the current value. */
    174. 

  174.             PASS_STATE_FN_ALWAYS = 0x0207, /** Always kept. */
    175. 

  175. 

  176.             PASS_STATE_FN_INVALID /**< An invalid function. */
    177. 

  177.         };
    178. 

  178. 

  179.     public:
    180. 

  180. 

  181.         /** The render states for effect passes. */
    182. 

  182.         static const String CG_RENDER_STATE_NAMES[];
    183. 

  183.         static const PassState CG_RENDER_STATES_XREF[];
    184. 

  184. 

  185.     public:
    186. 

  186. 

  187.         /** Constructor. */
    188. 

  188.         RenderState () {}
    189. 

  189. 

  190.         /** Destructor. */
    191. 

  191.         ~RenderState () {}
    192. 

  192. 

  193.         /** Returns the enumeration type of the current CG state. */
    194. 

  194.         static const PassState getRenderStateFromCgName ( const char* cgName );
    195. 

  195. 

  196.         /** Returns the collada name of the current CG state. */
    197. 

  197.         static const String getCgRenderStateName ( const PassState& state );
    198. 

  198. 

  199.         /** Returns the render state count. */
    200. 

  200.         static size_t getTotalRenderStateCount();
    201. 

  201. 

  202.         /** Converts the render state enumeration type to its COLLADASW render state name string.
    203. 

  203.         @param state The render state enumeration type.
    204. 

  204.         @return The render state name string. */
    205. 

  205.         static const String& getColladaRenderStateName ( const PassState& state );
    206. 

  206. 

  207.         /** Converts the COLLADASW render state function string to the render state function type.
    208. 

  208.         @param value The render state function string.
    209. 

  209.         @return The render state function type. */
    210. 

  210.         static const PassStateFunction getPassStateFunction ( const char* val );
    211. 

  211.         inline const PassStateFunction getPassStateFunction ( const String& value ) 
    212. 

  212.         { return getPassStateFunction ( value.c_str() ); } /**< See above. */
    213. 

  213. 

  214.         /** Converts the render state function type to its COLLADASW render state function string.
    215. 

  215.         @param fn The render state function type.
    216. 

  216.         @return The render state function string. */
    217. 

  217.         static const String& getColladaPassStateString ( const PassStateFunction& fn );
    218. 

  218. 

  219.     };
    220. 

  220. }
    221. 

  221. 

  222. #endif // __COLLADASTREAMWRITER_RENDER_STATE_H__
    223. 

  223.