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 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 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);
}
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);
}
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 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 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;
}
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;
}
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 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;
}
}
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;
}
}
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 );
}
}
protected virtual void AddPSSampleTexelInvocation( TextureUnitParams textureUnitParams, Function psMain,
Parameter texel, int groupOrder, ref int internalCounter )
{
FunctionInvocation curFuncInvocation = null;
if ( textureUnitParams.TexCoordCalcMethod == TexCoordCalcMethod.ProjectiveTexture )
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncSamplerTextureProj, groupOrder,
internalCounter++ );
}
else
{
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncSampleTexture, groupOrder,
internalCounter++ );
}
curFuncInvocation.PushOperand( textureUnitParams.TextureSampler, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( textureUnitParams.PSInputTexCoord, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( texel, Operand.OpSemantic.Out );
psMain.AddAtomInstance( curFuncInvocation );
}
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 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 );
}
}
private void AddIndexedNormalRelatedWeight( Function vsMain, Parameter normalRelatedParam,
Parameter normalWorldRelatedParam, int index, ref int funcCounter )
{
FunctionInvocation curFuncInvocation;
Operand.OpMask indexMask = IndexToMask( index );
//multiply position with world matrix and put into temporary param
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramInWorldMatrices, Operand.OpSemantic.In, (int)Operand.OpMask.All );
curFuncInvocation.PushOperand( paramInIndices, Operand.OpSemantic.In, (int)indexMask, 1 );
curFuncInvocation.PushOperand( normalRelatedParam, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramTempFloat3, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//multiply temporary param with weight
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulate,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramTempFloat3, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramInWeights, Operand.OpSemantic.In, (int)indexMask );
curFuncInvocation.PushOperand( paramTempFloat3, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//check if on first iteration
if ( index == 0 )
{
//set the local param as the value of the world normal
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramTempFloat3, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( normalWorldRelatedParam, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( normalWorldRelatedParam, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
else
{
//add the local param as the value of the world normal
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAdd,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramTempFloat3, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( normalWorldRelatedParam, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( normalWorldRelatedParam, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
}
private void 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 AddIndexedPositionWeight( Function vsMain, int index, ref int funcCounter )
{
Operand.OpMask indexMask = IndexToMask( index );
FunctionInvocation curFuncInvocation;
var outputMask = (int)( Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z );
if ( paramInWorldMatrices.Type == GpuProgramParameters.GpuConstantType.Matrix_4X4 )
{
outputMask = (int)Operand.OpMask.All;
}
//multiply posiiton with world matrix and put into temporary param
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramInWorldMatrix, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramInIndices, Operand.OpSemantic.In, (int)indexMask, 1 );
curFuncInvocation.PushOperand( paramInPosition, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramTempFloat4, Operand.OpSemantic.Out, outputMask );
vsMain.AddAtomInstance( curFuncInvocation );
//set w value of temporary param to 1
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( ParameterFactory.CreateConstParamFloat( 1.0f ), Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramTempFloat4, Operand.OpSemantic.Out, (int)Operand.OpMask.W );
vsMain.AddAtomInstance( curFuncInvocation );
//multiply temporary param with weight
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncModulate,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramTempFloat4, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramInWeights, Operand.OpSemantic.In, (int)indexMask );
curFuncInvocation.PushOperand( paramTempFloat4, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
//check if on first iteration
if ( index == 0 )
{
//set the local param as the value of the world param
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramTempFloat4, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramLocalPositionWorld, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
else
{
//add the local param as the value of the world param
curFuncInvocation = new FunctionInvocation( FFPRenderState.FFPFuncAdd,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++ );
curFuncInvocation.PushOperand( paramTempFloat4, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramLocalPositionWorld, Operand.OpSemantic.In );
curFuncInvocation.PushOperand( paramLocalPositionWorld, Operand.OpSemantic.Out );
vsMain.AddAtomInstance( curFuncInvocation );
}
}
protected 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 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 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 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);
}
}
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 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 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;
}
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 );
}
}
