Torque3D Documentation / _generateds / shaderMaterialParameters.cpp

shaderMaterialParameters.cpp

Engine/source/materials/shaderMaterialParameters.cpp

More...

Public Defines

define
SHADERMATPARAM_SET(handle, f)    (handle, "Handle is NULL!" ); \
   AssertFatal(handle->isValid(), "Handle is not valid!" ); \
   AssertFatal(dynamic_cast<*>(handle), "Invalid handle type!"); \
   ShaderMaterialParameterHandle* h = static_cast<*>(handle); \
   (h->() == (), "Handle length differs from buffer length!"); \
   for (  = 0;  < h->(); ++) \
{ \
   * shaderHandle = h->mHandles[]; \
    (shaderHandle->isValid()) \
      mBuffers[]->set(shaderHandle, f); \
}

Detailed Description

Public Defines

SHADERMATPARAM_SET(handle, f)    (handle, "Handle is NULL!" ); \
   AssertFatal(handle->isValid(), "Handle is not valid!" ); \
   AssertFatal(dynamic_cast<*>(handle), "Invalid handle type!"); \
   ShaderMaterialParameterHandle* h = static_cast<*>(handle); \
   (h->() == (), "Handle length differs from buffer length!"); \
   for (  = 0;  < h->(); ++) \
{ \
   * shaderHandle = h->mHandles[]; \
    (shaderHandle->isValid()) \
      mBuffers[]->set(shaderHandle, f); \
}

  1
  2//-----------------------------------------------------------------------------
  3// Copyright (c) 2012 GarageGames, LLC
  4//
  5// Permission is hereby granted, free of charge, to any person obtaining a copy
  6// of this software and associated documentation files (the "Software"), to
  7// deal in the Software without restriction, including without limitation the
  8// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  9// sell copies of the Software, and to permit persons to whom the Software is
 10// furnished to do so, subject to the following conditions:
 11//
 12// The above copyright notice and this permission notice shall be included in
 13// all copies or substantial portions of the Software.
 14//
 15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 21// IN THE SOFTWARE.
 22//-----------------------------------------------------------------------------
 23
 24#include "platform/platform.h"
 25#include "materials/shaderMaterialParameters.h"
 26
 27#include "console/console.h"
 28
 29//
 30// ShaderMaterialParameters
 31//
 32ShaderMaterialParameterHandle::ShaderMaterialParameterHandle(const String& name)
 33{
 34   VECTOR_SET_ASSOCIATION( mHandles );
 35
 36   mName = name;
 37}
 38
 39ShaderMaterialParameterHandle::ShaderMaterialParameterHandle(const String& name, Vector<GFXShader*>& shaders)
 40{
 41   VECTOR_SET_ASSOCIATION( mHandles );
 42
 43   mName = name;
 44   mHandles.setSize(shaders.size());
 45
 46   for (U32 i = 0; i < shaders.size(); i++)
 47      mHandles[i] = shaders[i]->getShaderConstHandle(name);
 48}
 49
 50ShaderMaterialParameterHandle::~ShaderMaterialParameterHandle()
 51{
 52}
 53
 54S32 ShaderMaterialParameterHandle::getSamplerRegister( U32 pass ) const
 55{
 56   AssertFatal( mHandles.size() > pass, "ShaderMaterialParameterHandle::getSamplerRegister - out of bounds" );   
 57   return mHandles[pass]->getSamplerRegister();
 58}
 59
 60//
 61// ShaderMaterialParameters
 62//
 63ShaderMaterialParameters::ShaderMaterialParameters()
 64: MaterialParameters()
 65{
 66   VECTOR_SET_ASSOCIATION( mBuffers );
 67}
 68
 69ShaderMaterialParameters::~ShaderMaterialParameters()
 70{
 71   releaseBuffers();   
 72}
 73
 74void ShaderMaterialParameters::setBuffers(Vector<GFXShaderConstDesc>& constDesc, Vector<GFXShaderConstBufferRef>& buffers)
 75{
 76   mShaderConstDesc = constDesc;
 77   mBuffers = buffers;
 78}
 79
 80void ShaderMaterialParameters::releaseBuffers()
 81{
 82   for (U32 i = 0; i < mBuffers.size(); i++)
 83   {
 84      mBuffers[i] = NULL;
 85   }
 86   mBuffers.setSize(0);
 87}
 88
 89U32 ShaderMaterialParameters::getAlignmentValue(const GFXShaderConstType constType)
 90{
 91   if (mBuffers.size() > 0)
 92      return mBuffers[0]->getShader()->getAlignmentValue(constType);
 93   else
 94      return 0;
 95}
 96
 97#define SHADERMATPARAM_SET(handle, f) \
 98   AssertFatal(handle, "Handle is NULL!" ); \
 99   AssertFatal(handle->isValid(), "Handle is not valid!" ); \
100   AssertFatal(dynamic_cast<ShaderMaterialParameterHandle*>(handle), "Invalid handle type!"); \
101   ShaderMaterialParameterHandle* h = static_cast<ShaderMaterialParameterHandle*>(handle); \
102   AssertFatal(h->mHandles.size() == mBuffers.size(), "Handle length differs from buffer length!"); \
103   for (U32 i = 0; i < h->mHandles.size(); i++) \
104{ \
105   GFXShaderConstHandle* shaderHandle = h->mHandles[i]; \
106   if (shaderHandle->isValid()) \
107      mBuffers[i]->set(shaderHandle, f); \
108} 
109
110void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const F32 f)
111{
112   SHADERMATPARAM_SET(handle, f);
113}
114
115void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const Point2F& fv)
116{
117   SHADERMATPARAM_SET(handle, fv);
118}
119
120void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const Point3F& fv)
121{
122   SHADERMATPARAM_SET(handle, fv);
123}
124
125void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const Point4F& fv)
126{
127   SHADERMATPARAM_SET(handle, fv);
128}
129
130void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const PlaneF& fv)
131{
132   SHADERMATPARAM_SET(handle, fv);
133}
134
135void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const LinearColorF& fv)
136{
137   SHADERMATPARAM_SET(handle, fv);
138}
139
140void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const S32 f)
141{
142   SHADERMATPARAM_SET(handle, f);
143}
144
145void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const Point2I& fv)
146{
147   SHADERMATPARAM_SET(handle, fv);
148}
149
150void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const Point3I& fv)
151{
152   SHADERMATPARAM_SET(handle, fv);
153}
154
155void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const Point4I& fv)
156{
157   SHADERMATPARAM_SET(handle, fv);
158}
159
160void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<F32>& fv)
161{
162   SHADERMATPARAM_SET(handle, fv);
163}
164
165void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<Point2F>& fv)
166{
167   SHADERMATPARAM_SET(handle, fv);
168}
169
170void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<Point3F>& fv)
171{
172   SHADERMATPARAM_SET(handle, fv);
173}
174
175void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<Point4F>& fv)
176{
177   SHADERMATPARAM_SET(handle, fv);
178}
179
180void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<S32>& fv)
181{
182   SHADERMATPARAM_SET(handle, fv);
183}
184
185void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<Point2I>& fv)
186{
187   SHADERMATPARAM_SET(handle, fv);
188}
189
190void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<Point3I>& fv)
191{
192   SHADERMATPARAM_SET(handle, fv);
193}
194
195void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const AlignedArray<Point4I>& fv)
196{
197   SHADERMATPARAM_SET(handle, fv);
198}
199
200void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const MatrixF& mat, const GFXShaderConstType matrixType)
201{
202   if ((!handle) || !handle->isValid())
203      return;
204   AssertFatal(dynamic_cast<ShaderMaterialParameterHandle*>(handle), "Invalid handle type!");
205   ShaderMaterialParameterHandle* h = static_cast<ShaderMaterialParameterHandle*>(handle);
206   AssertFatal(h->mHandles.size() == mBuffers.size(), "Handle length differs from buffer length!");
207   for (U32 i = 0; i < h->mHandles.size(); i++)
208   {
209      GFXShaderConstHandle* shaderHandle = h->mHandles[i];
210      if (shaderHandle && shaderHandle->isValid())
211         mBuffers[i]->set(shaderHandle, mat, matrixType);
212   } 
213}
214
215void ShaderMaterialParameters::set(MaterialParameterHandle* handle, const MatrixF* mat, const U32 arraySize, const GFXShaderConstType matrixType)
216{
217   if ((!handle) || !handle->isValid())
218      return;
219   AssertFatal(dynamic_cast<ShaderMaterialParameterHandle*>(handle), "Invalid handle type!");
220   ShaderMaterialParameterHandle* h = static_cast<ShaderMaterialParameterHandle*>(handle);
221   AssertFatal(h->mHandles.size() == mBuffers.size(), "Handle length differs from buffer length!");
222   for (U32 i = 0; i < h->mHandles.size(); i++)
223   {
224      GFXShaderConstHandle* shaderHandle = h->mHandles[i];
225      if (shaderHandle && shaderHandle->isValid())
226         mBuffers[i]->set(shaderHandle, mat, arraySize, matrixType);
227   } 
228}
229
230#undef SHADERMATPARAM_SET
231