public UniformParameter(GpuProgramParameters.AutoConstantType autoConstantType, Real autoConstantData, int size, GpuProgramParameters.GpuConstantType type) : base( Parameter.AutoParameters[autoConstantType].Type, Parameter.AutoParameters[autoConstantType].Name, SemanticType.Unknown, -1, ContentType.Unknown, size) { AutoShaderParameter parameterDef = Parameter.AutoParameters[autoConstantType]; _name = parameterDef.Name; if (autoConstantData != 0.0) { _name += autoConstantData.ToString(); //replace possible illegal point character in name _name = _name.Replace('.', '_'); } _type = type; _semantic = SemanticType.Unknown; _index = -1; _content = Parameter.ContentType.Unknown; this.isAutoConstantReal = true; this.isAutoConstantInt = false; this.autoConstantType = autoConstantType; this.autoConstantRealData = autoConstantData; this.variability = (int)GpuProgramParameters.GpuParamVariability.Global; this._params = null; this.physicalIndex = -1; _size = size; }
public UniformParameter(GpuProgramParameters.GpuConstantType type, string name, SemanticType semantic, int index, ContentType content, int variability, int size) : base(type, name, semantic, index, content, size) { this.isAutoConstantInt = false; this.isAutoConstantReal = false; this.autoConstantIntData = 0; this.variability = variability; this._params = null; this.physicalIndex = -1; }
protected static bool getConstantType(AbstractNode i, out GpuProgramParameters.GpuConstantType op) { op = GpuProgramParameters.GpuConstantType.Unknown; string val; getString(i, out val); if (val.Contains("float")) { var count = 1; if (val.Length == 6) { count = int.Parse(val.Substring(5)); } else if (val.Length > 6) { return(false); } if (count > 4 || count == 0) { return(false); } op = GpuProgramParameters.GpuConstantType.Float1 + count - 1; } else if (val.Contains("int")) { var count = 1; if (val.Length == 4) { count = int.Parse(val.Substring(3)); } else if (val.Length > 4) { return(false); } if (count > 4 || count == 0) { return(false); } op = GpuProgramParameters.GpuConstantType.Int1 + count - 1; } else if (val.Contains("matrix")) { int count1, count2; if (val.Length == 9) { count1 = int.Parse(val.Substring(6, 1)); count2 = int.Parse(val.Substring(8, 1)); } else { return(false); } if (count1 > 4 || count1 < 2 || count2 > 4 || count2 < 2) { return(false); } switch (count1) { case 2: op = GpuProgramParameters.GpuConstantType.Matrix_2X2 + count2 - 2; break; case 3: op = GpuProgramParameters.GpuConstantType.Matrix_3X2 + count2 - 2; break; case 4: op = GpuProgramParameters.GpuConstantType.Matrix_4X2 + count2 - 2; break; } ; } return(true); }
private void WriteProgramDependencies(StreamWriter stream, Program program) { for (int i = 0; i < program.DependencyCount; i++) { string curDependency = program.GetDependency(i); CacheDependencyFunctions(curDependency); } stream.WriteLine("//-----------------------------------------------------------------------------"); stream.WriteLine("// PROGRAM DEPENDENCIES"); stream.WriteLine(); var forwardDecl = new List <FunctionInvocation>(); var functionList = program.Functions; int itFunction = 0; Function curFunction = functionList[0]; var atomInstances = curFunction.AtomInstances; int itAtom = 0; int itAtomEnd = atomInstances.Count; //Now iterate over all function atoms for ( ; itAtom != itAtomEnd; itAtom++) { //Skip non function invocation atom if (atomInstances[itAtom] is FunctionInvocation == false) { continue; } var funcInvoc = atomInstances[itAtom] as FunctionInvocation; forwardDecl.Add(funcInvoc); // Now look into that function for other non-builtin functions and add them to the declaration list // Look for non-builtin functions // Do so by assuming that these functions do not have several variations. // Also, because GLSL is C based, functions must be defined before they are used // so we can make the assumption that we already have this function cached. // // If we find a function, look it up in the map and write it out DiscoverFunctionDependencies(funcInvoc, forwardDecl); } //Now remove duplicate declarations forwardDecl.Sort(); forwardDecl = forwardDecl.Distinct(new FunctionInvocation.FunctionInvocationComparer()).ToList(); for (int i = 0; i < program.DependencyCount; i++) { string curDependency = program.GetDependency(i); foreach (var key in this.definesMap.Keys) { if (this.definesMap[key] == curDependency) { stream.Write(this.definesMap[key]); stream.Write("\n"); } } } // Parse the source shader and write out only the needed functions foreach (var it in forwardDecl) { var invoc = new FunctionInvocation(string.Empty, 0, 0, string.Empty); string body = string.Empty; //find the function in the cache foreach (var key in this.functionCacheMap.Keys) { if (!(it == key)) { continue; } invoc = key; body = this.functionCacheMap[key]; break; } if (invoc.FunctionName.Length > 0) { //Write out the funciton name from the cached FunctionInvocation stream.Write(invoc.ReturnType); stream.Write(" "); stream.Write(invoc.FunctionName); stream.Write("("); int itOperand = 0; int itOperandEnd = invoc.OperandList.Count; while (itOperand != itOperandEnd) { Operand op = invoc.OperandList[itOperand]; Operand.OpSemantic opSemantic = op.Semantic; string paramName = op.Parameter.Name; int opMask = op.Mask; GpuProgramParameters.GpuConstantType gpuType = GpuProgramParameters.GpuConstantType.Unknown; switch (opSemantic) { case Operand.OpSemantic.In: stream.Write("in "); break; case Operand.OpSemantic.Out: stream.Write("out "); break; case Operand.OpSemantic.InOut: stream.Write("inout "); break; default: break; } //Swizzle masks are onluy defined for types like vec2, vec3, vec4 if (opMask == (int)Operand.OpMask.All) { gpuType = op.Parameter.Type; } else { gpuType = Operand.GetGpuConstantType(opMask); } //We need a valid type otherwise glsl compilation will not work if (gpuType == GpuProgramParameters.GpuConstantType.Unknown) { throw new Core.AxiomException("Cannot convert Operand.OpMask to GpuConstantType"); } stream.Write(this.gpuConstTypeMap[gpuType] + " " + paramName); itOperand++; //Prepare for the next operand if (itOperand != itOperandEnd) { stream.Write(", "); } } stream.WriteLine(); stream.WriteLine("{"); stream.WriteLine(body); stream.WriteLine("}"); stream.WriteLine(); } } }
private FunctionInvocation CreateInvocationFromString(string input) { string functionName, returnType; FunctionInvocation invoc = null; //Get the function name and return type var leftTokens = input.Split('('); var leftTokens2 = leftTokens[0].Split(' '); leftTokens2[0] = leftTokens2[0].Trim(); leftTokens2[1] = leftTokens2[1].Trim(); returnType = leftTokens2[0]; functionName = leftTokens2[1]; invoc = new FunctionInvocation(functionName, 0, 0, returnType); string[] parameters; int lparen_pos = -1; for (int i = 0; i < input.Length; i++) { if (input[i] == '(') { lparen_pos = i; break; } } if (lparen_pos != -1) { string[] tokens = input.Split('('); parameters = tokens[1].Split(','); } else { parameters = input.Split(','); } for (int i = 0; i < parameters.Length; i++) { string itParam = parameters[i]; itParam = itParam.Replace(")", string.Empty); itParam = itParam.Replace(",", string.Empty); string[] paramTokens = itParam.Split(' '); // There should be three parts for each token // 1. The operand type(in, out, inout) // 2. The type // 3. The name if (paramTokens.Length == 3) { Operand.OpSemantic semantic = Operand.OpSemantic.In; GpuProgramParameters.GpuConstantType gpuType = GpuProgramParameters.GpuConstantType.Unknown; if (paramTokens[0] == "in") { semantic = Operand.OpSemantic.In; } else if (paramTokens[0] == "out") { semantic = Operand.OpSemantic.Out; } else if (paramTokens[0] == "inout") { semantic = Operand.OpSemantic.InOut; } //Find the internal type based on the string that we're given foreach (var key in this.gpuConstTypeMap.Keys) { if (this.gpuConstTypeMap[key] == paramTokens[1]) { gpuType = key; break; } } //We need a valid type otherwise glsl compilation will not work if (gpuType == GpuProgramParameters.GpuConstantType.Unknown) { throw new Core.AxiomException("Cannot convert Operand.OpMask to GpuConstantType"); } if (gpuType == GpuProgramParameters.GpuConstantType.Sampler1D) { gpuType = GpuProgramParameters.GpuConstantType.Sampler2D; } var p = new Parameter(gpuType, paramTokens[2], Parameter.SemanticType.Unknown, i, Parameter.ContentType.Unknown, 0); invoc.PushOperand(p, semantic, (int)Operand.OpMask.All, 0); } } return(invoc); }