private void AddNormalRelatedCalculations(Function vsMain, Parameter normalRelatedParam, Parameter normalWorldRelatedParam, ref int funcCounter) { FunctionInvocation curFuncInvocation; if (doBoneCalculations) { //set functions to calculate world normal for (int i = 0; i < weightCount; i++) { AddIndexedNormalRelatedWeight(vsMain, normalRelatedParam, normalWorldRelatedParam, i, ref funcCounter); } //update back the original position relative to the object curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInInvWorldMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalWorldRelatedParam, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalRelatedParam, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } else { //update back the original position relative to the object curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInWorldMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalRelatedParam, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalWorldRelatedParam, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } }
private bool AddGlobalIlluminationInvocation(Function vsMain, int groupOrder, ref int internalCounter) { FunctionInvocation curFuncInvocation = null; if ((this.trackVertexColorType & TrackVertexColor.Ambient) == 0 && (this.trackVertexColorType & TrackVertexColor.Emissive) == 0) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.derivedSceneColor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } else { if ((this.trackVertexColorType & TrackVertexColor.Ambient) == TrackVertexColor.Ambient) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.lightAmbientColor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } else { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.derivedAmbientLightColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } if ((this.trackVertexColorType & TrackVertexColor.Emissive) == TrackVertexColor.Emissive) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.surfaceEmissiveCoilor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } else { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAdd, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.surfaceEmissiveCoilor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } } return(true); }
private void AddPositionCalculations(Function vsMain, ref int funcCounter) { FunctionInvocation curFuncInvocation = null; if (doBoneCalculations == true) { //set functions to calculate world position for (int i = 0; i < WeightCount; i++) { AddIndexedPositionWeight(vsMain, i, ref funcCounter); } //update back the original position relative to the object curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInInvWorldMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); //update the projective position thereby filling the transform stage role curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInViewProjMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramOutPositionProj, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } else { //update from object to world space curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInWorldMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); //update from ojbect to projective space curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInWorldViewProjMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramOutPositionProj, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } }
private void AddIndexedNormalRelatedWeight(Function vsMain, Parameter normalRelatedParam, Parameter normalWorldRelatedParam, int index, ref int funcCounter) { FunctionInvocation curFuncInvocation; Operand.OpMask indexMask = IndexToMask(index); //multiply position with world matrix and put into temporary param curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInWorldMatrices, Operand.OpSemantic.In, (int)Operand.OpMask.All); curFuncInvocation.PushOperand(paramInIndices, Operand.OpSemantic.In, (int)indexMask, 1); curFuncInvocation.PushOperand(normalRelatedParam, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramTempFloat3, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); //multiply temporary param with weight curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramTempFloat3, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramInWeights, Operand.OpSemantic.In, (int)indexMask); curFuncInvocation.PushOperand(paramTempFloat3, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); //check if on first iteration if (index == 0) { //set the local param as the value of the world normal curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramTempFloat3, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalWorldRelatedParam, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalWorldRelatedParam, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } else { //add the local param as the value of the world normal curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAdd, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramTempFloat3, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalWorldRelatedParam, Operand.OpSemantic.In); curFuncInvocation.PushOperand(normalWorldRelatedParam, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } }
private void AddPSModifierInvocation(Function psMain, int samplerIndex, Parameter arg1, Parameter arg2, int groupOrder, ref int internalCounter, int targetChanells) { SourceModifier modType; int customNum; if (GetSourceModifier(samplerIndex, out modType, out customNum) == true) { Parameter modifiedParam = null; string funcName = string.Empty; switch (modType) { case SourceModifier.Source1Modulate: funcName = "SGX_src_mod_modulate"; modifiedParam = arg1; break; case SourceModifier.Source2Modulate: funcName = "SGX_src_mod_modulate"; modifiedParam = arg2; break; case SourceModifier.Source1InvModulate: funcName = "SGX_src_mod_inv_modulate"; modifiedParam = arg1; break; case SourceModifier.Source2InvModulate: funcName = "SGX_src_mod_inv_modulate"; modifiedParam = arg2; break; default: break; } //add the function of the blend mode if (funcName != string.Empty) { Parameter controlParam = this.textureBlends[samplerIndex].ModControlParam; var curFuncInvocation = new FunctionInvocation(funcName, groupOrder, internalCounter++); curFuncInvocation.PushOperand(modifiedParam, Operand.OpSemantic.In, targetChanells); curFuncInvocation.PushOperand(controlParam, Operand.OpSemantic.In, targetChanells); curFuncInvocation.PushOperand(modifiedParam, Operand.OpSemantic.Out, targetChanells); psMain.AddAtomInstance(curFuncInvocation); } } }
private bool AddPSInvocation(Program psProgram, int groupOrder, ref int internalCounter) { Function psMain = psProgram.EntryPointFunction; FunctionInvocation curFuncInvocation = null; ShadowTextureParams splitParams0 = this.shadowTextureParamsList[0]; ShadowTextureParams splitParams1 = this.shadowTextureParamsList[1]; ShadowTextureParams splitParams2 = this.shadowTextureParamsList[2]; //Compute shadow factor curFuncInvocation = new FunctionInvocation(SGXFuncComputeShadowColor3, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.psInDepth, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psSplitPoints, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams0.PSInLightPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams1.PSInLightPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams2.PSInLightPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams0.TextureSampler, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams1.TextureSampler, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams2.TextureSampler, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams0.InvTextureSize, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams1.InvTextureSize, Operand.OpSemantic.In); curFuncInvocation.PushOperand(splitParams2.InvTextureSize, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psLocalShadowFactor, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); //Apply shadow factor on diffuse color curFuncInvocation = new FunctionInvocation(SGXFuncApplyShadowFactorDiffuse, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.psDerivedSceneColor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psLocalShadowFactor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psLocalShadowFactor, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); //Apply shadow factor on specular color curFuncInvocation = new FunctionInvocation(SGXFuncModulateScalar, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.psLocalShadowFactor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psSpecular, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psSpecular, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); //Assign the local diffuse to output diffuse curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.psDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psOutDiffuse, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); return(true); }
protected override void AddPSBlendInvocations(Function psMain, Parameter arg1, Parameter arg2, Parameter texel, int samplerIndex, Graphics.LayerBlendModeEx blendMode, int groupOrder, ref int internalCounter, int targetChannels) { //Add the modifier invocation AddPSModifierInvocation(psMain, samplerIndex, arg1, arg2, groupOrder, ref internalCounter, targetChannels); //Add the blending fucntion invocations BlendMode mode = GetBlendMode(samplerIndex); if ((mode == BlendMode.FFPBlend) || (mode == BlendMode.Invalid)) { base.AddPSBlendInvocations(psMain, arg1, arg2, texel, samplerIndex, blendMode, groupOrder, ref internalCounter, targetChannels); } else { //find the function name for the blend mode string funcName = string.Empty; for (int i = 0; i < blendModes.Length; i++) { if (blendModes[i].Type == mode) { funcName = blendModes[i].FuncName; break; } } if (funcName != string.Empty) { var curFuncInvocation = new FunctionInvocation(funcName, groupOrder, internalCounter++); curFuncInvocation.PushOperand(arg1, Operand.OpSemantic.In, targetChannels); curFuncInvocation.PushOperand(arg2, Operand.OpSemantic.In, targetChannels); curFuncInvocation.PushOperand(psOutDiffuse, Operand.OpSemantic.Out, targetChannels); psMain.AddAtomInstance(curFuncInvocation); } } }
private bool AddVSInvocation(Function vsMain, int groupOrder, ref int internalCounter) { FunctionInvocation curFuncInvocation; //Output the vertex depth in camera space curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.vsOutPos, Operand.OpSemantic.In, Operand.OpMask.Z); curFuncInvocation.PushOperand(this.vsOutDepth, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); //compute world space position foreach (var it in this.shadowTextureParamsList) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, groupOrder, internalCounter++); curFuncInvocation.PushOperand(it.WorldViewProjMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPos, Operand.OpSemantic.In); curFuncInvocation.PushOperand(it.VSOutLightPosition, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } return(true); }
protected override bool AddFunctionInvocations(ProgramSet programSet) { if (this.fogMode == FogMode.None) { return(true); } Program vsProgram = programSet.CpuVertexProgram; Program psProgram = programSet.CpuFragmentProgram; Function vsMain = vsProgram.EntryPointFunction; Function psMain = psProgram.EntryPointFunction; FunctionInvocation curFuncInvocation = null; int internalCounter = 0; //Per pixel fog if (this.calcMode == CalcMode.PerPixel) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncPixelFogDepth, (int)FFPRenderState.FFPVertexShaderStage.VSFog, internalCounter++); curFuncInvocation.PushOperand(this.worldViewProjMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPos, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDepth, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); internalCounter = 0; switch (this.fogMode) { case FogMode.Exp: curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncPixelFogLinear, (int)FFPRenderState.FFPFragmentShaderStage.PSFog, internalCounter++); break; case FogMode.Exp2: curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncPixelFogExp, (int)FFPRenderState.FFPFragmentShaderStage.PSFog, internalCounter++); break; case FogMode.Linear: curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncPixelFogExp2, (int)FFPRenderState.FFPFragmentShaderStage.PSFog, internalCounter++); break; default: break; } curFuncInvocation.PushOperand(this.psInDepth, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.fogParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.fogColor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psOutDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psOutDiffuse, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); } else //Per vertex fog { internalCounter = 0; switch (this.fogMode) { case FogMode.Exp: curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncVertexFogLinear, (int)FFPRenderState.FFPVertexShaderStage.VSFog, internalCounter++); break; case FogMode.Exp2: curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncVertexFogExp, (int)FFPRenderState.FFPVertexShaderStage.VSFog, internalCounter++); break; case FogMode.Linear: curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncVertexFogExp2, (int)FFPRenderState.FFPVertexShaderStage.VSFog, internalCounter++); break; default: break; } curFuncInvocation.PushOperand(this.worldViewProjMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPos, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.fogParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutFogFactor, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); internalCounter = 0; curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncLerp, (int)FFPRenderState.FFPFragmentShaderStage.PSFog, internalCounter++); curFuncInvocation.PushOperand(this.fogColor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psOutDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psInFogFactor, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psOutDiffuse, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); } return(true); }
private bool AddIlluminationInvocation(LightParams curLightParams, Function vsMain, int groupOrder, ref int internalCounter) { FunctionInvocation curFuncInvocation = null; //Merge dffuse color with vertex color if need to if ((this.trackVertexColorType & TrackVertexColor.Diffuse) == TrackVertexColor.Diffuse) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.vsDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } //Merge specular color with vertex color if need to if (this.specularEnable && (this.trackVertexColorType & TrackVertexColor.Specular) == TrackVertexColor.Specular) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.vsDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.SpecularColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.SpecularColor, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } switch (curLightParams.Type) { case LightType.Directional: if (this.specularEnable) { curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncLightDirectionDiffuseSpecular, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.worldViewMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.worldViewITMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInNormal, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.Direction, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.SpecularColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.surfaceShininess, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutSpecular, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutSpecular, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } else { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncLightDirectionDiffuse, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.worldViewITMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInNormal, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.Direction, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } break; case LightType.Point: if (this.specularEnable) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncLightPointDiffuseSpecular, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.worldViewMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.worldViewITMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInNormal, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.Position, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.AttenuatParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.SpecularColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.surfaceShininess, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutSpecular, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutSpecular, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } else { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncLightPointDiffuse, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.worldViewMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.worldViewITMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInNormal, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.Position, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.AttenuatParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } break; case LightType.Spotlight: if (this.specularEnable) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncLightSpotDiffuseSpecular, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.worldViewITMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.worldViewITMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInNormal, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.Position, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.Direction, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.AttenuatParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.SpotParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.SpecularColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.surfaceShininess, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutSpecular, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutSpecular, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } else { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncLightSpotDiffuse, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.worldViewMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.worldViewITMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInNormal, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.Position, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(curLightParams.AttenuatParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.SpotParams, Operand.OpSemantic.In); curFuncInvocation.PushOperand(curLightParams.DiffuseColor, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.vsOutDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); vsMain.AddAtomInstance(curFuncInvocation); } break; } return(true); }
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); }
/// <summary> /// Generates local parameters for the split parameters and perform packing/unpacking operation using them. /// </summary> /// <param name="fun"> </param> /// <param name="progType"> </param> /// <param name="mergedParams"> </param> /// <param name="splitParams"> </param> /// <param name="localParamsMap"> </param> internal static void GenerateLocalSplitParameters(Function func, GpuProgramType progType, List <MergeParameter> mergedParams, List <Parameter> splitParams, Dictionary <Parameter, Parameter> localParamsMap) { //No split params created. if (splitParams.Count == 0) { return; } //Create the local parameters + map from source to local for (int i = 0; i < splitParams.Count; i++) { Parameter srcParameter = splitParams[i]; Parameter localParameter = func.ResolveLocalParameter(srcParameter.Semantic, srcParameter.Index, "lssplit_" + srcParameter.Name, srcParameter.Type); localParamsMap.Add(srcParameter, localParameter); } int invocationCounter = 0; //Establish link between the local parameter to the merged parameter. for (int i = 0; i < mergedParams.Count; i++) { var curMergeParameter = mergedParams[i]; for (int p = 0; p < curMergeParameter.SourceParameterCount; p++) { Parameter srcMergedParameter = curMergeParameter.SourceParameter[p]; if (localParamsMap.ContainsKey(srcMergedParameter)) { //Case it is the vertex shader -> assign the local parameter to the output merged parameter if (progType == GpuProgramType.Vertex) { var curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int) FFPRenderState.FFPVertexShaderStage. VSPostProcess, invocationCounter++); curFuncInvocation.PushOperand(localParamsMap[srcMergedParameter], Operand.OpSemantic.In, curMergeParameter.GetSourceParameterMask(p)); curFuncInvocation.PushOperand( curMergeParameter.GetDestinationParameter((int)Operand.OpSemantic.Out, i), Operand.OpSemantic.Out, curMergeParameter.GetDestinationParameterMask(p)); func.AddAtomInstance(curFuncInvocation); } else if (progType == GpuProgramType.Fragment) { var curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int) FFPRenderState.FFPFragmentShaderStage. PSPreProcess, invocationCounter++); curFuncInvocation.PushOperand( curMergeParameter.GetDestinationParameter((int)Operand.OpSemantic.In, i), Operand.OpSemantic.In, curMergeParameter.GetDestinationParameterMask(p)); curFuncInvocation.PushOperand(localParamsMap[srcMergedParameter], Operand.OpSemantic.Out, curMergeParameter.GetSourceParameterMask(p)); func.AddAtomInstance(curFuncInvocation); } } } } }
private void AddIndexedPositionWeight(Function vsMain, int index, ref int funcCounter) { Operand.OpMask indexMask = IndexToMask(index); FunctionInvocation curFuncInvocation; var outputMask = (int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z); if (paramInWorldMatrices.Type == GpuProgramParameters.GpuConstantType.Matrix_4X4) { outputMask = (int)Operand.OpMask.All; } //multiply posiiton with world matrix and put into temporary param curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramInWorldMatrix, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramInIndices, Operand.OpSemantic.In, (int)indexMask, 1); curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out, outputMask); vsMain.AddAtomInstance(curFuncInvocation); //set w value of temporary param to 1 curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out, (int)Operand.OpMask.W); vsMain.AddAtomInstance(curFuncInvocation); //multiply temporary param with weight curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramInWeights, Operand.OpSemantic.In, (int)indexMask); curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); //check if on first iteration if (index == 0) { //set the local param as the value of the world param curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } else { //add the local param as the value of the world param curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAdd, (int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++); curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.In); curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } }
protected override bool AddFunctionInvocations(ProgramSet programSet) { Program vsProgram = programSet.CpuVertexProgram; Program psProgram = programSet.CpuFragmentProgram; Function psMain = psProgram.EntryPointFunction; Function vsMain = vsProgram.EntryPointFunction; FunctionInvocation curFuncInvocation = null; //Calculate the position and size of the texture in the atlas in the vertex shader int groupOrder = ((int)FFPRenderState.FFPVertexShaderStage.VSTexturing - (int)FFPRenderState.FFPVertexShaderStage.VSLighting) / 2; int internalCounter = 0; for (int i = 0; i < TextureAtlasSampler.MaxTextures; i++) { if (this.isAtlasTextureUnits[i] == true) { Operand.OpMask textureIndexMask = Operand.OpMask.X; switch (i) { case 1: textureIndexMask = Operand.OpMask.Y; break; case 2: textureIndexMask = Operand.OpMask.Z; break; case 3: textureIndexMask = Operand.OpMask.W; break; } curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++); curFuncInvocation.PushOperand(this.vsTextureTable[i], Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsInpTextureTableIndex, Operand.OpSemantic.In, (int)textureIndexMask, 1); curFuncInvocation.PushOperand(this.vsOutTextureDatas[i], Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } } //sample the texture in the fragment shader given the extracted data in the pixel shader // groupOrder = (FFP_PS_SAMPLING + FFP_PS_TEXTURING) / 2; internalCounter = 0; var inpParams = psMain.InputParameters; var localParams = psMain.LocalParameters; Parameter psAtlasTextureCoord = psMain.ResolveLocalParameter(Parameter.SemanticType.Unknown, -1, "atlasCoord", GpuProgramParameters.GpuConstantType.Float2); for (int j = 0; j < TextureAtlasSampler.MaxTextures; j++) { if (this.isAtlasTextureUnits[j] == true) { //Find the texture coordinates texel and sampler from the original FFPTexturing Parameter texcoord = Function.GetParameterByContent(inpParams, (Parameter.ContentType) ((int)Parameter.ContentType.TextureCoordinate0 + j), GpuProgramParameters.GpuConstantType.Float2); Parameter texel = Function.GetParameterByName(localParams, this.paramTexel + j.ToString()); UniformParameter sampler = psProgram.GetParameterByType(GpuProgramParameters.GpuConstantType.Sampler2D, j); //TODO string addressUFuncName = GetAddressingFunctionName(this.textureAddressings[j].U); string addressVFuncName = GetAddressingFunctionName(this.textureAddressings[j].V); //Create a function which will replace the texel with the texture texel if ((texcoord != null) && (texel != null) && (sampler != null) && (addressUFuncName != null) && (addressVFuncName != null)) { //calculate the U value due to addressing mode curFuncInvocation = new FunctionInvocation(addressUFuncName, groupOrder, internalCounter++); curFuncInvocation.PushOperand(texcoord, Operand.OpSemantic.In, Operand.OpMask.X); curFuncInvocation.PushOperand(psAtlasTextureCoord, Operand.OpSemantic.Out, Operand.OpMask.X); psMain.AddAtomInstance(curFuncInvocation); //calculate the V value due to addressing mode curFuncInvocation = new FunctionInvocation(addressVFuncName, groupOrder, internalCounter++); curFuncInvocation.PushOperand(texcoord, Operand.OpSemantic.In, Operand.OpMask.Y); curFuncInvocation.PushOperand(psAtlasTextureCoord, Operand.OpSemantic.Out, Operand.OpMask.Y); psMain.AddAtomInstance(curFuncInvocation); //sample the texel color curFuncInvocation = new FunctionInvocation(this.autoAdjustPollPosition ? SGXFuncAtlasSampleAutoAdjust : SGXFuncAtlasSampleNormal, groupOrder, internalCounter++); curFuncInvocation.PushOperand(sampler, Operand.OpSemantic.In); curFuncInvocation.PushOperand(texcoord, Operand.OpSemantic.In, (int)(Operand.OpMask.X | Operand.OpMask.Y)); curFuncInvocation.PushOperand(psAtlasTextureCoord, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psInpTextureData[j], Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psTextureSizes[j], Operand.OpSemantic.In); curFuncInvocation.PushOperand(texel, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); } } } return(true); }
protected override bool AddFunctionInvocations(ProgramSet programSet) { Program vsProgram = programSet.CpuVertexProgram; Program psProgram = programSet.CpuFragmentProgram; Function vsMain = vsProgram.EntryPointFunction; Function psMain = psProgram.EntryPointFunction; FunctionInvocation curFuncInvocation = null; int internalCounter; //Create vertex shader color invocations Parameter vsDiffuse, vsSpecular; internalCounter = 0; if (this.vsInputDiffuse != null) { vsDiffuse = this.vsInputDiffuse; } else { vsDiffuse = vsMain.ResolveLocalParameter(Parameter.SemanticType.Color, 0, Parameter.ContentType.ColorDiffuse, Graphics.GpuProgramParameters.GpuConstantType.Float4); curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncConstruct, (int)FFPRenderState.FFPVertexShaderStage.VSColor, internalCounter++); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(vsDiffuse, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } if (this.vsOutputDiffuse != null) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int)FFPRenderState.FFPVertexShaderStage.VSColor, internalCounter++); curFuncInvocation.PushOperand(vsDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutputDiffuse, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } if (this.vsInputSpecular != null) { vsSpecular = this.vsInputSpecular; } else { vsSpecular = vsMain.ResolveLocalParameter(Parameter.SemanticType.Color, 1, Parameter.ContentType.ColorSpecular, Graphics.GpuProgramParameters.GpuConstantType.Float4); curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncConstruct, (int)FFPRenderState.FFPVertexShaderStage.VSColor, internalCounter++); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(vsSpecular, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } if (this.vsOutputSpecular != null) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int)FFPRenderState.FFPVertexShaderStage.VSColor, internalCounter++); curFuncInvocation.PushOperand(vsSpecular, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.vsOutputSpecular, Operand.OpSemantic.Out); vsMain.AddAtomInstance(curFuncInvocation); } //Create fragment shader color invocations Parameter psDiffuse, psSpecular; internalCounter = 0; //Handle diffuse color if (this.psInputDiffuse != null) { psDiffuse = this.psInputDiffuse; } else { psDiffuse = psMain.ResolveLocalParameter(Parameter.SemanticType.Color, 0, Parameter.ContentType.ColorDiffuse, Graphics.GpuProgramParameters.GpuConstantType.Float4); curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncConstruct, (int)FFPRenderState.FFPFragmentShaderStage.PSColorBegin, internalCounter++); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(psDiffuse, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); } //Handle specular color if (this.psInputSpecular != null) { psSpecular = this.psInputSpecular; } else { psSpecular = psMain.ResolveLocalParameter(Parameter.SemanticType.Color, 1, Parameter.ContentType.ColorSpecular, Graphics.GpuProgramParameters.GpuConstantType.Float4); curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncConstruct, (int)FFPRenderState.FFPFragmentShaderStage.PSColorBegin, internalCounter++); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(0.0f), Operand.OpSemantic.In); curFuncInvocation.PushOperand(psSpecular, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); } //Assign diffuse color if (this.psOutputDiffuse != null) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int)FFPRenderState.FFPFragmentShaderStage.PSColorBegin, internalCounter++); curFuncInvocation.PushOperand(psDiffuse, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psOutputDiffuse, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); } //Assign specular color if (this.psOutputSpecular != null) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, (int)FFPRenderState.FFPFragmentShaderStage.PSColorBegin, internalCounter++); curFuncInvocation.PushOperand(psSpecular, Operand.OpSemantic.In); curFuncInvocation.PushOperand(this.psOutputSpecular, Operand.OpSemantic.Out); psMain.AddAtomInstance(curFuncInvocation); } //Add specular to out color internalCounter = 0; if (this.psOutputDiffuse != null && psSpecular != null) { curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAdd, (int)FFPRenderState.FFPFragmentShaderStage.PSColorEnd, internalCounter++); curFuncInvocation.PushOperand(this.psOutputDiffuse, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(psSpecular, Operand.OpSemantic.In, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); curFuncInvocation.PushOperand(this.psOutputDiffuse, Operand.OpSemantic.Out, (Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z)); psMain.AddAtomInstance(curFuncInvocation); } return(true); }