private void WriteStageString(PICATexEnvStage stage)
{
text.Append(" Color = ");
if (stage.IsColorPassThrough)
{
text.AppendLine("Passthrough");
}
else
{
WriteCombinerString(stage.Combiner.Color, stage.Source.Color, stage.Operand.Color);
text.Append($", (scale: {stage.Scale.Color})");
text.Append('\n');
}
text.Append(" Alpha = ");
if (stage.IsAlphaPassThrough)
{
text.AppendLine("Passthrough");
}
else
{
WriteCombinerString(stage.Combiner.Alpha, stage.Source.Alpha, stage.Operand.Alpha);
text.Append($", (scale: {stage.Scale.Color})");
text.Append('\n');
}
text.AppendLine($" Update Color Buffer: {stage.UpdateColorBuffer}");
text.AppendLine($" Update Alpha Buffer: {stage.UpdateAlphaBuffer}");
text.AppendLine($" Constant: {stage.Color}");
}
public GFShader()
{
TexEnvStages = new PICATexEnvStage[6];
for (int Index = 0; Index < TexEnvStages.Length; Index++)
{
TexEnvStages[Index] = new PICATexEnvStage();
}
}
private void GenCombinerAlpha(PICATexEnvStage Stage, string[] AlphaArgs)
{
switch (Stage.Combiner.Alpha)
{
case PICATextureCombinerMode.Replace:
SB.AppendLine($"\tOutput.a = ({AlphaArgs[0]});");
break;
case PICATextureCombinerMode.Modulate:
SB.AppendLine($"\tOutput.a = ({AlphaArgs[0]}) * ({AlphaArgs[1]});");
break;
case PICATextureCombinerMode.Add:
SB.AppendLine($"\tOutput.a = min(({AlphaArgs[0]}) + ({AlphaArgs[1]}), 1);");
break;
case PICATextureCombinerMode.AddSigned:
SB.AppendLine($"\tOutput.a = clamp(({AlphaArgs[0]}) + ({AlphaArgs[1]}) - 0.5, 0, 1);");
break;
case PICATextureCombinerMode.Interpolate:
SB.AppendLine($"\tOutput.a = mix(({AlphaArgs[1]}), ({AlphaArgs[0]}), ({AlphaArgs[2]}));");
break;
case PICATextureCombinerMode.Subtract:
SB.AppendLine($"\tOutput.a = max(({AlphaArgs[0]}) - ({AlphaArgs[1]}), 0);");
break;
case PICATextureCombinerMode.DotProduct3Rgb:
SB.AppendLine($"\tOutput.a = min(dot(vec3({AlphaArgs[0]}), vec3({AlphaArgs[1]})), 1);");
break;
case PICATextureCombinerMode.DotProduct3Rgba:
SB.AppendLine($"\tOutput.a = min(dot(vec4({AlphaArgs[0]}), vec4({AlphaArgs[1]})), 1);");
break;
case PICATextureCombinerMode.MultAdd:
SB.AppendLine($"\tOutput.a = min(({AlphaArgs[0]}) * ({AlphaArgs[1]}) + ({AlphaArgs[2]}), 1);");
break;
case PICATextureCombinerMode.AddMult:
SB.AppendLine($"\tOutput.a = min(({AlphaArgs[0]}) + ({AlphaArgs[1]}), 1) * ({AlphaArgs[2]});");
break;
}
}
private void GenCombinerColor(PICATexEnvStage Stage, string[] ColorArgs)
{
switch (Stage.Combiner.Color)
{
case PICATextureCombinerMode.Replace:
SB.AppendLine($"\tOutput.rgb = ({ColorArgs[0]}).rgb;");
break;
case PICATextureCombinerMode.Modulate:
SB.AppendLine($"\tOutput.rgb = ({ColorArgs[0]}).rgb * ({ColorArgs[1]}).rgb;");
break;
case PICATextureCombinerMode.Add:
SB.AppendLine($"\tOutput.rgb = min(({ColorArgs[0]}).rgb + ({ColorArgs[1]}).rgb, 1);");
break;
case PICATextureCombinerMode.AddSigned:
SB.AppendLine($"\tOutput.rgb = clamp(({ColorArgs[0]}).rgb + ({ColorArgs[1]}).rgb - 0.5, 0, 1);");
break;
case PICATextureCombinerMode.Interpolate:
SB.AppendLine($"\tOutput.rgb = mix(({ColorArgs[1]}).rgb, ({ColorArgs[0]}).rgb, ({ColorArgs[2]}).rgb);");
break;
case PICATextureCombinerMode.Subtract:
SB.AppendLine($"\tOutput.rgb = max(({ColorArgs[0]}).rgb - ({ColorArgs[1]}).rgb, 0);");
break;
case PICATextureCombinerMode.DotProduct3Rgb:
SB.AppendLine($"\tOutput.rgb = vec3(min(dot(({ColorArgs[0]}).rgb, ({ColorArgs[1]}).rgb), 1));");
break;
case PICATextureCombinerMode.DotProduct3Rgba:
SB.AppendLine($"\tOutput.rgb = vec3(min(dot(({ColorArgs[0]}), ({ColorArgs[1]})), 1));");
break;
case PICATextureCombinerMode.MultAdd:
SB.AppendLine($"\tOutput.rgb = min(({ColorArgs[0]}).rgb * ({ColorArgs[1]}).rgb + ({ColorArgs[2]}).rgb, 1);");
break;
case PICATextureCombinerMode.AddMult:
SB.AppendLine($"\tOutput.rgb = min(({ColorArgs[0]}).rgb + ({ColorArgs[1]}).rgb, 1) * ({ColorArgs[2]}).rgb;");
break;
}
}
public MTFragmentLighting(BinaryReader Reader)
{
Reader.BaseStream.Seek(0x4c, SeekOrigin.Current);
uint TexEnvStagesAddress = Reader.ReadUInt32();
Reader.BaseStream.Seek(TexEnvStagesAddress + 0xc, SeekOrigin.Begin);
TexEnvStages = new PICATexEnvStage[6];
for (int Stage = 0; Stage < 6; Stage++)
{
TexEnvStages[Stage] = new PICATexEnvStage()
{
Source = new PICATexEnvSource(Reader.ReadUInt32()),
Operand = new PICATexEnvOperand(Reader.ReadUInt32()),
Combiner = new PICATexEnvCombiner(Reader.ReadUInt32()),
Color = new RGBA(Reader.ReadUInt32()),
Scale = new PICATexEnvScale(Reader.ReadUInt32())
};
}
}
public GFShader(BinaryReader Reader) : this()
{
uint MagicNumber = Reader.ReadUInt32();
uint ShaderCount = Reader.ReadUInt32();
GFSection.SkipPadding(Reader.BaseStream);
GFSection ShaderSection = new GFSection(Reader);
Name = Reader.ReadPaddedString(0x40);
uint Hash = Reader.ReadUInt32();
uint Count = Reader.ReadUInt32();
GFSection.SkipPadding(Reader.BaseStream);
uint CommandsLength = Reader.ReadUInt32();
uint CommandsCount = Reader.ReadUInt32();
uint CommandsHash = Reader.ReadUInt32();
uint Padding = Reader.ReadUInt32();
string FileName = Reader.ReadPaddedString(0x40);
uint[] Commands = new uint[CommandsLength >> 2];
for (int Index = 0; Index < Commands.Length; Index++)
{
Commands[Index] = Reader.ReadUInt32();
}
uint[] OutMap = new uint[7];
List <uint> ShaderExecutable = new List <uint>();
List <ulong> ShaderSwizzles = new List <ulong>();
PICACommandReader CmdReader = new PICACommandReader(Commands);
while (CmdReader.HasCommand)
{
PICACommand Cmd = CmdReader.GetCommand();
uint Param = Cmd.Parameters[0];
int Stage = ((int)Cmd.Register >> 3) & 7;
if (Stage >= 6)
{
Stage -= 2;
}
switch (Cmd.Register)
{
/* Shader */
case PICARegister.GPUREG_SH_OUTMAP_O0: OutMap[0] = Param; break;
case PICARegister.GPUREG_SH_OUTMAP_O1: OutMap[1] = Param; break;
case PICARegister.GPUREG_SH_OUTMAP_O2: OutMap[2] = Param; break;
case PICARegister.GPUREG_SH_OUTMAP_O3: OutMap[3] = Param; break;
case PICARegister.GPUREG_SH_OUTMAP_O4: OutMap[4] = Param; break;
case PICARegister.GPUREG_SH_OUTMAP_O5: OutMap[5] = Param; break;
case PICARegister.GPUREG_SH_OUTMAP_O6: OutMap[6] = Param; break;
/* Fragment Shader */
case PICARegister.GPUREG_TEXENV0_SOURCE:
case PICARegister.GPUREG_TEXENV1_SOURCE:
case PICARegister.GPUREG_TEXENV2_SOURCE:
case PICARegister.GPUREG_TEXENV3_SOURCE:
case PICARegister.GPUREG_TEXENV4_SOURCE:
case PICARegister.GPUREG_TEXENV5_SOURCE:
TexEnvStages[Stage].Source = new PICATexEnvSource(Param);
break;
case PICARegister.GPUREG_TEXENV0_OPERAND:
case PICARegister.GPUREG_TEXENV1_OPERAND:
case PICARegister.GPUREG_TEXENV2_OPERAND:
case PICARegister.GPUREG_TEXENV3_OPERAND:
case PICARegister.GPUREG_TEXENV4_OPERAND:
case PICARegister.GPUREG_TEXENV5_OPERAND:
TexEnvStages[Stage].Operand = new PICATexEnvOperand(Param);
break;
case PICARegister.GPUREG_TEXENV0_COMBINER:
case PICARegister.GPUREG_TEXENV1_COMBINER:
case PICARegister.GPUREG_TEXENV2_COMBINER:
case PICARegister.GPUREG_TEXENV3_COMBINER:
case PICARegister.GPUREG_TEXENV4_COMBINER:
case PICARegister.GPUREG_TEXENV5_COMBINER:
TexEnvStages[Stage].Combiner = new PICATexEnvCombiner(Param);
break;
case PICARegister.GPUREG_TEXENV0_COLOR:
case PICARegister.GPUREG_TEXENV1_COLOR:
case PICARegister.GPUREG_TEXENV2_COLOR:
case PICARegister.GPUREG_TEXENV3_COLOR:
case PICARegister.GPUREG_TEXENV4_COLOR:
case PICARegister.GPUREG_TEXENV5_COLOR:
TexEnvStages[Stage].Color = new RGBA(Param);
break;
case PICARegister.GPUREG_TEXENV0_SCALE:
case PICARegister.GPUREG_TEXENV1_SCALE:
case PICARegister.GPUREG_TEXENV2_SCALE:
case PICARegister.GPUREG_TEXENV3_SCALE:
case PICARegister.GPUREG_TEXENV4_SCALE:
case PICARegister.GPUREG_TEXENV5_SCALE:
TexEnvStages[Stage].Scale = new PICATexEnvScale(Param);
break;
case PICARegister.GPUREG_TEXENV_UPDATE_BUFFER: PICATexEnvStage.SetUpdateBuffer(TexEnvStages, Param); break;
case PICARegister.GPUREG_TEXENV_BUFFER_COLOR: TexEnvBufferColor = new RGBA(Param); break;
/* Geometry Shader */
case PICARegister.GPUREG_GSH_ENTRYPOINT:
if (GeoShader == null)
{
GeoShader = new ShaderProgram();
}
GeoShader.MainOffset = Param & 0xffff;
break;
/* Vertex Shader */
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA0:
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA1:
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA2:
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA3:
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA4:
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA5:
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA6:
case PICARegister.GPUREG_VSH_CODETRANSFER_DATA7:
ShaderExecutable.AddRange(Cmd.Parameters);
break;
case PICARegister.GPUREG_VSH_OPDESCS_DATA0:
case PICARegister.GPUREG_VSH_OPDESCS_DATA1:
case PICARegister.GPUREG_VSH_OPDESCS_DATA2:
case PICARegister.GPUREG_VSH_OPDESCS_DATA3:
case PICARegister.GPUREG_VSH_OPDESCS_DATA4:
case PICARegister.GPUREG_VSH_OPDESCS_DATA5:
case PICARegister.GPUREG_VSH_OPDESCS_DATA6:
case PICARegister.GPUREG_VSH_OPDESCS_DATA7:
for (int i = 0; i < Cmd.Parameters.Length; i++)
{
ShaderSwizzles.Add(Cmd.Parameters[i]);
}
break;
case PICARegister.GPUREG_VSH_ENTRYPOINT:
if (VtxShader == null)
{
VtxShader = new ShaderProgram();
}
VtxShader.MainOffset = Param & 0xffff;
break;
}
}
Executable = ShaderExecutable.ToArray();
Swizzles = ShaderSwizzles.ToArray();
for (int i = 0; i < OutMap.Length; i++)
{
if (OutMap[i] == 0)
{
continue;
}
ShaderOutputReg Reg = new ShaderOutputReg();
for (int j = 0; j < 4; j++)
{
uint Value = (OutMap[i] >> j * 8) & 0x1f;
if (Value != 0x1f)
{
Reg.Mask |= 1u << j;
if (Value < 0x4)
{
Reg.Name = ShaderOutputRegName.Position;
}
else if (Value < 0x8)
{
Reg.Name = ShaderOutputRegName.QuatNormal;
}
else if (Value < 0xc)
{
Reg.Name = ShaderOutputRegName.Color;
}
else if (Value < 0xe)
{
Reg.Name = ShaderOutputRegName.TexCoord0;
}
else if (Value < 0x10)
{
Reg.Name = ShaderOutputRegName.TexCoord1;
}
else if (Value < 0x11)
{
Reg.Name = ShaderOutputRegName.TexCoord0W;
}
else if (Value < 0x12)
{
Reg.Name = ShaderOutputRegName.Generic;
}
else if (Value < 0x16)
{
Reg.Name = ShaderOutputRegName.View;
}
else if (Value < 0x18)
{
Reg.Name = ShaderOutputRegName.TexCoord2;
}
else
{
Reg.Name = ShaderOutputRegName.Generic;
}
}
}
if (VtxShader != null)
{
VtxShader.OutputRegs[i] = Reg;
}
if (GeoShader != null)
{
GeoShader.OutputRegs[i] = Reg;
}
}
HashSet <uint> Dsts = new HashSet <uint>();
uint LblId = 0;
for (uint i = 0; i < Executable.Length; i++)
{
ShaderOpCode OpCode = (ShaderOpCode)(Executable[i] >> 26);
if (OpCode == ShaderOpCode.Call ||
OpCode == ShaderOpCode.CallC ||
OpCode == ShaderOpCode.CallU ||
OpCode == ShaderOpCode.JmpC ||
OpCode == ShaderOpCode.JmpU)
{
uint Dst = (Executable[i] >> 10) & 0xfff;
if (!Dsts.Contains(Dst))
{
Dsts.Add(Dst);
string Name = "label_" + Dst.ToString("x4");
ShaderLabel Label = new ShaderLabel()
{
Id = LblId++,
Offset = Dst,
Length = 0,
Name = Name
};
if (VtxShader != null)
{
VtxShader.Labels.Add(Label);
}
if (GeoShader != null)
{
GeoShader.Labels.Add(Label);
}
}
}
}
MakeArray(VtxShader?.Vec4Uniforms, "v_c");
MakeArray(GeoShader?.Vec4Uniforms, "g_c");
FindProgramEnd(VtxShader, Executable);
FindProgramEnd(GeoShader, Executable);
VtxShaderUniforms = CmdReader.GetAllVertexShaderUniforms();
GeoShaderUniforms = CmdReader.GetAllGeometryShaderUniforms();
}
public GfxTexEnv()
{
Stage = new PICATexEnvStage();
}
public H3DMaterial ToH3DMaterial(Material mat)
{
H3DMaterial h3dMaterial = new H3DMaterial();
var matParams = h3dMaterial.MaterialParams;
if (mat.IsVertexLightingEnabled)
{
matParams.Flags |= H3DMaterialFlags.IsVertexLightingEnabled;
}
if (mat.IsFragmentLightingEnabled)
{
matParams.Flags |= H3DMaterialFlags.IsFragmentLightingEnabled;
}
if (mat.IsHemiSphereLightingEnabled)
{
matParams.Flags |= H3DMaterialFlags.IsHemiSphereLightingEnabled;
}
if (mat.IsHemiSphereOcclusionEnabled)
{
matParams.Flags |= H3DMaterialFlags.IsHemiSphereOcclusionEnabled;
}
switch (mat.LayerConfig)
{
case LayerConfig.LayerConfig0: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig0; break;
case LayerConfig.LayerConfig1: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig1; break;
case LayerConfig.LayerConfig2: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig2; break;
case LayerConfig.LayerConfig3: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig3; break;
case LayerConfig.LayerConfig4: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig4; break;
case LayerConfig.LayerConfig5: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig5; break;
case LayerConfig.LayerConfig6: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig6; break;
case LayerConfig.LayerConfig7: matParams.TranslucencyKind = H3DTranslucencyKind.LayerConfig7; break;
}
for (int i = 0; i < mat.TextureMappers?.Count; i++)
{
string texture = GetTextureName(mat.TextureMappers[i].TextureID);
if (texture == string.Empty)
{
continue;
}
if (i == 0)
{
h3dMaterial.Texture0Name = texture;
}
if (i == 0)
{
h3dMaterial.Texture1Name = texture;
}
if (i == 0)
{
h3dMaterial.Texture2Name = texture;
}
h3dMaterial.TextureMappers[i].WrapU = ConvertWrapMode(mat.TextureMappers[i].WrapU);
h3dMaterial.TextureMappers[i].WrapV = ConvertWrapMode(mat.TextureMappers[i].WrapV);
h3dMaterial.TextureMappers[i].MagFilter = ConvertTexMagFilter(mat.TextureMappers[i].TextureMagFilter);
h3dMaterial.TextureMappers[i].MinFilter = ConvertTexMinFilter(mat.TextureMappers[i].TextureMinFilter);
h3dMaterial.TextureMappers[i].LODBias = mat.TextureMappers[i].LODBias;
h3dMaterial.TextureMappers[i].MinLOD = (byte)(mat.TextureMappers[i].MinLODBias / 255);
h3dMaterial.TextureMappers[i].BorderColor = new SPICA.Math3D.RGBA(
mat.TextureMappers[i].BorderColor.R,
mat.TextureMappers[i].BorderColor.G,
mat.TextureMappers[i].BorderColor.B,
mat.TextureMappers[i].BorderColor.A);
matParams.TextureCoords[i].TransformType = H3DTextureTransformType.DccMaya;
matParams.TextureCoords[i].MappingType = H3DTextureMappingType.UvCoordinateMap;
matParams.TextureCoords[i].Scale = new System.Numerics.Vector2(
mat.TextureCoords[i].Scale.X, mat.TextureCoords[i].Scale.Y);
matParams.TextureCoords[i].Translation = new System.Numerics.Vector2(
mat.TextureCoords[i].Translation.X, mat.TextureCoords[i].Translation.Y);
matParams.TextureCoords[i].Rotation = mat.TextureCoords[i].Rotation;
}
matParams.DiffuseColor = ConvertRGBA(mat.DiffuseColor);
matParams.Specular0Color = ConvertRGBA(mat.Specular0Color);
matParams.Specular1Color = ConvertRGBA(mat.Specular1Color);
matParams.EmissionColor = ConvertRGBA(mat.EmissionColor);
matParams.Constant0Color = ConvertRGBA(mat.ConstantColors[0]);
matParams.Constant1Color = ConvertRGBA(mat.ConstantColors[1]);
matParams.Constant2Color = ConvertRGBA(mat.ConstantColors[2]);
matParams.Constant3Color = ConvertRGBA(mat.ConstantColors[3]);
matParams.Constant4Color = ConvertRGBA(mat.ConstantColors[4]);
matParams.Constant5Color = ConvertRGBA(mat.ConstantColors[5]);
matParams.BlendColor = ConvertRGBA(mat.BlendColor);
matParams.TexEnvBufferColor = ConvertRGBA(mat.BufferColor);
if (mat.CullMode == CullMode.Back)
{
matParams.FaceCulling = PICAFaceCulling.BackFace;
}
else if (mat.CullMode == CullMode.Front)
{
matParams.FaceCulling = PICAFaceCulling.FrontFace;
}
else
{
matParams.FaceCulling = PICAFaceCulling.Never;
}
matParams.AlphaTest.Enabled = mat.AlphaTest.Enabled;
matParams.AlphaTest.Function = ConvertTestFunction(mat.AlphaTest.Function);
matParams.AlphaTest.Reference = mat.AlphaTest.Reference;
matParams.BlendFunction.ColorSrcFunc = ConvertBlendFunc(mat.BlendFunction.ColorSrcFunc);
matParams.BlendFunction.ColorDstFunc = ConvertBlendFunc(mat.BlendFunction.ColorDstFunc);
matParams.BlendFunction.AlphaSrcFunc = ConvertBlendFunc(mat.BlendFunction.AlphaSrcFunc);
matParams.BlendFunction.AlphaDstFunc = ConvertBlendFunc(mat.BlendFunction.AlphaDstFunc);
for (int i = 0; i < mat.TexEnvStages.Count; i++)
{
var combiner = mat.TexEnvStages[i];
var h3dStage = new PICATexEnvStage();
h3dStage.Source.Color[0] = ConvertCombinerSrc[combiner.Source.Color[0]];
h3dStage.Source.Color[1] = ConvertCombinerSrc[combiner.Source.Color[1]];
h3dStage.Source.Color[2] = ConvertCombinerSrc[combiner.Source.Color[2]];
h3dStage.Source.Alpha[0] = ConvertCombinerSrc[combiner.Source.Alpha[0]];
h3dStage.Source.Alpha[1] = ConvertCombinerSrc[combiner.Source.Alpha[1]];
h3dStage.Source.Alpha[2] = ConvertCombinerSrc[combiner.Source.Alpha[2]];
h3dStage.Operand.Alpha[0] = ConvertConvertCombinerAlphaOp[combiner.Operand.Alpha[0]];
h3dStage.Operand.Alpha[1] = ConvertConvertCombinerAlphaOp[combiner.Operand.Alpha[1]];
h3dStage.Operand.Alpha[2] = ConvertConvertCombinerAlphaOp[combiner.Operand.Alpha[2]];
h3dStage.Operand.Color[0] = ConvertConvertCombinerColorOp[combiner.Operand.Color[0]];
h3dStage.Operand.Color[1] = ConvertConvertCombinerColorOp[combiner.Operand.Color[1]];
h3dStage.Operand.Color[2] = ConvertConvertCombinerColorOp[combiner.Operand.Color[2]];
h3dStage.Scale.Color = ConvertScale[combiner.Scale.Color];
h3dStage.Scale.Alpha = ConvertScale[combiner.Scale.Alpha];
h3dStage.Combiner.Alpha = ConvertConvertCombiner[combiner.Combiner.Alpha];
h3dStage.Combiner.Color = ConvertConvertCombiner[combiner.Combiner.Color];
matParams.TexEnvStages[i] = h3dStage;
}
matParams.LUTInputAbsolute.Dist0 = mat.Distibution0SamplerIsAbs;
matParams.LUTInputAbsolute.Dist1 = mat.Distibution1SamplerIsAbs;
matParams.LUTInputAbsolute.ReflecR = mat.ReflectanceRSamplerIsAbs;
matParams.LUTInputAbsolute.ReflecG = mat.ReflectanceGSamplerIsAbs;
matParams.LUTInputAbsolute.ReflecB = mat.ReflectanceBSamplerIsAbs;
matParams.LUTInputAbsolute.Fresnel = mat.FresnelSamplerIsAbs;
return(h3dMaterial);
}
/// <summary>
/// Returns the name of the indicated alpha source from the given stage and adds a color correction map if needed
/// Member StringBuilder 'script' must be valid
/// </summary>
/// <param name="stage">The stage containing the desired source</param>
/// <param name="srcIdx">the index of the desired source</param>
/// <returns>MaxScript variable name of the source</returns>
private string GetSourceStringAlpha(PICATexEnvStage stage, int srcIdx)
{
//TODO: Ensure validity of script member var
int op = (int)stage.Operand.Alpha[srcIdx];
//source 2 of "Interpolate" combiner must be inverted oppositely to everything else
if (stage.Combiner.Alpha == PICATextureCombinerMode.Interpolate && srcIdx == 2)
{
op = op + 1 - 2 * (op % 2);
}
//if source is vertex colors and operand is alpha (Workaround for Max's inablity to use vertex alpha in materials. Copy of vertex alpha must be in last map channel)
if (stage.Source.Alpha[srcIdx] == PICATextureCombinerSource.PrimaryColor && (op == (int)PICATextureCombinerAlphaOp.Alpha || op == (int)PICATextureCombinerAlphaOp.OneMinusAlpha))
{
script.Append("vtxAlpha = VertexColor()\n"
+ $"vtxAlpha.map = {maxMapChannel + 1}\n"
+ "vtxAlpha.subid = 1\n");
//if inverse alpha, apply color correction map for inversion
if (op == (int)PICATextureCombinerAlphaOp.OneMinusAlpha)
{
script.Append("ccmap = ColorCorrection()\n"
+ "ccmap.map = vtxAlpha\n"
+ "ccmap.rewireMode = 2\n");
return("ccmap");
}
return("vtxAlpha");
}
//No color correction for buffer
if (stage.Source.Alpha[srcIdx] == PICATextureCombinerSource.PreviousBuffer)
{
return("buffer");
}
//if source is a constant, create one based on the operand
if (stage.Source.Color[srcIdx] == PICATextureCombinerSource.Constant)
{
switch (op)
{
case (int)PICATextureCombinerAlphaOp.OneMinusAlpha: return($"rgbMult color1: [{255 - stageColor.A},{255 - stageColor.A},{255 - stageColor.A}]\n");
case (int)PICATextureCombinerAlphaOp.Red: return($"rgbMult color1: [{stageColor.R},{stageColor.R},{stageColor.R}]\n");
case (int)PICATextureCombinerAlphaOp.OneMinusRed: return($"rgbMult color1: [{255 - stageColor.R},{255 - stageColor.R},{255 - stageColor.R}]\n");
case (int)PICATextureCombinerAlphaOp.Green: return($"rgbMult color1: [{stageColor.G},{stageColor.G},{stageColor.G}]\n");
case (int)PICATextureCombinerAlphaOp.OneMinusGreen: return($"rgbMult color1: [{255 - stageColor.G},{255 - stageColor.G},{255 - stageColor.G}]\n");
case (int)PICATextureCombinerAlphaOp.Blue: return($"rgbMult color1: [{stageColor.B},{stageColor.B},{stageColor.B}]\n");
case (int)PICATextureCombinerAlphaOp.OneMinusBlue: return($"rgbMult color1: [{255 - stageColor.B},{255 - stageColor.B},{255 - stageColor.B}]\n");
default: return($"rgbMult color1: [{stageColor.R},{stageColor.G},{stageColor.B}]\n");
}
}
//create a color correction map to select the color channels
op = op + 2 + ((op > 3)?2:0) + ((op > 5)?2:0);
script.Append("ccmap = ColorCorrection()\n"
+ $"ccmap.map = {sources[(int)(stage.Source.Alpha[srcIdx])]}\n"
+ $"ccmap.rewireR = {operandChannels[op][0]}\n"
+ $"ccmap.rewireG = {operandChannels[op][1]}\n"
+ $"ccmap.rewireB = {operandChannels[op][2]}\n"
+ $"ccmap.rewireA = 9\n");
return("ccmap"); //return the color map
}
public GfxTexEnv(PICATexEnvStage Stage)
{
this.Stage = Stage;
}
