public UniformParameter(GpuProgramParameters.AutoConstantType autoConstantType, int autoConstantData, int size)
: base(
Parameter.AutoParameters[autoConstantType].Type, Parameter.AutoParameters[autoConstantType].Name,
SemanticType.Unknown, -1, ContentType.Unknown, size)
{
AutoShaderParameter parameterDef = Parameter.AutoParameters[autoConstantType];
_name = parameterDef.Name;
if (autoConstantData != 0)
{
_name += autoConstantData.ToString();
}
_type = parameterDef.Type;
_semantic = SemanticType.Unknown;
_index = -1;
_content = Parameter.ContentType.Unknown;
this.isAutoConstantInt = true;
this.isAutoConstantReal = false;
this.autoConstantType = autoConstantType;
this.autoConstantIntData = autoConstantData;
this.variability = (int)GpuProgramParameters.GpuParamVariability.Global;
this._params = null;
this.physicalIndex = -1;
_size = size;
}
public UniformParameter(GpuProgramParameters.AutoConstantType autoConstantType, Real autoConstantData, int size,
GpuProgramParameters.GpuConstantType type)
: base(
Parameter.AutoParameters[autoConstantType].Type, Parameter.AutoParameters[autoConstantType].Name,
SemanticType.Unknown, -1, ContentType.Unknown, size)
{
AutoShaderParameter parameterDef = Parameter.AutoParameters[autoConstantType];
_name = parameterDef.Name;
if (autoConstantData != 0.0)
{
_name += autoConstantData.ToString();
//replace possible illegal point character in name
_name = _name.Replace('.', '_');
}
_type = type;
_semantic = SemanticType.Unknown;
_index = -1;
_content = Parameter.ContentType.Unknown;
this.isAutoConstantReal = true;
this.isAutoConstantInt = false;
this.autoConstantType = autoConstantType;
this.autoConstantRealData = autoConstantData;
this.variability = (int)GpuProgramParameters.GpuParamVariability.Global;
this._params = null;
this.physicalIndex = -1;
_size = size;
}
public static void SetAuto <T>(this Shader shader, Expression <Func <T> > loc,
GpuProgramParameters.AutoConstantType ac, uint extraInfo)
{
var name = Shader.UniformName(loc);
var prog = (Program)shader.Program;
prog.SetAuto(name, ac, extraInfo);
}
public UniformParameter GetParameterByAutoType(GpuProgramParameters.AutoConstantType autoType)
{
foreach (var param in this.parameters)
{
if (param.IsAutoConstantParameter && param.AutoConstantType == autoType)
{
return(param);
}
}
return(null);
}
/// <summary>
/// Resolve uniform auto constant parameter with associated int data of this program
/// </summary>
/// <param name="autoType"> The auto type of the desried parameter </param>
/// <param name="data"> The data to associate with the auto parameter </param>
/// <param name="size"> number of elements in the parameter </param>
/// <returns> </returns>
public UniformParameter ResolveAutoParameterInt(GpuProgramParameters.AutoConstantType autoType, int data,
int size)
{
UniformParameter param = null;
//check if parameter already exits.
param = GetParameterByAutoType(autoType);
if (param != null)
{
if (param.IsAutoConstantIntParameter && param.AutoConstantIntData == data)
{
param.Size = Axiom.Math.Utility.Max(size, param.Size);
return(param);
}
}
//Create new parameter
param = new UniformParameter(autoType, data, size);
AddParameter(param);
return(param);
}
/// <summary>
/// Resolve uniform auto constant parameter with associated real data of this program
/// </summary>
/// <param name="autoType"> The auto type of the desired parameter </param>
/// <param name="type"> The desried data type of the auto parameter </param>
/// <param name="data"> The data to associate with the auto parameter </param>
/// <param name="size"> number of elements in the parameter </param>
/// <returns> parameter instance in case of that resolve operation succeeded, otherwise null </returns>
public UniformParameter ResolveAutoParameterReal(GpuProgramParameters.AutoConstantType autoType,
Axiom.Graphics.GpuProgramParameters.GpuConstantType type,
Real data, int size)
{
UniformParameter param = null;
//check if parameter already exists
param = GetParameterByAutoType(autoType);
if (param != null)
{
if (param.IsAutoConstantRealParameter && param.AutoConstantRealData == data)
{
param.Size = Axiom.Math.Utility.Max(size, param.Size);
return(param);
}
}
//Create new parameter
param = new UniformParameter(autoType, data, size, type);
AddParameter(param);
return(param);
}
public void SetAuto(string name, GpuProgramParameters.AutoConstantType ac, uint extraInfo)
{
Pass.GetVertexProgramParameters().SetNamedAutoConstant(name, ac, extraInfo);
//_pass.GetFragmentProgramParameters().SetNamedAutoConstant(name, ac);
}
public UniformParameter ResolveAutoParameterInt(GpuProgramParameters.AutoConstantType autoType, int data)
{
return(ResolveAutoParameterInt(autoType, data, 0));
}
internal override bool ResolveParameters(ProgramSet programSet)
{
Program vsProgram = programSet.CpuVertexProgram;
Function vsMain = vsProgram.EntryPointFunction;
//if needed mark this vertex program as hardware skinned
if (DoBoneCalculations)
{
vsProgram.SkeletalAnimationIncluded = true;
}
//get the parameters we need whther we are doing bone calculations or not
//note in order t be consistent we will always output position, normal,
//tangent, and binormal in both object and world space. And output position
//in projective space to cover the responsibility of the transform stage
//input param
paramInPosition = vsMain.ResolveInputParameter(Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4);
paramInNormal = vsMain.ResolveInputParameter(Parameter.SemanticType.Normal, 0,
Parameter.ContentType.NormalObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3);
paramInBiNormal = vsMain.ResolveInputParameter(Parameter.SemanticType.Binormal, 0,
Parameter.ContentType.BinormalObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3);
paramInTangent = vsMain.ResolveInputParameter(Parameter.SemanticType.Tangent, 0,
Parameter.ContentType.TangentObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3);
//local param
paramLocalPositionWorld = vsMain.ResolveLocalParameter(Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4);
paramLocalNormalWorld = vsMain.ResolveLocalParameter(Parameter.SemanticType.Normal, 0,
Parameter.ContentType.NormalWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3);
paramLocalTangentWorld = vsMain.ResolveLocalParameter(Parameter.SemanticType.Tangent, 0,
Parameter.ContentType.TangentWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3);
paramLocalBiNormalWorld = vsMain.ResolveLocalParameter(Parameter.SemanticType.Binormal, 0,
Parameter.ContentType.BinormalWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3);
//output param
paramOutPositionProj = vsMain.ResolveOutputParameter(Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionProjectiveSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4);
//check if parameter retrieval went well
bool isValid =
(paramInPosition != null &&
paramInNormal != null &&
paramInBiNormal != null &&
paramInTangent != null &&
paramLocalPositionWorld != null &&
paramLocalNormalWorld != null &&
paramLocalTangentWorld != null &&
paramLocalBiNormalWorld != null &&
paramOutPositionProj != null);
if (doBoneCalculations)
{
GpuProgramParameters.AutoConstantType worldMatrixType =
GpuProgramParameters.AutoConstantType.WorldMatrixArray3x4;
if (ShaderGenerator.Instance.TargetLangauge == "hlsl")
{
//given that hlsl shaders use column major matrices which are not compatible with the cg
//and glsl method of row major matrices, we will use a full matrix instead
worldMatrixType = GpuProgramParameters.AutoConstantType.WorldMatrixArray;
}
//input parameters
paramInNormal = vsMain.ResolveInputParameter(Parameter.SemanticType.Normal, 0,
Parameter.ContentType.NormalObjectSpace,
GpuProgramParameters.GpuConstantType.Float3);
paramInBiNormal = vsMain.ResolveInputParameter(Parameter.SemanticType.Binormal, 0,
Parameter.ContentType.BinormalObjectSpace,
GpuProgramParameters.GpuConstantType.Float3);
paramInTangent = vsMain.ResolveInputParameter(Parameter.SemanticType.Tangent, 0,
Parameter.ContentType.TangentObjectSpace,
GpuProgramParameters.GpuConstantType.Float3);
paramInIndices = vsMain.ResolveInputParameter(Parameter.SemanticType.BlendIndicies, 0,
Parameter.ContentType.Unknown,
GpuProgramParameters.GpuConstantType.Float4);
paramInWeights = vsMain.ResolveInputParameter(Parameter.SemanticType.BlendWeights, 0,
Parameter.ContentType.Unknown,
GpuProgramParameters.GpuConstantType.Float4);
paramInWorldMatrices = vsProgram.ResolveAutoParameterInt(worldMatrixType, 0, boneCount);
paramInInvWorldMatrix =
vsProgram.ResolveAutoParameterInt(GpuProgramParameters.AutoConstantType.InverseWorldMatrix, 0);
paramInViewProjMatrix =
vsProgram.ResolveAutoParameterInt(GpuProgramParameters.AutoConstantType.ViewProjMatrix, 0);
paramTempFloat4 = vsMain.ResolveLocalParameter(Parameter.SemanticType.Unknown, -1, "TempVal4",
GpuProgramParameters.GpuConstantType.Float3);
paramTempFloat3 = vsMain.ResolveLocalParameter(Parameter.SemanticType.Unknown, -1, "TempVal3",
GpuProgramParameters.GpuConstantType.Float3);
//check if parameter retrival went well
isValid &=
(paramInIndices != null &&
paramInWeights != null &&
paramInWorldMatrices != null &&
paramInViewProjMatrix != null &&
paramInInvWorldMatrix != null &&
paramTempFloat4 != null &&
paramTempFloat3 != null);
}
else
{
paramInWorldMatrices =
vsProgram.ResolveAutoParameterInt(GpuProgramParameters.AutoConstantType.WorldMatrix, 0);
paramInWorldViewProjMatrix =
vsProgram.ResolveAutoParameterInt(GpuProgramParameters.AutoConstantType.WorldViewProjMatrix, 0);
//check if parameter retrieval went well
isValid &=
(paramInWorldMatrix != null &&
paramInWorldViewProjMatrix != null);
}
return(isValid);
}
