shaderGenHLSL.cpp

Engine/source/shaderGen/HLSL/shaderGenHLSL.cpp

More...

Detailed Description

  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 "shaderGen/HLSL/shaderGenHLSL.h"
 26
 27#include "shaderGen/HLSL/shaderCompHLSL.h"
 28#include "shaderGen/featureMgr.h"
 29
 30
 31void ShaderGenPrinterHLSL::printShaderHeader(Stream& stream)
 32{
 33   const char *header1 = "//*****************************************************************************\r\n";
 34   const char *header2 = "// Torque -- HLSL procedural shader\r\n";
 35
 36   stream.write( dStrlen(header1), header1 );
 37   stream.write( dStrlen(header2), header2 );
 38   stream.write( dStrlen(header1), header1 );
 39
 40   const char* header3 = "\r\n";      
 41   stream.write( dStrlen(header3), header3 );
 42}
 43
 44void ShaderGenPrinterHLSL::printMainComment(Stream& stream)
 45{
 46   const char * header5 = "// Main\r\n";
 47   const char * line    = "//-----------------------------------------------------------------------------\r\n";
 48
 49   stream.write( dStrlen(line), line );
 50   stream.write( dStrlen(header5), header5 );
 51   stream.write( dStrlen(line), line );
 52}
 53
 54void ShaderGenPrinterHLSL::printVertexShaderCloser(Stream& stream)
 55{
 56   const char *closer = "   return OUT;\r\n}\r\n";
 57   stream.write( dStrlen(closer), closer );
 58}
 59
 60void ShaderGenPrinterHLSL::printPixelShaderOutputStruct(Stream& stream, const MaterialFeatureData &featureData)
 61{
 62   // Determine the number of output targets we need
 63   U32 numMRTs = 0;
 64   for( U32 i = 0; i < FEATUREMGR->getFeatureCount(); i++ )
 65   {
 66      const FeatureInfo &info = FEATUREMGR->getAt( i );
 67      if ( featureData.features.hasFeature( *info.type ) )
 68         numMRTs |= info.feature->getOutputTargets( featureData );
 69   }
 70
 71   WRITESTR("struct Fragout\r\n");
 72   WRITESTR("{\r\n");
 73
 74   WRITESTR("   float4 col : SV_Target0;\r\n");
 75   for (U32 i = 1; i < 4; i++)
 76   {
 77      if (numMRTs & 1 << i)
 78         WRITESTR(avar("   float4 col%d : SV_Target%d;\r\n", i, i));
 79   }
 80   
 81   WRITESTR("};\r\n");
 82   WRITESTR("\r\n");
 83   WRITESTR("\r\n");
 84}
 85
 86void ShaderGenPrinterHLSL::printPixelShaderCloser(Stream& stream)
 87{
 88   WRITESTR( "\r\n   return OUT;\r\n}\r\n" );
 89}
 90
 91void ShaderGenPrinterHLSL::printLine(Stream& stream, const String& line)
 92{
 93   stream.write(line.length(), line.c_str());
 94   const char* end = "\r\n";
 95   stream.write(dStrlen(end), end);
 96}
 97
 98const char* ShaderGenComponentFactoryHLSL::typeToString( GFXDeclType type )
 99{
100   switch ( type )
101   {
102      default:
103      case GFXDeclType_Float:
104         return "float";
105
106      case GFXDeclType_Float2:
107         return "float2";
108
109      case GFXDeclType_Float3:
110         return "float3";
111
112      case GFXDeclType_Float4:
113      case GFXDeclType_Color:
114         return "float4";
115      
116     case GFXDeclType_UByte4:
117         return "uint4";
118   }
119}
120
121ShaderComponent* ShaderGenComponentFactoryHLSL::createVertexInputConnector( const GFXVertexFormat &vertexFormat )
122{
123   ShaderConnectorHLSL *vertComp = new ShaderConnectorHLSL;
124   vertComp->setName( "VertData" );
125
126   // Loop thru the vertex format elements.
127   for ( U32 i=0; i < vertexFormat.getElementCount(); i++ )
128   {
129      const GFXVertexElement &element = vertexFormat.getElement( i );
130      
131      Var *var = NULL;
132
133      if ( element.isSemantic( GFXSemantic::POSITION ) )
134      {
135         var = vertComp->getElement( RT_POSITION );
136         var->setName( "position" );
137      }
138      else if ( element.isSemantic( GFXSemantic::NORMAL ) )
139      {
140         var = vertComp->getElement( RT_NORMAL );
141         var->setName( "normal" );
142      }
143      else if ( element.isSemantic( GFXSemantic::TANGENT ) )
144      {
145         var = vertComp->getElement( RT_TANGENT );
146         var->setName( "T" );
147      }
148      else if ( element.isSemantic( GFXSemantic::TANGENTW ) )
149      {
150         var = vertComp->getIndexedElement(element.getSemanticIndex(), RT_TEXCOORD);
151         var->setName("tangentW");
152      }
153      else if ( element.isSemantic( GFXSemantic::BINORMAL ) )
154      {
155         var = vertComp->getElement( RT_BINORMAL );
156         var->setName( "B" );
157      }
158      else if ( element.isSemantic( GFXSemantic::COLOR ) )
159      {
160         var = vertComp->getElement( RT_COLOR );
161         var->setName( "diffuse" );
162      }
163      else if ( element.isSemantic( GFXSemantic::TEXCOORD ) )
164      {
165         var = vertComp->getIndexedElement( element.getSemanticIndex(), RT_TEXCOORD );
166         if ( element.getSemanticIndex() == 0 )
167            var->setName( "texCoord" );
168         else
169            var->setName( String::ToString( "texCoord%d", element.getSemanticIndex() + 1 ) );
170      }
171      else if ( element.isSemantic( GFXSemantic::BLENDINDICES ) )
172      {
173         var = vertComp->getIndexedElement( element.getSemanticIndex(), RT_BLENDINDICES );
174         var->setName( String::ToString( "blendIndices%d", element.getSemanticIndex() ) );
175      }
176      else if ( element.isSemantic( GFXSemantic::BLENDWEIGHT ) )
177      {
178         var = vertComp->getIndexedElement( element.getSemanticIndex(), RT_BLENDWEIGHT );
179         var->setName( String::ToString( "blendWeight%d", element.getSemanticIndex() ) );
180      }
181      else if ( element.isSemantic( GFXSemantic::PADDING ) )
182      {
183         var = NULL;
184         //var = vertComp->getIndexedElement( vertComp->getCurTexElem() + element.getSemanticIndex(), RT_TEXCOORD );
185         //var->setName( String::ToString( "pad%d", element.getSemanticIndex() + 1 ) );
186      }
187      else
188      {
189         // Everything else is a texcoord!
190         var = vertComp->getIndexedElement( element.getSemanticIndex(), RT_TEXCOORD );
191         var->setName( "tc" + element.getSemantic() );
192      }
193
194      if ( !var )
195         continue;
196
197      var->setStructName( "IN" );
198      var->setType( typeToString( element.getType() ) );
199   }
200
201   return vertComp;
202}
203
204ShaderComponent* ShaderGenComponentFactoryHLSL::createVertexPixelConnector()
205{
206   ShaderComponent* comp = new ShaderConnectorHLSL;
207   ((ShaderConnector*)comp)->setName("ConnectData");
208   return comp;
209}
210
211ShaderComponent* ShaderGenComponentFactoryHLSL::createVertexParamsDef()
212{
213   ShaderComponent* comp = new VertexParamsDefHLSL;
214   return comp;
215}
216
217ShaderComponent* ShaderGenComponentFactoryHLSL::createPixelParamsDef()
218{
219   ShaderComponent* comp = new PixelParamsDefHLSL;
220   return comp;
221}
222