00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef __CS_CSPLUGINCOMMON_RENDERMANAGER_SHADERSETUP_H__
00020 #define __CS_CSPLUGINCOMMON_RENDERMANAGER_SHADERSETUP_H__
00021
00026 #include "csutil/compositefunctor.h"
00027
00028 #include "csplugincommon/rendermanager/rendertree.h"
00029 #include "csplugincommon/rendermanager/operations.h"
00030 #include "csplugincommon/rendermanager/svsetup.h"
00031
00032 namespace CS
00033 {
00034 namespace RenderManager
00035 {
00036
00037 typedef csArray<size_t> TicketArrayType;
00038 typedef csArray<iShader*> ShaderArrayType;
00039
00047 template<typename RenderTree, typename LayerConfigType>
00048 class ShaderSetup
00049 {
00050 public:
00051 ShaderSetup (ShaderArrayType& shaderArray, const LayerConfigType& layerConfig)
00052 : shaderArray (shaderArray), layerConfig (layerConfig)
00053 {
00054 }
00055
00056 void operator() (typename RenderTree::MeshNode* node)
00057 {
00058
00059 const size_t totalMeshes = node->GetOwner().totalRenderMeshes;
00060
00061 for (size_t i = 0; i < node->meshes.GetSize (); ++i)
00062 {
00063 typename RenderTree::MeshNode::SingleMesh& mesh = node->meshes[i];
00064
00065 csRenderMesh* rm = mesh.renderMesh;
00066
00067 for (size_t layer = 0; layer < layerConfig.GetLayerCount (); ++layer)
00068 {
00069 size_t layerOffset = layer*totalMeshes;
00070
00071 iShader* shader = 0;
00072 if (rm->material)
00073 {
00074 size_t layerShaderNum;
00075 const csStringID* layerShaders = layerConfig.GetShaderTypes (layer, layerShaderNum);
00076
00077 shader = rm->material->GetMaterial ()->GetFirstShader (layerShaders,
00078 layerShaderNum);
00079 }
00080 shaderArray[mesh.contextLocalId+layerOffset] = shader ? shader : layerConfig.GetDefaultShader (layer);
00081 }
00082 }
00083 }
00084
00085 private:
00086 ShaderArrayType& shaderArray;
00087 const LayerConfigType& layerConfig;
00088 };
00089
00090 template<typename RenderTree, typename LayerConfigType>
00091 struct OperationTraits<ShaderSetup<RenderTree, LayerConfigType> >
00092 {
00093 typedef OperationUnorderedParallel Ordering;
00094 };
00095
00096
00097
00105 template<typename RenderTree, typename LayerConfigType>
00106 class TicketSetup
00107 {
00108 public:
00109
00110 TicketSetup (SVArrayHolder& svArrays, csShaderVariableStack& varStack,
00111 const ShaderArrayType& shaderArray, TicketArrayType& tickets,
00112 const LayerConfigType& layerConfig)
00113 : svArrays (svArrays), varStack (varStack),
00114 shaderArray (shaderArray), ticketArray (tickets),
00115 layerConfig (layerConfig)
00116 {
00117 }
00118
00119
00120 void operator() (typename RenderTree::MeshNode* node)
00121 {
00122 const size_t totalMeshes = node->GetOwner().totalRenderMeshes;
00123
00124 for (size_t i = 0; i < node->meshes.GetSize (); ++i)
00125 {
00126 typename RenderTree::MeshNode::SingleMesh& mesh = node->meshes[i];
00127
00128 for (size_t layer = 0; layer < layerConfig.GetLayerCount (); ++layer)
00129 {
00130 size_t layerOffset = layer*totalMeshes;
00131
00132
00133 svArrays.SetupSVStack (varStack, layer, mesh.contextLocalId);
00134
00135
00136 iShader* shader = shaderArray[mesh.contextLocalId+layerOffset];
00137 ticketArray[mesh.contextLocalId+layerOffset] = shader ? shader->GetTicket (*mesh.renderMesh, varStack) : ~0;
00138 }
00139 }
00140 }
00141
00142 private:
00143 SVArrayHolder& svArrays;
00144 csShaderVariableStack& varStack;
00145 const ShaderArrayType& shaderArray;
00146 TicketArrayType& ticketArray;
00147 const LayerConfigType& layerConfig;
00148 };
00149
00150 template<typename RenderTree, typename LayerConfigType>
00151 struct OperationTraits<TicketSetup<RenderTree, LayerConfigType> >
00152 {
00153 typedef OperationUnordered Ordering;
00154 };
00155
00156
00157 template<typename RenderTree, typename LayerConfigType>
00158 struct StandardSATSetupTypes
00159 {
00160 typedef ShaderSetup<RenderTree, LayerConfigType> ShaderSetupType;
00161 typedef ShaderSVSetup<RenderTree, LayerConfigType> ShaderSVSetupType;
00162 typedef TicketSetup<RenderTree, LayerConfigType> TicketSetupType;
00163
00164 typedef CS::Meta::CompositeFunctorType2<TicketSetupType,
00165 ShaderSVSetupType>CombinedFunctorType;
00166 };
00167
00171 template<typename ContextNodeType, typename LayerConfigType>
00172 void SetupStandardShader (ContextNodeType& context,
00173 iShaderManager* shaderManager,
00174 const LayerConfigType& layerConfig)
00175 {
00176 context.shaderArray.SetSize (context.totalRenderMeshes*layerConfig.GetLayerCount ());
00177
00178
00179 typedef typename ContextNodeType::TreeType Tree;
00180 typedef StandardSATSetupTypes<Tree, LayerConfigType> TypeHelper;
00181
00182 typename TypeHelper::ShaderSetupType
00183 shaderSetup (context.shaderArray, layerConfig);
00184
00185 ForEachMeshNode (context, shaderSetup);
00186 }
00187
00192 template<typename ContextNodeType, typename LayerConfigType>
00193 void SetupStandardTicket (ContextNodeType& context,
00194 iShaderManager* shaderManager,
00195 const LayerConfigType& layerConfig)
00196 {
00197 context.ticketArray.SetSize (context.totalRenderMeshes*layerConfig.GetLayerCount ());
00198
00199 typedef typename ContextNodeType::TreeType Tree;
00200 typedef StandardSATSetupTypes<Tree, LayerConfigType> TypeHelper;
00201
00202
00203
00204
00205 typename TypeHelper::TicketSetupType
00206 ticketSetup (context.svArrays, shaderManager->GetShaderVariableStack (),
00207 context.shaderArray, context.ticketArray, layerConfig);
00208
00209 typename TypeHelper::ShaderSVSetupType
00210 shaderSVSetup (context.svArrays, context.shaderArray,
00211 context.ticketArray, layerConfig);
00212
00213
00214 typename TypeHelper::CombinedFunctorType
00215 combFunctor (CS::Meta::CompositeFunctor (ticketSetup, shaderSVSetup));
00216
00217 ForEachMeshNode (context, combFunctor);
00218 }
00219
00220 typedef csDirtyAccessArray<csStringID> ShaderVariableNameArray;
00221 }
00222 }
00223
00224 #endif