private void AdjustForCorrectAntipodality(Function vsMain, int index, ref int funcCounter,
Parameter tempWorldMatrix)
{
FunctionInvocation curFuncInvocation = null;
//Antipodality doesn't need to be adjusted for dq0 on itself (used as the basis of antipodality calculations)
if (index > 0)
{
curFuncInvocation = new FunctionInvocation(SGXFuncAntipodalityAdjustment,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
//This is the base dual quaternion dq0, which the antipodality calculations are based on
curFuncInvocation.PushOperand(this.paramInitialDQ, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramTempFloat2x4, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(tempWorldMatrix, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
else if (index == 0)
{
//Set the first dual quaternion as the initial dq
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramTempFloat2x4, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramInitialDQ, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
}
private bool AddVsInvocations(Function vsMain, int groupOrder)
{
FunctionInvocation funcInvocation = null;
int internalCounter = 0;
funcInvocation = new FunctionInvocation(SGXFuncInstancedViewportsTransform, groupOrder, internalCounter++);
funcInvocation.PushOperand(this.vsInPosition, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.worldViewMatrix, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.projectionMatrix, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInViewportOffsetMatrixR0, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInViewportOffsetMatrixR1, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInViewportOffsetMatrixR2, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInViewportOffsetMatrixR3, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInMonitorsCount, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInMonitorIndex, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsOriginalOutPositionProjectiveSpace, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(funcInvocation);
//Output position in projective space
funcInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++);
funcInvocation.PushOperand(this.vsOriginalOutPositionProjectiveSpace, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsOutPositionProjectiveSpace, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(funcInvocation);
//Output monitor index
funcInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++);
funcInvocation.PushOperand(this.vsInMonitorIndex, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsOutMonitorIndex, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(funcInvocation);
return(true);
}
private bool AddPsInvocations(Function psMain, int groupOrder)
{
FunctionInvocation funcInvocation = null;
int internalCounter = 0;
funcInvocation = new FunctionInvocation(SGXFuncInstancedViewportsDiscardOutOfBounds, groupOrder, internalCounter++);
funcInvocation.PushOperand(this.psInMonitorsCount, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.psInMonitorIndex, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.psInPositionProjectiveSpace, Operand.OpSemantic.In);
psMain.AddAtomInstance(funcInvocation);
return(true);
}
internal override bool CreateCpuSubPrograms(ProgramSet programSet)
{
Program vsProgram = programSet.CpuVertexProgram;
//Resolve world view proj matrix
UniformParameter wvpMatrix =
vsProgram.ResolveAutoParameterInt(Graphics.GpuProgramParameters.AutoConstantType.WorldViewProjMatrix, 0);
if (wvpMatrix == null)
{
return(false);
}
Function vsEntry = vsProgram.EntryPointFunction;
//Resolve input position parameter
Parameter positionIn = vsEntry.ResolveInputParameter(Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4);
if (positionIn == null)
{
return(false);
}
//Resolve output position parameter
Parameter positionOut = vsEntry.ResolveOutputParameter(Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionProjectiveSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4);
if (positionOut == null)
{
return(false);
}
//Add dependency
vsProgram.AddDependency(FFPRenderState.FFPLibTransform);
var transformFunc = new FunctionInvocation(FFPRenderState.FFPFuncTransform, -1, 0);
transformFunc.PushOperand(wvpMatrix, Operand.OpSemantic.In);
transformFunc.PushOperand(positionIn, Operand.OpSemantic.In);
transformFunc.PushOperand(positionOut, Operand.OpSemantic.Out);
vsEntry.AddAtomInstance(transformFunc);
return(true);
}
internal override bool CreateCpuSubPrograms( ProgramSet programSet )
{
Program vsProgram = programSet.CpuVertexProgram;
//Resolve world view proj matrix
UniformParameter wvpMatrix =
vsProgram.ResolveAutoParameterInt( Graphics.GpuProgramParameters.AutoConstantType.WorldViewProjMatrix, 0 );
if ( wvpMatrix == null )
{
return false;
}
Function vsEntry = vsProgram.EntryPointFunction;
//Resolve input position parameter
Parameter positionIn = vsEntry.ResolveInputParameter( Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
if ( positionIn == null )
{
return false;
}
//Resolve output position parameter
Parameter positionOut = vsEntry.ResolveOutputParameter( Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionProjectiveSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
if ( positionOut == null )
{
return false;
}
//Add dependency
vsProgram.AddDependency( FFPRenderState.FFPLibTransform );
var transformFunc = new FunctionInvocation( FFPRenderState.FFPFuncTransform, -1, 0 );
transformFunc.PushOperand( wvpMatrix, Operand.OpSemantic.In );
transformFunc.PushOperand( positionIn, Operand.OpSemantic.In );
transformFunc.PushOperand( positionOut, Operand.OpSemantic.Out );
vsEntry.AddAtomInstance( transformFunc );
return true;
}
private void AddIndexedPositionWeight(Function vsMain, int index, Parameter worldMatrix,
Parameter positionTempParameter, Parameter positionRelatedOutputParam,
ref int funcCounter)
{
Operand.OpMask indexMask = IndexToMask(index);
FunctionInvocation curFuncInvocation = null;
//multiply position with world matrix and put into temporary param
curFuncInvocation = new FunctionInvocation(SGXFuncBlendWeight,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInWeights, Operand.OpSemantic.In, indexMask);
curFuncInvocation.PushOperand(worldMatrix, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(positionTempParameter, 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(positionTempParameter, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(positionRelatedOutputParam, 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(positionTempParameter, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(positionRelatedOutputParam, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(positionRelatedOutputParam, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
}
private bool AddVsInvocations(Function vsMain, int groupOrder)
{
FunctionInvocation funcInvocation = null;
int internalCounter = 0;
//Output mask texgture coordinates
funcInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++);
funcInvocation.PushOperand(this.vsInMaskTexcoord, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsOutMaskTexcoord, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(funcInvocation);
//Output reflection texture coordinates.
if (this.reflectionMapType == TextureType.TwoD)
{
funcInvocation = new FunctionInvocation(FFPRenderState.FFPFunGenerateTexcoordEnvSphere, groupOrder,
internalCounter++);
funcInvocation.PushOperand(this.worldITMatrix, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.viewMatrix, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInputNormal, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsOutReflectionTexcoord, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(funcInvocation);
}
else
{
funcInvocation = new FunctionInvocation(FFPRenderState.FFPFuncGenerateTexCoordEnvReflect, groupOrder,
internalCounter++);
funcInvocation.PushOperand(this.worldMatrix, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.worldITMatrix, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.viewMatrix, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInputNormal, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsInputPos, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.vsOutReflectionTexcoord, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(funcInvocation);
}
return(true);
}
private bool AddPsInvocations(Function psMain, int groupOrder)
{
FunctionInvocation funcInvocation = null;
int internalCounter = 0;
funcInvocation = new FunctionInvocation(SGXFuncApplyReflectionMap, groupOrder, internalCounter++);
funcInvocation.PushOperand(this.maskMapSampler, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.psInMaskTexcoord, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.reflectionMapSampler, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.psInReflectionTexcoord, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.psOutDiffuse, Operand.OpSemantic.In,
(int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z));
funcInvocation.PushOperand(this.reflectionPower, Operand.OpSemantic.In);
funcInvocation.PushOperand(this.psOutDiffuse, Operand.OpSemantic.Out,
(int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z));
psMain.AddAtomInstance(funcInvocation);
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 AddVsInvocations( Function vsMain, int groupOrder )
{
FunctionInvocation funcInvocation = null;
int internalCounter = 0;
funcInvocation = new FunctionInvocation( SGXFuncInstancedViewportsTransform, groupOrder, internalCounter++ );
funcInvocation.PushOperand( this.vsInPosition, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.worldViewMatrix, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.projectionMatrix, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsInViewportOffsetMatrixR0, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsInViewportOffsetMatrixR1, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsInViewportOffsetMatrixR2, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsInViewportOffsetMatrixR3, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsInMonitorsCount, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsInMonitorIndex, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsOriginalOutPositionProjectiveSpace, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( funcInvocation );
//Output position in projective space
funcInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++ );
funcInvocation.PushOperand( this.vsOriginalOutPositionProjectiveSpace, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsOutPositionProjectiveSpace, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( funcInvocation );
//Output monitor index
funcInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++ );
funcInvocation.PushOperand( this.vsInMonitorIndex, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.vsOutMonitorIndex, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( funcInvocation );
return true;
}
protected bool AddPSFinalAssignmentInvocation( Function psMain, int groupOrder, ref int internalCounter )
{
var curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPFragmentShaderStage.PSColorBegin + 1,
internalCounter++ );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPFragmentShaderStage.PSColorBegin + 1,
internalCounter++ );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
if ( this.specularEnable )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPFragmentShaderStage.PSColorBegin + 1,
internalCounter++ );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psSpecular, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
}
return true;
}
protected bool AddVSInvocation( Function vsMain, int groupOrder, ref int internalCounter )
{
FunctionInvocation curFuncInvocation = null;
//transform normal in view space
curFuncInvocation = new FunctionInvocation( SGXFuncTransformNormal, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.worldViewITMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsOutNormal, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Transform view space position if need to
if ( this.vsOutViewPos != null )
{
curFuncInvocation = new FunctionInvocation( SGXFuncTransformPosition, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.worldViewMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsInPosition, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsOutViewPos, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
return true;
}
private void AddPositionCalculations(Function vsMain, ref int funcCounter)
{
FunctionInvocation curFuncInvocation = null;
if (doBoneCalculations)
{
if (scalingShearingSupport)
{
//Construct a scaling and shearing matrix based on the blend weights
for (int i = 0; i < WeightCount; i++)
{
//Assign the local param based on the current index of the scaling and shearing matrices
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramInScaleShearMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInIndices, Operand.OpSemantic.In, (int)IndexToMask(i), 1);
curFuncInvocation.PushOperand(this.paramTempFloat3x4, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Calculate the resultant scaling and shearing matrix based on the weigts given
AddIndexedPositionWeight(vsMain, i, this.paramTempFloat3x4, this.paramTempFloat3x4, this.paramBlendS,
ref funcCounter);
}
//Transform the position based on the scaling and shearing matrix
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramBlendS, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In,
(int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z));
curFuncInvocation.PushOperand(this.paramLocalBlendPosition, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
else
{
//Assign the input position to the local blended position
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In,
(int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z));
curFuncInvocation.PushOperand(this.paramLocalBlendPosition, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
//Set functions to calculate world position
for (int i = 0; i < weightCount; i++)
{
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInIndices, Operand.OpSemantic.In, (int)IndexToMask(i));
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//multiply the index by 2
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(2.0f), Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Add 1 to the index and assign as the second row's index
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAdd,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex2, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Build the dual quaternion matrix
curFuncInvocation = new FunctionInvocation(
DualQuaternionSkinning.SGXFuncBuildDualQuaternionMatrix,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++);
curFuncInvocation.PushOperand(paramInWorldMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.In, (int)Operand.OpMask.All, 1);
curFuncInvocation.PushOperand(paramInWorldMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex2, Operand.OpSemantic.In, (int)Operand.OpMask.All, 1);
curFuncInvocation.PushOperand(this.paramTempFloat2x4, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
if (correctAntipodalityHandling)
{
AdjustForCorrectAntipodality(vsMain, i, ref funcCounter, this.paramTempFloat2x4);
}
//Calculate the resultant dual quaternion based based on the weights given
AddIndexedPositionWeight(vsMain, i, this.paramTempFloat2x4, this.paramTempFloat2x4, this.paramBlendDQ,
ref funcCounter);
}
//Normalize the dual quaternion
curFuncInvocation = new FunctionInvocation(DualQuaternionSkinning.SGXFuncNormalizeDualQuaternion,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramBlendDQ, Operand.OpSemantic.InOut);
vsMain.AddAtomInstance(curFuncInvocation);
//Calculate the blend position
curFuncInvocation = new FunctionInvocation(DualQuaternionSkinning.SGXFuncCalculateBlendPosition,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramLocalBlendPosition, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramBlendDQ, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Update from object to projective space
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInViewProjMatrix, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramTempFloat4, 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(paramInWorldMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//update from object 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);
}
}
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;
}
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 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;
}
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 );
}
}
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 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 AddIndexedPositionWeight( Function vsMain, int index, Parameter worldMatrix,
Parameter positionTempParameter, Parameter positionRelatedOutputParam,
ref int funcCounter )
{
Operand.OpMask indexMask = IndexToMask( index );
FunctionInvocation curFuncInvocation = null;
//multiply position with world matrix and put into temporary param
curFuncInvocation = new FunctionInvocation( SGXFuncBlendWeight,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramInWeights, Operand.OpSemantic.In, indexMask );
curFuncInvocation.PushOperand( worldMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( positionTempParameter, 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( positionTempParameter, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( positionRelatedOutputParam, 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( positionTempParameter, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( positionRelatedOutputParam, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( positionRelatedOutputParam, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
}
private void AdjustForCorrectAntipodality( Function vsMain, int index, ref int funcCounter,
Parameter tempWorldMatrix )
{
FunctionInvocation curFuncInvocation = null;
//Antipodality doesn't need to be adjusted for dq0 on itself (used as the basis of antipodality calculations)
if ( index > 0 )
{
curFuncInvocation = new FunctionInvocation( SGXFuncAntipodalityAdjustment,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
//This is the base dual quaternion dq0, which the antipodality calculations are based on
curFuncInvocation.PushOperand( this.paramInitialDQ, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramTempFloat2x4, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( tempWorldMatrix, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
else if ( index == 0 )
{
//Set the first dual quaternion as the initial dq
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( this.paramTempFloat2x4, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramInitialDQ, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
}
private void AddNormalRelatedCalculations( Function vsMain, Parameter normalRelatedParam,
Parameter normalWorldRelatedParam, ref int funcCounter )
{
FunctionInvocation curFuncInvocation = null;
if ( doBoneCalculations )
{
if ( scalingShearingSupport )
{
//Calculate the adjoint transpose of the blended scaling and shearing matrix
curFuncInvocation = new FunctionInvocation( DualQuaternionSkinning.SGXFuncAdjointTransposeMatrix,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( this.paramBlendS, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramTempFloat3x3, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Transform the normal by the adjoint transpose of the blended scaling and shearing matrix
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( this.paramTempFloat3x3, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( normalRelatedParam, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( normalRelatedParam, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Need to normalize again after transforming the normal
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncNormalize,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( normalRelatedParam, Operand.OpSemantic.InOut );
vsMain.AddAtomInstance( curFuncInvocation );
}
//Transform the normal according to the dual quaternion
curFuncInvocation = new FunctionInvocation( DualQuaternionSkinning.SGXFuncCalculateBlendNormal,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( normalRelatedParam, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramBlendDQ, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( normalWorldRelatedParam, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//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 from object to world space
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 );
}
}
protected bool AddVSInvocation( Function vsMain, int groupOrder, int internalCounter )
{
FunctionInvocation curFuncInvocation = null;
//Construct TNB matrix.
if ( this.normalMapSpace == RTShaderSystem.NormalMapSpace.Tangent )
{
curFuncInvocation = new FunctionInvocation( SGXFuncConstructTbnMatrix, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.vsInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsInTangent, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsTBNMatrix, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
//Output texture coordinates
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.vsInTexcoord, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsOutTexcoord, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//computer world space position
if ( this.vsWorldPosition != null )
{
curFuncInvocation = new FunctionInvocation( SGXFuncTransformPosition, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.worldMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsInPosition, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsWorldPosition, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
//compute the view vector
if ( this.vsInPosition != null && this.vsOutView != null )
{
//View vector in world space
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncSubtract, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.camPosWorldSpace, Operand.OpSemantic.In,
( (int)Operand.OpMask.X | (int)Operand.OpMask.Y | (int)Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.vsWorldPosition, Operand.OpSemantic.In,
( (int)Operand.OpMask.X | (int)Operand.OpMask.Y | (int)Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Transform to object space.
curFuncInvocation = new FunctionInvocation( SGXFuncTranformNormal, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.worldInvRotMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Transform to tangent space
if ( this.normalMapSpace == RTShaderSystem.NormalMapSpace.Tangent )
{
curFuncInvocation = new FunctionInvocation( SGXFuncTranformNormal, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.vsTBNMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsOutView, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
//output object space
else if ( this.normalMapSpace == RTShaderSystem.NormalMapSpace.Object )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsOutView, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
}
//Add per light functions
for ( int i = 0; i < this.lightParamsList.Count; i++ )
{
if ( AddVSIlluminationInvocation( this.lightParamsList[ i ], vsMain, groupOrder, ref internalCounter ) ==
false )
{
return false;
}
}
return true;
}
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;
}
internal bool AddVSIlluminationInvocation( LightParams curLightParams, Function vsMain, int groupOrder,
ref int internalCounter )
{
FunctionInvocation curFuncInvocation = null;
//Computer light direction in texture space.
if ( curLightParams.Direction != null && curLightParams.VSOutDirection != null )
{
//Transform to texture space.
if ( this.normalMapSpace == RTShaderSystem.NormalMapSpace.Tangent )
{
curFuncInvocation = new FunctionInvocation( SGXFuncTranformNormal, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.vsTBNMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.Direction, Operand.OpSemantic.In,
( (int)Operand.OpMask.X | (int)Operand.OpMask.Y |
(int)Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.VSOutDirection, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
//Output object space
else if ( this.normalMapSpace == RTShaderSystem.NormalMapSpace.Object )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( curLightParams.Direction, Operand.OpSemantic.In,
( (int)Operand.OpMask.X | (int)Operand.OpMask.Y |
(int)Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.VSOutDirection, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
}
//Transform light vector to target space
if ( curLightParams.Position != null && curLightParams.VSOutToLightDir != null )
{
//Compute light vector.
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncSubtract, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( curLightParams.Position, Operand.OpSemantic.In,
( (int)Operand.OpMask.X | (int)Operand.OpMask.Y | (int)Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.vsWorldPosition, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Transform to object space
curFuncInvocation = new FunctionInvocation( SGXFuncTranformNormal, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.worldInvRotMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
if ( this.normalMapSpace == RTShaderSystem.NormalMapSpace.Tangent )
{
curFuncInvocation = new FunctionInvocation( SGXFuncTranformNormal, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.vsTBNMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.VSOutToLightDir, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
//Output object space
else if ( this.normalMapSpace == RTShaderSystem.NormalMapSpace.Object )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.vsLocalDir, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.VSOutToLightDir, 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;
}
protected bool AddPSNormalFetchInvocation( Function psMain, int groupOrder, ref int internalCounter )
{
FunctionInvocation curFuncInvocation = null;
curFuncInvocation = new FunctionInvocation( SGXFuncFetchNormal, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.normalMapSampler, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psInTexcoord, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psNormal, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
return true;
}
private void AddNormalRelatedCalculations(Function vsMain, Parameter normalRelatedParam,
Parameter normalWorldRelatedParam, ref int funcCounter)
{
FunctionInvocation curFuncInvocation = null;
if (doBoneCalculations)
{
if (scalingShearingSupport)
{
//Calculate the adjoint transpose of the blended scaling and shearing matrix
curFuncInvocation = new FunctionInvocation(DualQuaternionSkinning.SGXFuncAdjointTransposeMatrix,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramBlendS, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramTempFloat3x3, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Transform the normal by the adjoint transpose of the blended scaling and shearing matrix
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramTempFloat3x3, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(normalRelatedParam, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(normalRelatedParam, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Need to normalize again after transforming the normal
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncNormalize,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(normalRelatedParam, Operand.OpSemantic.InOut);
vsMain.AddAtomInstance(curFuncInvocation);
}
//Transform the normal according to the dual quaternion
curFuncInvocation = new FunctionInvocation(DualQuaternionSkinning.SGXFuncCalculateBlendNormal,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(normalRelatedParam, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramBlendDQ, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(normalWorldRelatedParam, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//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 from object to world space
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 AddPsInvocations( Function psMain, int groupOrder )
{
FunctionInvocation funcInvocation = null;
int internalCounter = 0;
funcInvocation = new FunctionInvocation( SGXFuncApplyReflectionMap, groupOrder, internalCounter++ );
funcInvocation.PushOperand( this.maskMapSampler, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.psInMaskTexcoord, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.reflectionMapSampler, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.psInReflectionTexcoord, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
funcInvocation.PushOperand( this.reflectionPower, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( funcInvocation );
return true;
}
private bool AddPsInvocations( Function psMain, int groupOrder )
{
FunctionInvocation funcInvocation = null;
int internalCounter = 0;
funcInvocation = new FunctionInvocation( SGXFuncInstancedViewportsDiscardOutOfBounds, groupOrder, internalCounter++ );
funcInvocation.PushOperand( this.psInMonitorsCount, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.psInMonitorIndex, Operand.OpSemantic.In );
funcInvocation.PushOperand( this.psInPositionProjectiveSpace, Operand.OpSemantic.In );
psMain.AddAtomInstance( funcInvocation );
return true;
}
protected virtual void AddPSBlendInvocations( Function psMain, Parameter arg1, Parameter arg2, Parameter texel,
int samplerIndex, LayerBlendModeEx blendMode,
int groupOrder, ref int internalCounter, int targetChannels )
{
FunctionInvocation curFuncInvocation = null;
switch ( blendMode.operation )
{
case LayerBlendOperationEx.Add:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAdd, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.AddSigned:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAddSigned, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.AddSmooth:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAddSmooth, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.BlendCurrentAlpha:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncLerp, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
if ( samplerIndex == 0 )
{
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In, Operand.OpMask.W );
}
else
{
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.In, Operand.OpMask.W );
}
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.BlendDiffuseAlpha:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncSubtract, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In, Operand.OpMask.W );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.BlendDiffuseColor:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncLerp, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.BlendManual:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncLerp, groupOrder, internalCounter );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( blendMode.blendFactor ),
Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.BlendTextureAlpha:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncLerp, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( texel, Operand.OpSemantic.In, Operand.OpMask.W );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.DotProduct:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncDotProduct, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.Modulate:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulate, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.ModulateX2:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulateX2, groupOrder,
internalCounter );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.ModulateX4:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulateX4, groupOrder,
internalCounter );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.Source1:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.Source2:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendOperationEx.Subtract:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncSubtract, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( arg1, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( arg2, Operand.OpSemantic.In, targetChannels );
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.Out, targetChannels );
psMain.AddAtomInstance( curFuncInvocation );
break;
}
}
private bool AddPSGlobalIlluminationInvocation( Function psMain, 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.psTempDiffuseColor, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
}
else
{
if ( ( this.trackVertexColorType & TrackVertexColor.Ambient ) != 0 )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulate, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.lightAmbientColor, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
}
else
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.derivedAmbientLightColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( curFuncInvocation );
}
if ( ( this.trackVertexColorType & TrackVertexColor.Emissive ) != 0 )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAdd, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
}
else
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAdd, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.surfaceEmissiveColor, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
}
}
if ( this.specularEnable )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++ );
curFuncInvocation.PushOperand( this.psSpecular, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
}
return true;
}
protected virtual void AddPSArgumentInvocations( Function psMain, Parameter arg, Parameter texel,
int samplerIndex, LayerBlendSource blendSrc, ColorEx colorValue,
Real alphaValue, bool isAlphaArgument, int groupOrder,
ref int internalCounter )
{
FunctionInvocation curFuncInvocation = null;
switch ( blendSrc )
{
case LayerBlendSource.Current:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder, internalCounter++ );
if ( samplerIndex == 0 )
{
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In );
}
else
{
curFuncInvocation.PushOperand( this.psOutDiffuse, Operand.OpSemantic.In );
}
curFuncInvocation.PushOperand( arg, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendSource.Texture:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( texel, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( arg, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendSource.Specular:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psSpecular, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( arg, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendSource.Diffuse:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( arg, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
break;
case LayerBlendSource.Manual:
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncConstruct, groupOrder,
internalCounter++ );
if ( isAlphaArgument )
{
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( alphaValue ),
Operand.OpSemantic.In );
}
else
{
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( colorValue.r ),
Operand.OpSemantic.In );
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( colorValue.g ),
Operand.OpSemantic.In );
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( colorValue.b ),
Operand.OpSemantic.In );
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( colorValue.a ),
Operand.OpSemantic.In );
}
curFuncInvocation.PushOperand( arg, Operand.OpSemantic.In );
psMain.AddAtomInstance( curFuncInvocation );
break;
}
}
internal bool AddPSIlluminationInvocation( LightParams curLightParams, Function psMain, int groupOrder,
ref int internalCounter )
{
FunctionInvocation curFuncInvocation = null;
//merge diffuse color with vertex color if need to
if ( ( this.trackVertexColorType & TrackVertexColor.Diffuse ) != 0 )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulate, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.DiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.DiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( curFuncInvocation );
}
//merge specular color with vertex color if need to
if ( this.specularEnable && ( this.trackVertexColorType & TrackVertexColor.Specular ) != 0 )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulate, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psDiffuse, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.SpecularColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.SpecularColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( curFuncInvocation );
}
switch ( curLightParams.Type )
{
case LightType.Directional:
if ( this.specularEnable )
{
curFuncInvocation = new FunctionInvocation( SGXFuncLightDirectionalDiffuseSpecular, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psInViewPos, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.Direction, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.DiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.SpecularColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.surfaceShininess, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( curFuncInvocation );
}
else
{
curFuncInvocation = new FunctionInvocation( SGXFuncLightDirectionalDiffuse, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.Direction, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.DiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( curFuncInvocation );
}
break;
case LightType.Point:
if ( this.specularEnable )
{
curFuncInvocation = new FunctionInvocation( SGXFuncLightPointDiffuseSpecular, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psInViewPos, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.Position, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.AttenuatParams, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.DiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.SpecularColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.surfaceShininess, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( curFuncInvocation );
}
else
{
curFuncInvocation = new FunctionInvocation( SGXFuncLightPointDiffuse, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psInViewPos, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.Position, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.AttenuatParams, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.DiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.AddAtomInstance( curFuncInvocation );
}
break;
case LightType.Spotlight:
if ( this.specularEnable )
{
curFuncInvocation = new FunctionInvocation( SGXFuncLightSpotDiffuseSpecular, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psInViewPos, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.Position, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.Direction, Operand.OpSemantic.In,
(int)( 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,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.SpecularColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.surfaceShininess, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempSpecularColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
}
else
{
curFuncInvocation = new FunctionInvocation( SGXFuncLightSpotDiffuse, groupOrder,
internalCounter++ );
curFuncInvocation.PushOperand( this.psInNormal, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.psInViewPos, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( curLightParams.Position, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( curLightParams.Direction, Operand.OpSemantic.In,
(int)( 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,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.psTempDiffuseColor, Operand.OpSemantic.Out,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
psMain.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;
}
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 AddVSFunctionInvocations( TextureUnitParams textureUnitParams, Function vsMain )
{
FunctionInvocation texCoordCalcFunc = null;
switch ( textureUnitParams.TexCoordCalcMethod )
{
case TexCoordCalcMethod.None:
if ( textureUnitParams.TextureMatrix == null )
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( textureUnitParams.VSInputTexCoord, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
else
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFuncTransformTexCoord,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( textureUnitParams.TextureMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSInputTexCoord, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
break;
case TexCoordCalcMethod.EnvironmentMap:
case TexCoordCalcMethod.EnvironmentMapPlanar:
if ( textureUnitParams.TextureMatrix == null )
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFunGenerateTexcoordEnvSphere,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( this.worldITMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.viewMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputNormal, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
else
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFunGenerateTexcoordEnvSphere,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( this.worldITMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.viewMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.TextureMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputNormal, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
break;
case TexCoordCalcMethod.EnvironmentMapReflection:
if ( textureUnitParams.TextureMatrix == null )
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFuncGenerateTexCoordEnvReflect,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( this.worldMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.worldITMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.viewMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputNormal, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputPos, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
else
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFuncGenerateTexCoordEnvReflect,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( this.worldMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.worldITMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.viewMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.TextureMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputNormal, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputPos, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
break;
case TexCoordCalcMethod.EnvironmentMapNormal:
if ( textureUnitParams.TextureMatrix == null )
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFuncGenerateTexcoordEnvNormal,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( this.worldITMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.viewMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputPos, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
else
{
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFuncGenerateTexcoordEnvNormal,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( this.worldITMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.viewMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.TextureMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputNormal, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
}
break;
case TexCoordCalcMethod.ProjectiveTexture:
texCoordCalcFunc = new FunctionInvocation( FFPRenderState.FFPFuncGenerateTexCoordProjection,
(int)FFPRenderState.FFPVertexShaderStage.VSTexturing,
textureUnitParams.TextureSamplerIndex );
texCoordCalcFunc.PushOperand( this.worldMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.TextureViewProjImageMatrix, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( this.vsInputPos, Operand.OpSemantic.In );
texCoordCalcFunc.PushOperand( textureUnitParams.VSOutputTexCoord, Operand.OpSemantic.Out );
break;
}
if ( texCoordCalcFunc != null )
{
vsMain.AddAtomInstance( texCoordCalcFunc );
}
return true;
}
/// <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 AddPositionCalculations( Function vsMain, ref int funcCounter )
{
FunctionInvocation curFuncInvocation = null;
if ( doBoneCalculations )
{
if ( scalingShearingSupport )
{
//Construct a scaling and shearing matrix based on the blend weights
for ( int i = 0; i < WeightCount; i++ )
{
//Assign the local param based on the current index of the scaling and shearing matrices
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( this.paramInScaleShearMatrices, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramInIndices, Operand.OpSemantic.In, (int)IndexToMask( i ), 1 );
curFuncInvocation.PushOperand( this.paramTempFloat3x4, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Calculate the resultant scaling and shearing matrix based on the weigts given
AddIndexedPositionWeight( vsMain, i, this.paramTempFloat3x4, this.paramTempFloat3x4, this.paramBlendS,
ref funcCounter );
}
//Transform the position based on the scaling and shearing matrix
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( this.paramBlendS, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramInPosition, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.paramLocalBlendPosition, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
else
{
//Assign the input position to the local blended position
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramInPosition, Operand.OpSemantic.In,
(int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z ) );
curFuncInvocation.PushOperand( this.paramLocalBlendPosition, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
//Set functions to calculate world position
for ( int i = 0; i < weightCount; i++ )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramInIndices, Operand.OpSemantic.In, (int)IndexToMask( i ) );
curFuncInvocation.PushOperand( this.paramIndex1, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//multiply the index by 2
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulate,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( 2.0f ), Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramIndex1, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramIndex1, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Add 1 to the index and assign as the second row's index
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAdd,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( 1.0f ), Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramIndex1, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramIndex2, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Build the dual quaternion matrix
curFuncInvocation = new FunctionInvocation(
DualQuaternionSkinning.SGXFuncBuildDualQuaternionMatrix,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++ );
curFuncInvocation.PushOperand( paramInWorldMatrices, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramIndex1, Operand.OpSemantic.In, (int)Operand.OpMask.All, 1 );
curFuncInvocation.PushOperand( paramInWorldMatrices, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramIndex2, Operand.OpSemantic.In, (int)Operand.OpMask.All, 1 );
curFuncInvocation.PushOperand( this.paramTempFloat2x4, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
if ( correctAntipodalityHandling )
{
AdjustForCorrectAntipodality( vsMain, i, ref funcCounter, this.paramTempFloat2x4 );
}
//Calculate the resultant dual quaternion based based on the weights given
AddIndexedPositionWeight( vsMain, i, this.paramTempFloat2x4, this.paramTempFloat2x4, this.paramBlendDQ,
ref funcCounter );
}
//Normalize the dual quaternion
curFuncInvocation = new FunctionInvocation( DualQuaternionSkinning.SGXFuncNormalizeDualQuaternion,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( this.paramBlendDQ, Operand.OpSemantic.InOut );
vsMain.AddAtomInstance( curFuncInvocation );
//Calculate the blend position
curFuncInvocation = new FunctionInvocation( DualQuaternionSkinning.SGXFuncCalculateBlendPosition,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( this.paramLocalBlendPosition, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( this.paramBlendDQ, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramTempFloat4, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//Update from object to projective space
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramInViewProjMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramTempFloat4, 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( paramInWorldMatrices, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramInPosition, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramLocalPositionWorld, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//update from object 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 );
}
}