Initial import from TransGaming
git-svn-id: https://angleproject.googlecode.com/svn/trunk@2 736b8ea6-26fd-11df-bfd4-992fa37f6226
diff --git a/Compiler/OutputHLSL.cpp b/Compiler/OutputHLSL.cpp
new file mode 100644
index 0000000..eaa1589
--- /dev/null
+++ b/Compiler/OutputHLSL.cpp
@@ -0,0 +1,1184 @@
+//
+// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#include "OutputHLSL.h"
+
+#include "InfoSink.h"
+#include "debug.h"
+
+namespace sh
+{
+OutputHLSL::OutputHLSL(TParseContext &context) : TIntermTraverser(true, true, true), context(context)
+{
+}
+
+void OutputHLSL::header()
+{
+ EShLanguage language = context.language;
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ if (language == EShLangFragment)
+ {
+ TString uniforms;
+ TString varyingInput;
+ TString varyingGlobals;
+
+ TSymbolTableLevel *symbols = context.symbolTable.getGlobalLevel();
+ int semanticIndex = 0;
+
+ for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
+ {
+ const TSymbol *symbol = (*namedSymbol).second;
+ const TString &name = symbol->getName();
+
+ if (symbol->isVariable())
+ {
+ const TVariable *variable = static_cast<const TVariable*>(symbol);
+ const TType &type = variable->getType();
+ TQualifier qualifier = type.getQualifier();
+
+ if (qualifier == EvqUniform)
+ {
+ uniforms += "uniform " + typeString(type) + " " + name + arrayString(type) + ";\n";
+ }
+ else if (qualifier == EvqVaryingIn || qualifier == EvqInvariantVaryingIn)
+ {
+ char semantic[100];
+ sprintf(semantic, " : TEXCOORD%d", semanticIndex);
+ semanticIndex += type.isArray() ? type.getArraySize() : 1;
+
+ varyingInput += " " + typeString(type) + " " + name + arrayString(type) + semantic + ";\n";
+ varyingGlobals += "static " + typeString(type) + " " + name + arrayString(type) + " = " + initializer(type) + ";\n";
+ }
+ }
+ }
+
+ out << uniforms;
+ out << "\n";
+ out << "struct PS_INPUT\n" // FIXME: Prevent name clashes
+ "{\n";
+ out << varyingInput;
+ out << "};\n"
+ "\n";
+ out << varyingGlobals;
+ out << "\n"
+ "struct PS_OUTPUT\n" // FIXME: Prevent name clashes
+ "{\n"
+ " float4 gl_Color[1] : COLOR;\n"
+ "};\n"
+ "\n"
+ "static float4 gl_Color[1] = {float4(0, 0, 0, 0)};\n"
+ "\n"
+ "float4 gl_texture2D(sampler2D s, float2 t)\n"
+ "{\n"
+ " return tex2D(s, t);\n"
+ "}\n"
+ "\n"
+ "float4 gl_texture2DProj(sampler2D s, float3 t)\n"
+ "{\n"
+ " return tex2Dproj(s, float4(t.x, t.y, 0, t.z));\n"
+ "}\n"
+ "float4 gl_texture2DBias(sampler2D s, float2 t, float bias)\n"
+ "{\n"
+ " return tex2Dbias(s, float4(t.x, t.y, 0, bias));\n"
+ "}\n"
+ "\n"
+ "float4 gl_textureCube(samplerCUBE s, float3 t)\n"
+ "{\n"
+ " return texCUBE(s, t);\n"
+ "}\n"
+ "\n";
+ }
+ else
+ {
+ TString uniforms;
+ TString attributeInput;
+ TString attributeGlobals;
+ TString varyingOutput;
+ TString varyingGlobals;
+ TString globals;
+
+ TSymbolTableLevel *symbols = context.symbolTable.getGlobalLevel();
+ int semanticIndex = 0;
+
+ for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
+ {
+ const TSymbol *symbol = (*namedSymbol).second;
+ const TString &name = symbol->getName();
+
+ if (symbol->isVariable())
+ {
+ const TVariable *variable = static_cast<const TVariable*>(symbol);
+ const TType &type = variable->getType();
+ TQualifier qualifier = type.getQualifier();
+
+ if (qualifier == EvqUniform)
+ {
+ uniforms += "uniform " + typeString(type) + " " + name + arrayString(type) + ";\n";
+ }
+ else if (qualifier == EvqAttribute)
+ {
+ char semantic[100];
+ sprintf(semantic, " : TEXCOORD%d", semanticIndex);
+ semanticIndex += type.isArray() ? type.getArraySize() : 1;
+
+ attributeInput += " " + typeString(type) + " " + name + arrayString(type) + semantic + ";\n";
+ attributeGlobals += "static " + typeString(type) + " " + name + arrayString(type) + " = " + initializer(type) + ";\n";
+ }
+ else if (qualifier == EvqVaryingOut || qualifier == EvqInvariantVaryingOut)
+ {
+ varyingOutput += " " + typeString(type) + " " + name + arrayString(type) + " : TEXCOORD0;\n"; // Actual semantic index assigned during link
+ varyingGlobals += "static " + typeString(type) + " " + name + arrayString(type) + " = " + initializer(type) + ";\n";
+ }
+ else if (qualifier == EvqGlobal)
+ {
+ globals += typeString(type) + " " + name + arrayString(type) + ";\n";
+ }
+ else UNREACHABLE();
+ }
+ }
+
+ out << "uniform float2 gl_HalfPixelSize;\n";
+ out << "\n";
+ out << uniforms;
+ out << "\n";
+ out << globals;
+ out << "\n";
+ out << "struct VS_INPUT\n" // FIXME: Prevent name clashes
+ "{\n";
+ out << attributeInput;
+ out << "};\n"
+ "\n";
+ out << attributeGlobals;
+ out << "\n"
+ "struct VS_OUTPUT\n" // FIXME: Prevent name clashes
+ "{\n"
+ " float4 gl_Position : POSITION;\n"
+ " float gl_PointSize : PSIZE;\n";
+ out << varyingOutput;
+ out << "};\n"
+ "\n"
+ "static float4 gl_Position = float4(0, 0, 0, 0);\n"
+ "static float gl_PointSize = float(0);\n";
+ out << varyingGlobals;
+ out << "\n";
+ }
+
+ out << "float vec1(float x)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return x;\n"
+ "}\n"
+ "\n"
+ "float vec1(float2 xy)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return xy[0];\n"
+ "}\n"
+ "\n"
+ "float vec1(float3 xyz)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return xyz[0];\n"
+ "}\n"
+ "\n"
+ "float vec1(float4 xyzw)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return xyzw[0];\n"
+ "}\n"
+ "\n"
+ "float2 vec2(float x)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float2(x, x);\n"
+ "}\n"
+ "\n"
+ "float2 vec2(float x, float y)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float2(x, y);\n"
+ "}\n"
+ "\n"
+ "float2 vec2(float2 xy)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return xy;\n"
+ "}\n"
+ "\n"
+ "float2 vec2(float3 xyz)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float2(xyz[0], xyz[1]);\n"
+ "}\n"
+ "\n"
+ "float2 vec2(float4 xyzw)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float2(xyzw[0], xyzw[1]);\n"
+ "}\n"
+ "\n"
+ "float3 vec3(float x)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float3(x, x, x);\n"
+ "}\n"
+ "\n"
+ "float3 vec3(float x, float y, float z)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float3(x, y, z);\n"
+ "}\n"
+ "\n"
+ "float3 vec3(float2 xy, float z)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float3(xy[0], xy[1], z);\n"
+ "}\n"
+ "\n"
+ "float3 vec3(float x, float2 yz)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float3(x, yz[0], yz[1]);\n"
+ "}\n"
+ "\n"
+ "float3 vec3(float3 xyz)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return xyz;\n"
+ "}\n"
+ "\n"
+ "float3 vec3(float4 xyzw)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float3(xyzw[0], xyzw[1], xyzw[2]);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float x)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(x, x, x, x);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float x, float y, float z, float w)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(x, y, z, w);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float2 xy, float z, float w)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(xy[0], xy[1], z, w);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float x, float2 yz, float w)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(x, yz[0], yz[1], w);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float x, float y, float2 zw)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(x, y, zw[0], zw[1]);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float2 xy, float2 zw)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(xy[0], xy[1], zw[0], zw[1]);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float3 xyz, float w)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(xyz[0], xyz[1], xyz[2], w);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float x, float3 yzw)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return float4(x, yzw[0], yzw[1], yzw[2]);\n"
+ "}\n"
+ "\n"
+ "float4 vec4(float4 xyzw)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return xyzw;\n"
+ "}\n"
+ "\n"
+ "bool xor(bool p, bool q)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return (p || q) && !(p && q);\n"
+ "}\n"
+ "\n"
+ "float mod(float x, float y)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return x - y * floor(x / y);\n"
+ "}\n"
+ "float2 mod(float2 x, float y)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return x - y * floor(x / y);\n"
+ "}\n"
+ "float3 mod(float3 x, float y)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return x - y * floor(x / y);\n"
+ "}\n"
+ "float4 mod(float4 x, float y)\n" // FIXME: Prevent name clashes
+ "{\n"
+ " return x - y * floor(x / y);\n"
+ "}\n"
+ "\n";
+}
+
+void OutputHLSL::visitSymbol(TIntermSymbol *node)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ TString name = node->getSymbol();
+
+ if (name == "gl_FragColor")
+ {
+ out << "gl_Color[0]";
+ }
+ else if (name == "gl_FragData")
+ {
+ out << "gl_Color";
+ }
+ else
+ {
+ out << name;
+ }
+}
+
+bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ switch (node->getOp())
+ {
+ case EOpAssign: outputTriplet(visit, "(", " = ", ")"); break;
+ case EOpInitialize: outputTriplet(visit, NULL, " = ", NULL); break;
+ case EOpAddAssign: outputTriplet(visit, NULL, " += ", NULL); break;
+ case EOpSubAssign: outputTriplet(visit, NULL, " -= ", NULL); break;
+ case EOpMulAssign: outputTriplet(visit, NULL, " *= ", NULL); break;
+ case EOpVectorTimesMatrixAssign: UNIMPLEMENTED(); /* FIXME */ out << "matrix mult second child into first child"; break;
+ case EOpVectorTimesScalarAssign: outputTriplet(visit, NULL, " *= ", NULL); break;
+ case EOpMatrixTimesScalarAssign: UNIMPLEMENTED(); /* FIXME */ out << "matrix scale second child into first child"; break;
+ case EOpMatrixTimesMatrixAssign: UNIMPLEMENTED(); /* FIXME */ out << "matrix mult second child into first child"; break;
+ case EOpDivAssign: outputTriplet(visit, NULL, " /= ", NULL); break;
+ case EOpModAssign: UNIMPLEMENTED(); /* FIXME */ out << "mod second child into first child"; break;
+ case EOpAndAssign: UNIMPLEMENTED(); /* FIXME */ out << "and second child into first child"; break;
+ case EOpInclusiveOrAssign: UNIMPLEMENTED(); /* FIXME */ out << "or second child into first child"; break;
+ case EOpExclusiveOrAssign: UNIMPLEMENTED(); /* FIXME */ out << "exclusive or second child into first child"; break;
+ case EOpLeftShiftAssign: UNIMPLEMENTED(); /* FIXME */ out << "left shift second child into first child"; break;
+ case EOpRightShiftAssign: UNIMPLEMENTED(); /* FIXME */ out << "right shift second child into first child"; break;
+ case EOpIndexDirect: outputTriplet(visit, NULL, "[", "]"); break;
+ case EOpIndexIndirect: outputTriplet(visit, NULL, "[", "]"); break;
+ case EOpIndexDirectStruct: UNIMPLEMENTED(); /* FIXME */ out << "direct index for structure"; break;
+ case EOpVectorSwizzle:
+ if (visit == InVisit)
+ {
+ out << ".";
+
+ TIntermAggregate *swizzle = node->getRight()->getAsAggregate();
+
+ if (swizzle)
+ {
+ TIntermSequence &sequence = swizzle->getSequence();
+
+ for (TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)
+ {
+ TIntermConstantUnion *element = (*sit)->getAsConstantUnion();
+
+ if (element)
+ {
+ int i = element->getUnionArrayPointer()[0].getIConst();
+
+ switch (i)
+ {
+ case 0: out << "x"; break;
+ case 1: out << "y"; break;
+ case 2: out << "z"; break;
+ case 3: out << "w"; break;
+ default: UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+ }
+ }
+ else UNREACHABLE();
+
+ return false; // Fully processed
+ }
+ break;
+ case EOpAdd: outputTriplet(visit, "(", " + ", ")"); break;
+ case EOpSub: outputTriplet(visit, "(", " - ", ")"); break;
+ case EOpMul: outputTriplet(visit, "(", " * ", ")"); break;
+ case EOpDiv: outputTriplet(visit, "(", " / ", ")"); break;
+ case EOpMod: UNIMPLEMENTED(); /* FIXME */ out << "mod"; break;
+ case EOpRightShift: UNIMPLEMENTED(); /* FIXME */ out << "right-shift"; break;
+ case EOpLeftShift: UNIMPLEMENTED(); /* FIXME */ out << "left-shift"; break;
+ case EOpAnd: UNIMPLEMENTED(); /* FIXME */ out << "bitwise and"; break;
+ case EOpInclusiveOr: UNIMPLEMENTED(); /* FIXME */ out << "inclusive-or"; break;
+ case EOpExclusiveOr: UNIMPLEMENTED(); /* FIXME */ out << "exclusive-or"; break;
+ case EOpEqual: outputTriplet(visit, "(", " == ", ")"); break;
+ case EOpNotEqual: outputTriplet(visit, "(", " != ", ")"); break;
+ case EOpLessThan: outputTriplet(visit, "(", " < ", ")"); break;
+ case EOpGreaterThan: outputTriplet(visit, "(", " > ", ")"); break;
+ case EOpLessThanEqual: outputTriplet(visit, "(", " <= ", ")"); break;
+ case EOpGreaterThanEqual: outputTriplet(visit, "(", " >= ", ")"); break;
+ case EOpVectorTimesScalar: outputTriplet(visit, "(", " * ", ")"); break;
+ case EOpVectorTimesMatrix: UNIMPLEMENTED(); /* FIXME */ out << "vector-times-matrix"; break;
+ case EOpMatrixTimesVector: outputTriplet(visit, "mul(", ", ", ")"); break;
+ case EOpMatrixTimesScalar: UNIMPLEMENTED(); /* FIXME */ out << "matrix-scale"; break;
+ case EOpMatrixTimesMatrix: UNIMPLEMENTED(); /* FIXME */ out << "matrix-multiply"; break;
+ case EOpLogicalOr: outputTriplet(visit, "(", " || ", ")"); break;
+ case EOpLogicalXor: outputTriplet(visit, "xor(", ", ", ")"); break; // FIXME: Prevent name clashes
+ case EOpLogicalAnd: outputTriplet(visit, "(", " && ", ")"); break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+}
+
+bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ switch (node->getOp())
+ {
+ case EOpNegative: outputTriplet(visit, "(-", NULL, ")"); break;
+ case EOpVectorLogicalNot: outputTriplet(visit, "(!", NULL, ")"); break;
+ case EOpLogicalNot: outputTriplet(visit, "(!", NULL, ")"); break;
+ case EOpBitwiseNot: outputTriplet(visit, "(~", NULL, ")"); break;
+ case EOpPostIncrement: outputTriplet(visit, "(", NULL, "++)"); break;
+ case EOpPostDecrement: outputTriplet(visit, "(", NULL, "--)"); break;
+ case EOpPreIncrement: outputTriplet(visit, "(++", NULL, ")"); break;
+ case EOpPreDecrement: outputTriplet(visit, "(--", NULL, ")"); break;
+ case EOpConvIntToBool:
+ case EOpConvFloatToBool:
+ switch (node->getOperand()->getType().getNominalSize())
+ {
+ case 1: outputTriplet(visit, "bool(", NULL, ")"); break;
+ case 2: outputTriplet(visit, "bool2(", NULL, ")"); break;
+ case 3: outputTriplet(visit, "bool3(", NULL, ")"); break;
+ case 4: outputTriplet(visit, "bool4(", NULL, ")"); break;
+ default: UNREACHABLE();
+ }
+ break;
+ case EOpConvBoolToFloat:
+ case EOpConvIntToFloat:
+ switch (node->getOperand()->getType().getNominalSize())
+ {
+ case 1: outputTriplet(visit, "float(", NULL, ")"); break;
+ case 2: outputTriplet(visit, "float2(", NULL, ")"); break;
+ case 3: outputTriplet(visit, "float3(", NULL, ")"); break;
+ case 4: outputTriplet(visit, "float4(", NULL, ")"); break;
+ default: UNREACHABLE();
+ }
+ break;
+ case EOpConvFloatToInt:
+ case EOpConvBoolToInt:
+ switch (node->getOperand()->getType().getNominalSize())
+ {
+ case 1: outputTriplet(visit, "int(", NULL, ")"); break;
+ case 2: outputTriplet(visit, "int2(", NULL, ")"); break;
+ case 3: outputTriplet(visit, "int3(", NULL, ")"); break;
+ case 4: outputTriplet(visit, "int4(", NULL, ")"); break;
+ default: UNREACHABLE();
+ }
+ break;
+ case EOpRadians: outputTriplet(visit, "radians(", NULL, ")"); break;
+ case EOpDegrees: outputTriplet(visit, "degrees(", NULL, ")"); break;
+ case EOpSin: outputTriplet(visit, "sin(", NULL, ")"); break;
+ case EOpCos: outputTriplet(visit, "cos(", NULL, ")"); break;
+ case EOpTan: outputTriplet(visit, "tan(", NULL, ")"); break;
+ case EOpAsin: outputTriplet(visit, "asin(", NULL, ")"); break;
+ case EOpAcos: outputTriplet(visit, "acos(", NULL, ")"); break;
+ case EOpAtan: outputTriplet(visit, "atan(", NULL, ")"); break;
+ case EOpExp: outputTriplet(visit, "exp(", NULL, ")"); break;
+ case EOpLog: outputTriplet(visit, "log(", NULL, ")"); break;
+ case EOpExp2: outputTriplet(visit, "exp2(", NULL, ")"); break;
+ case EOpLog2: outputTriplet(visit, "log2(", NULL, ")"); break;
+ case EOpSqrt: outputTriplet(visit, "sqrt(", NULL, ")"); break;
+ case EOpInverseSqrt: outputTriplet(visit, "rsqrt(", NULL, ")"); break;
+ case EOpAbs: outputTriplet(visit, "abs(", NULL, ")"); break;
+ case EOpSign: outputTriplet(visit, "sign(", NULL, ")"); break;
+ case EOpFloor: outputTriplet(visit, "floor(", NULL, ")"); break;
+ case EOpCeil: outputTriplet(visit, "ceil(", NULL, ")"); break;
+ case EOpFract: outputTriplet(visit, "frac(", NULL, ")"); break;
+ case EOpLength: outputTriplet(visit, "length(", NULL, ")"); break;
+ case EOpNormalize: outputTriplet(visit, "normalize(", NULL, ")"); break;
+// case EOpDPdx: outputTriplet(visit, "ddx(", NULL, ")"); break;
+// case EOpDPdy: outputTriplet(visit, "ddy(", NULL, ")"); break;
+// case EOpFwidth: outputTriplet(visit, "fwidth(", NULL, ")"); break;
+ case EOpAny: outputTriplet(visit, "any(", NULL, ")"); break;
+ case EOpAll: outputTriplet(visit, "all(", NULL, ")"); break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+}
+
+bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
+{
+ EShLanguage language = context.language;
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ if (node->getOp() == EOpNull)
+ {
+ out.message(EPrefixError, "node is still EOpNull!");
+ return true;
+ }
+
+ switch (node->getOp())
+ {
+ case EOpSequence: outputTriplet(visit, NULL, ";\n", ";\n"); break;
+ case EOpDeclaration:
+ if (visit == PreVisit)
+ {
+ TIntermSequence &sequence = node->getSequence();
+ TIntermTyped *variable = sequence[0]->getAsTyped();
+ bool visit = true;
+
+ if (variable && variable->getQualifier() == EvqTemporary)
+ {
+ out << typeString(variable->getType()) + " ";
+
+ for (TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)
+ {
+ TIntermSymbol *symbol = (*sit)->getAsSymbolNode();
+
+ if (symbol)
+ {
+ symbol->traverse(this);
+
+ out << arrayString(symbol->getType());
+ }
+ else
+ {
+ (*sit)->traverse(this);
+ }
+
+ if (visit && this->inVisit)
+ {
+ if (*sit != sequence.back())
+ {
+ visit = this->visitAggregate(InVisit, node);
+ }
+ }
+ }
+
+ if (visit && this->postVisit)
+ {
+ this->visitAggregate(PostVisit, node);
+ }
+ }
+
+ return false;
+ }
+ else if (visit == InVisit)
+ {
+ out << ", ";
+ }
+ break;
+ case EOpComma: UNIMPLEMENTED(); /* FIXME */ out << "Comma\n"; return true;
+ case EOpFunction:
+ {
+ const TString &mangledName = node->getName();
+ TString name = TString(mangledName.c_str(), mangledName.find_first_of('('));
+
+ if (visit == PreVisit)
+ {
+ if (name == "main")
+ {
+ TSymbolTableLevel *symbols = context.symbolTable.getGlobalLevel();
+
+ if (language == EShLangFragment)
+ {
+ out << "PS_OUTPUT main(PS_INPUT input)\n" // FIXME: Prevent name clashes
+ "{\n";
+
+ for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
+ {
+ const TSymbol *symbol = (*namedSymbol).second;
+ const TString &name = symbol->getName();
+
+ if (symbol->isVariable())
+ {
+ const TVariable *variable = static_cast<const TVariable*>(symbol);
+ const TType &type = variable->getType();
+ TQualifier qualifier = type.getQualifier();
+
+ if(qualifier == EvqVaryingIn)
+ {
+ out << " " + name + " = input." + name + ";\n"; // FIXME: Prevent name clashes
+ }
+ }
+ }
+ }
+ else
+ {
+ out << "VS_OUTPUT main(VS_INPUT input)\n" // FIXME: Prevent name clashes
+ "{\n";
+
+ for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
+ {
+ const TSymbol *symbol = (*namedSymbol).second;
+ const TString &name = symbol->getName();
+
+ if (symbol->isVariable())
+ {
+ const TVariable *variable = static_cast<const TVariable*>(symbol);
+ const TType &type = variable->getType();
+ TQualifier qualifier = type.getQualifier();
+
+ if (qualifier == EvqAttribute)
+ {
+ out << " " + name + " = input." + name + ";\n"; // FIXME: Prevent name clashes
+ }
+ }
+ }
+ }
+
+ // Erase the (empty) argument list
+ TIntermSequence &sequence = node->getSequence();
+ sequence.erase(sequence.begin());
+ }
+ else
+ {
+ out << typeString(node->getType()) << " " << name << "(";
+
+ TIntermSequence &sequence = node->getSequence();
+ TIntermSequence &arguments = sequence[0]->getAsAggregate()->getSequence();
+
+ for (unsigned int i = 0; i < arguments.size(); i++)
+ {
+ TIntermSymbol *symbol = arguments[i]->getAsSymbolNode();
+
+ if (symbol)
+ {
+ const TType &type = symbol->getType();
+ const TString &name = symbol->getSymbol();
+
+ out << typeString(type) + " " + name;
+
+ if(i < arguments.size() - 1)
+ {
+ out << ", ";
+ }
+ }
+ else UNREACHABLE();
+ }
+
+ sequence.erase(sequence.begin());
+
+ out << ")\n"
+ "{\n";
+ }
+ }
+ else if (visit == PostVisit)
+ {
+ if (name == "main")
+ {
+ if (language == EShLangFragment)
+ {
+ out << " PS_OUTPUT output;\n" // FIXME: Prevent name clashes
+ " output.gl_Color[0] = gl_Color[0];\n"; // FIXME: Prevent name clashes
+
+ TSymbolTableLevel *symbols = context.symbolTable.getGlobalLevel();
+
+ for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
+ {
+ const TSymbol *symbol = (*namedSymbol).second;
+ const TString &name = symbol->getName();
+ }
+ }
+ else
+ {
+ out << " VS_OUTPUT output;\n" // FIXME: Prevent name clashes
+ " output.gl_Position.x = gl_Position.x - gl_HalfPixelSize.x * gl_Position.w;\n"
+ " output.gl_Position.y = -(gl_Position.y - gl_HalfPixelSize.y * gl_Position.w);\n"
+ " output.gl_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n"
+ " output.gl_Position.w = gl_Position.w;\n"
+ " output.gl_PointSize = gl_PointSize;\n";
+
+ TSymbolTableLevel *symbols = context.symbolTable.getGlobalLevel();
+
+ for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++)
+ {
+ const TSymbol *symbol = (*namedSymbol).second;
+ const TString &name = symbol->getName();
+
+ if (symbol->isVariable())
+ {
+ const TVariable *variable = static_cast<const TVariable*>(symbol);
+ TQualifier qualifier = variable->getType().getQualifier();
+
+ if(qualifier == EvqVaryingOut || qualifier == EvqInvariantVaryingOut)
+ {
+ out << " output." + name + " = " + name + ";\n"; // FIXME: Prevent name clashes
+ }
+ }
+ }
+ }
+
+ out << " return output;\n" // FIXME: Prevent name clashes
+ "}\n";
+ }
+ else
+ {
+ out << "}\n";
+ }
+ }
+ }
+ break;
+ case EOpFunctionCall:
+ {
+ if (visit == PreVisit)
+ {
+ const TString &mangledName = node->getName();
+ TString name = TString(mangledName.c_str(), mangledName.find_first_of('('));
+
+ if (node->isUserDefined())
+ {
+ out << name << "(";
+ }
+ else
+ {
+ if (name == "texture2D")
+ {
+ if (node->getSequence().size() == 2)
+ {
+ out << "gl_texture2D(";
+ }
+ else if (node->getSequence().size() == 3)
+ {
+ out << "gl_texture2DBias(";
+ }
+ else UNREACHABLE();
+ }
+ else if (name == "texture2DProj")
+ {
+ out << "gl_texture2DProj(";
+ }
+ else if (name == "texture2DLod")
+ {
+ out << "gl_texture2DLod(";
+ UNIMPLEMENTED(); // FIXME: Move lod to last texture coordinate component
+ }
+ else if (name == "texture2DProjLod")
+ {
+ out << "gl_texture2DProjLod(";
+ UNIMPLEMENTED(); // FIXME: Move lod to last texture coordinate component
+ }
+ else if (name == "textureCube")
+ {
+ out << "gl_textureCube("; // FIXME: Incorrect sampling location
+ }
+ else
+ {
+ UNIMPLEMENTED(); // FIXME
+ }
+ }
+ }
+ else if (visit == InVisit)
+ {
+ out << ", ";
+ }
+ else
+ {
+ out << ")";
+ }
+ }
+ break;
+ case EOpParameters: outputTriplet(visit, "(", ", ", ")\n{\n"); break;
+ case EOpConstructFloat: outputTriplet(visit, "vec1(", NULL, ")"); break;
+ case EOpConstructVec2: outputTriplet(visit, "vec2(", ", ", ")"); break;
+ case EOpConstructVec3: outputTriplet(visit, "vec3(", ", ", ")"); break;
+ case EOpConstructVec4: outputTriplet(visit, "vec4(", ", ", ")"); break;
+ case EOpConstructBool: UNIMPLEMENTED(); /* FIXME */ out << "Construct bool"; break;
+ case EOpConstructBVec2: UNIMPLEMENTED(); /* FIXME */ out << "Construct bvec2"; break;
+ case EOpConstructBVec3: UNIMPLEMENTED(); /* FIXME */ out << "Construct bvec3"; break;
+ case EOpConstructBVec4: UNIMPLEMENTED(); /* FIXME */ out << "Construct bvec4"; break;
+ case EOpConstructInt: UNIMPLEMENTED(); /* FIXME */ out << "Construct int"; break;
+ case EOpConstructIVec2: UNIMPLEMENTED(); /* FIXME */ out << "Construct ivec2"; break;
+ case EOpConstructIVec3: UNIMPLEMENTED(); /* FIXME */ out << "Construct ivec3"; break;
+ case EOpConstructIVec4: UNIMPLEMENTED(); /* FIXME */ out << "Construct ivec4"; break;
+ case EOpConstructMat2: outputTriplet(visit, "float2x2(", ", ", ")"); break;
+ case EOpConstructMat3: outputTriplet(visit, "float3x3(", ", ", ")"); break;
+ case EOpConstructMat4: UNIMPLEMENTED(); /* FIXME */ out << "Construct mat4"; break;
+ case EOpConstructStruct: UNIMPLEMENTED(); /* FIXME */ out << "Construct structure"; break;
+ case EOpLessThan: outputTriplet(visit, "(", " < ", ")"); break;
+ case EOpGreaterThan: outputTriplet(visit, "(", " > ", ")"); break;
+ case EOpLessThanEqual: outputTriplet(visit, "(", " <= ", ")"); break;
+ case EOpGreaterThanEqual: outputTriplet(visit, "(", " >= ", ")"); break;
+ case EOpVectorEqual: outputTriplet(visit, "(", " == ", ")"); break;
+ case EOpVectorNotEqual: outputTriplet(visit, "(", " != ", ")"); break;
+ case EOpMod: outputTriplet(visit, "mod(", ", ", ")"); break; // FIXME: Prevent name clashes
+ case EOpPow: outputTriplet(visit, "pow(", ", ", ")"); break;
+ case EOpAtan:
+ if (node->getSequence().size() == 1)
+ {
+ outputTriplet(visit, "atan(", ", ", ")");
+ }
+ else if (node->getSequence().size() == 2)
+ {
+ outputTriplet(visit, "atan2(", ", ", ")");
+ }
+ else UNREACHABLE();
+ break;
+ case EOpMin: outputTriplet(visit, "min(", ", ", ")"); break;
+ case EOpMax: outputTriplet(visit, "max(", ", ", ")"); break;
+ case EOpClamp: outputTriplet(visit, "clamp(", ", ", ")"); break;
+ case EOpMix: outputTriplet(visit, "lerp(", ", ", ")"); break;
+ case EOpStep: outputTriplet(visit, "step(", ", ", ")"); break;
+ case EOpSmoothStep: outputTriplet(visit, "smoothstep(", ", ", ")"); break;
+ case EOpDistance: outputTriplet(visit, "distance(", ", ", ")"); break;
+ case EOpDot: outputTriplet(visit, "dot(", ", ", ")"); break;
+ case EOpCross: outputTriplet(visit, "cross(", ", ", ")"); break;
+ case EOpFaceForward: UNIMPLEMENTED(); /* FIXME */ out << "face-forward"; break;
+ case EOpReflect: outputTriplet(visit, "reflect(", ", ", ")"); break;
+ case EOpRefract: outputTriplet(visit, "refract(", ", ", ")"); break;
+ case EOpMul: outputTriplet(visit, "(", " * ", ")"); break;
+ case EOpItof: UNIMPLEMENTED(); /* FIXME */ out << "itof"; break;
+ case EOpFtoi: UNIMPLEMENTED(); /* FIXME */ out << "ftoi"; break;
+ case EOpSkipPixels: UNIMPLEMENTED(); /* FIXME */ out << "skipPixels"; break;
+ case EOpReadInput: UNIMPLEMENTED(); /* FIXME */ out << "readInput"; break;
+ case EOpWritePixel: UNIMPLEMENTED(); /* FIXME */ out << "writePixel"; break;
+ case EOpBitmapLsb: UNIMPLEMENTED(); /* FIXME */ out << "bitmapLSB"; break;
+ case EOpBitmapMsb: UNIMPLEMENTED(); /* FIXME */ out << "bitmapMSB"; break;
+ case EOpWriteOutput: UNIMPLEMENTED(); /* FIXME */ out << "writeOutput"; break;
+ case EOpReadPixel: UNIMPLEMENTED(); /* FIXME */ out << "readPixel"; break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+}
+
+bool OutputHLSL::visitSelection(Visit visit, TIntermSelection *node)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ out << "if(";
+
+ node->getCondition()->traverse(this);
+
+ out << ")\n"
+ "{\n";
+
+ node->getTrueBlock()->traverse(this);
+
+ out << ";}\n";
+
+ if (node->getFalseBlock())
+ {
+ out << "else\n"
+ "{\n";
+
+ node->getFalseBlock()->traverse(this);
+
+ out << ";}\n";
+ }
+
+ return false;
+}
+
+void OutputHLSL::visitConstantUnion(TIntermConstantUnion *node)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ int size = node->getType().getObjectSize();
+ bool matrix = node->getType().isMatrix();
+ TBasicType type = node->getUnionArrayPointer()[0].getType();
+
+ switch (type)
+ {
+ case EbtBool:
+ if (!matrix)
+ {
+ switch (size)
+ {
+ case 1: out << "bool("; break;
+ case 2: out << "bool2("; break;
+ case 3: out << "bool3("; break;
+ case 4: out << "bool4("; break;
+ default: UNREACHABLE();
+ }
+ }
+ else
+ {
+ UNIMPLEMENTED();
+ }
+ break;
+ case EbtFloat:
+ if (!matrix)
+ {
+ switch (size)
+ {
+ case 1: out << "float("; break;
+ case 2: out << "float2("; break;
+ case 3: out << "float3("; break;
+ case 4: out << "float4("; break;
+ default: UNREACHABLE();
+ }
+ }
+ else
+ {
+ switch (size)
+ {
+ case 4: out << "float2x2("; break;
+ case 9: out << "float3x3("; break;
+ case 16: out << "float4x4("; break;
+ default: UNREACHABLE();
+ }
+ }
+ break;
+ case EbtInt:
+ if (!matrix)
+ {
+ switch (size)
+ {
+ case 1: out << "int("; break;
+ case 2: out << "int2("; break;
+ case 3: out << "int3("; break;
+ case 4: out << "int4("; break;
+ default: UNREACHABLE();
+ }
+ }
+ else
+ {
+ UNIMPLEMENTED();
+ }
+ break;
+ default:
+ UNIMPLEMENTED(); // FIXME
+ }
+
+ for (int i = 0; i < size; i++)
+ {
+ switch (type)
+ {
+ case EbtBool:
+ if (node->getUnionArrayPointer()[i].getBConst())
+ {
+ out << "true";
+ }
+ else
+ {
+ out << "false";
+ }
+ break;
+ case EbtFloat:
+ out << node->getUnionArrayPointer()[i].getFConst();
+ break;
+ case EbtInt:
+ out << node->getUnionArrayPointer()[i].getIConst();
+ break;
+ default:
+ UNIMPLEMENTED(); // FIXME
+ }
+
+ if (i != size - 1)
+ {
+ out << ", ";
+ }
+ }
+
+ out << ")";
+}
+
+bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ if (!node->testFirst())
+ {
+ out << "do\n"
+ "{\n";
+ }
+ else
+ {
+ out << "for(";
+
+ if (node->getInit())
+ {
+ node->getInit()->traverse(this);
+ }
+
+ out << "; ";
+
+ if (node->getTest())
+ {
+ node->getTest()->traverse(this);
+ }
+
+ out << "; ";
+
+ if (node->getTerminal())
+ {
+ node->getTerminal()->traverse(this);
+ }
+
+ out << ")\n"
+ "{\n";
+ }
+
+ if (node->getBody())
+ {
+ node->getBody()->traverse(this);
+ }
+
+ out << "}\n";
+
+ if (!node->testFirst())
+ {
+ out << "while(\n";
+
+ node->getTest()->traverse(this);
+
+ out << ")";
+ }
+
+ out << ";\n";
+
+ return false;
+}
+
+bool OutputHLSL::visitBranch(Visit visit, TIntermBranch *node)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ switch (node->getFlowOp())
+ {
+ case EOpKill: outputTriplet(visit, "discard", NULL, NULL); break;
+ case EOpBreak: UNIMPLEMENTED(); /* FIXME */ break;
+ case EOpContinue: UNIMPLEMENTED(); /* FIXME */ break;
+ case EOpReturn:
+ if (visit == PreVisit)
+ {
+ if (node->getExpression())
+ {
+ out << "return ";
+ }
+ else
+ {
+ out << "return;\n";
+ }
+ }
+ else if (visit == PostVisit)
+ {
+ out << ";\n";
+ }
+ break;
+ default: UNREACHABLE();
+ }
+
+ return true;
+}
+
+void OutputHLSL::outputTriplet(Visit visit, const char *preString, const char *inString, const char *postString)
+{
+ TInfoSinkBase &out = context.infoSink.obj;
+
+ if (visit == PreVisit && preString)
+ {
+ out << preString;
+ }
+ else if (visit == InVisit && inString)
+ {
+ out << inString;
+ }
+ else if (visit == PostVisit && postString)
+ {
+ out << postString;
+ }
+}
+
+TString OutputHLSL::typeString(const TType &type)
+{
+ if (type.isMatrix())
+ {
+ switch (type.getNominalSize())
+ {
+ case 2: return "float2x2";
+ case 3: return "float3x3";
+ case 4: return "float4x4";
+ }
+ }
+ else
+ {
+ switch (type.getBasicType())
+ {
+ case EbtFloat:
+ switch (type.getNominalSize())
+ {
+ case 1: return "float";
+ case 2: return "float2";
+ case 3: return "float3";
+ case 4: return "float4";
+ }
+ case EbtInt:
+ switch (type.getNominalSize())
+ {
+ case 1: return "int";
+ case 2: return "int2";
+ case 3: return "int3";
+ case 4: return "int4";
+ }
+ case EbtBool:
+ switch (type.getNominalSize())
+ {
+ case 1: return "bool";
+ case 2: return "bool2";
+ case 3: return "bool3";
+ case 4: return "bool4";
+ }
+ case EbtVoid:
+ return "void";
+ case EbtSampler2D:
+ return "sampler2D";
+ case EbtSamplerCube:
+ return "samplerCUBE";
+ }
+ }
+
+ UNIMPLEMENTED(); // FIXME
+ return "<unknown type>";
+}
+
+TString OutputHLSL::arrayString(const TType &type)
+{
+ if (!type.isArray())
+ {
+ return "";
+ }
+
+ char buffer[100];
+ sprintf(buffer, "[%d]", type.getArraySize());
+
+ return buffer;
+}
+
+TString OutputHLSL::initializer(const TType &type)
+{
+ TString string;
+
+ int arraySize = type.isArray() ? type.getArraySize() : 1;
+
+ if (type.isArray())
+ {
+ string += "{";
+ }
+
+ for (int element = 0; element < arraySize; element++)
+ {
+ string += typeString(type) + "(";
+
+ for (int component = 0; component < type.getNominalSize(); component++)
+ {
+ string += "0";
+
+ if (component < type.getNominalSize() - 1)
+ {
+ string += ", ";
+ }
+ }
+
+ string += ")";
+
+ if (element < arraySize - 1)
+ {
+ string += ", ";
+ }
+ }
+
+ if (type.isArray())
+ {
+ string += "}";
+ }
+
+ return string;
+}
+}