mirror of
https://github.com/ZuneDev/Xune.git
synced 2026-07-27 13:13:10 -07:00
377 lines
14 KiB
C#
377 lines
14 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Microsoft.Iris.Render.Graphics.Dx9EffectBuilder
|
|
// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
|
|
// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
|
|
// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll
|
|
|
|
using Microsoft.Iris.Library;
|
|
using Microsoft.Iris.Render.Internal;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace Microsoft.Iris.Render.Graphics
|
|
{
|
|
internal class Dx9EffectBuilder
|
|
{
|
|
private string m_stPixelOutput;
|
|
private StringBuilder m_sbPixelShader;
|
|
private StringBuilder m_sbVertexShader;
|
|
private StringBuilder m_sbDeclarations;
|
|
private StringBuilder m_sbEffect;
|
|
private Vector<VariableInfo> m_alPropertyVariables;
|
|
private int m_nUniqueVariableID;
|
|
private Vector<Dx9TextureInfo> m_alTextureInfos;
|
|
private Vector<VariableInfo> m_alGlobalVariables;
|
|
private Vector<string> m_alIncludes;
|
|
private int m_cMaxSimultaneousTextures;
|
|
private int m_cMaxRenderTargets;
|
|
private int m_nRequirements;
|
|
|
|
internal Dx9EffectBuilder(GraphicsCaps caps)
|
|
{
|
|
this.m_cMaxSimultaneousTextures = caps.MaxSimultaneousTextures;
|
|
this.m_cMaxRenderTargets = caps.AvailableRenderTargets;
|
|
}
|
|
|
|
internal void EmitPixelFragment(string stData)
|
|
{
|
|
if (this.m_sbPixelShader == null)
|
|
this.m_sbPixelShader = new StringBuilder(128);
|
|
this.m_sbPixelShader.Append(stData);
|
|
}
|
|
|
|
internal void EmitEffectFragment(string stData)
|
|
{
|
|
if (this.m_sbEffect == null)
|
|
this.m_sbEffect = new StringBuilder(512);
|
|
this.m_sbEffect.Append(stData);
|
|
}
|
|
|
|
internal void EmitIncludesFragment(string stData)
|
|
{
|
|
if (this.m_alIncludes == null)
|
|
this.m_alIncludes = new Vector<string>();
|
|
if (this.m_alIncludes.Contains(stData))
|
|
return;
|
|
this.m_alIncludes.Add(stData);
|
|
}
|
|
|
|
internal string GenerateGlobalConstant(Dx9VariableType typeProperty, string stName) => this.GenerateVariableName(VariableScope.Const, typeProperty, stName);
|
|
|
|
internal string GenerateLocalVariable(Dx9VariableType typeProperty, string stName) => this.GenerateVariableName(VariableScope.Local, typeProperty, stName);
|
|
|
|
internal string GenerateGlobalVariable(Dx9VariableType typeProperty, string stName) => this.GenerateVariableName(VariableScope.Global, typeProperty, stName);
|
|
|
|
internal void AddPropertyVariable(VariableInfo variableInfo)
|
|
{
|
|
if (this.m_alPropertyVariables == null)
|
|
this.m_alPropertyVariables = new Vector<VariableInfo>();
|
|
this.m_alPropertyVariables.Add(variableInfo);
|
|
}
|
|
|
|
internal void AddGlobalVariable(VariableInfo variableInfo)
|
|
{
|
|
if (this.m_alGlobalVariables == null)
|
|
this.m_alGlobalVariables = new Vector<VariableInfo>();
|
|
this.m_alGlobalVariables.Add(variableInfo);
|
|
}
|
|
|
|
private string GenerateVariableName(
|
|
VariableScope scope,
|
|
Dx9VariableType typeProperty,
|
|
string stName)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder(32);
|
|
switch (scope)
|
|
{
|
|
case VariableScope.Global:
|
|
stringBuilder.Append("g_");
|
|
break;
|
|
case VariableScope.Const:
|
|
stringBuilder.Append("k_");
|
|
break;
|
|
}
|
|
switch (typeProperty)
|
|
{
|
|
case Dx9VariableType.Integer:
|
|
stringBuilder.Append("n");
|
|
break;
|
|
case Dx9VariableType.Float:
|
|
stringBuilder.Append("fl");
|
|
break;
|
|
case Dx9VariableType.Vector2:
|
|
case Dx9VariableType.Vector3:
|
|
case Dx9VariableType.Vector4:
|
|
stringBuilder.Append("v");
|
|
break;
|
|
case Dx9VariableType.Texture:
|
|
stringBuilder.Append("tex");
|
|
break;
|
|
}
|
|
if (stName != null)
|
|
{
|
|
if (stName.Length > 15)
|
|
stName = stName.Substring(0, 15);
|
|
stringBuilder.Append(stName);
|
|
}
|
|
else
|
|
stringBuilder.Append("Temp");
|
|
return stringBuilder.ToString() + (object) this.m_nUniqueVariableID++;
|
|
}
|
|
|
|
internal void Clear()
|
|
{
|
|
this.m_stPixelOutput = (string) null;
|
|
this.m_nUniqueVariableID = 0;
|
|
this.m_nRequirements = 0;
|
|
this.m_sbPixelShader = (StringBuilder) null;
|
|
this.m_sbVertexShader = (StringBuilder) null;
|
|
this.m_sbDeclarations = (StringBuilder) null;
|
|
this.m_sbEffect = (StringBuilder) null;
|
|
if (this.m_alPropertyVariables != null)
|
|
this.m_alPropertyVariables.Clear();
|
|
if (this.m_alGlobalVariables != null)
|
|
this.m_alGlobalVariables.Clear();
|
|
if (this.m_alTextureInfos != null)
|
|
this.m_alTextureInfos.Clear();
|
|
if (this.m_alIncludes == null)
|
|
return;
|
|
this.m_alIncludes.Clear();
|
|
}
|
|
|
|
internal string ConvertToString(Dx9VariableType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case Dx9VariableType.Integer:
|
|
return "int";
|
|
case Dx9VariableType.Float:
|
|
return "float";
|
|
case Dx9VariableType.Vector2:
|
|
return "float2";
|
|
case Dx9VariableType.Vector3:
|
|
return "float3";
|
|
case Dx9VariableType.Vector4:
|
|
return "float4";
|
|
case Dx9VariableType.Texture:
|
|
return "texture";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
internal string ConvertToString(FilterMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case FilterMode.Point:
|
|
return "Point";
|
|
case FilterMode.Linear:
|
|
return "Linear";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
internal bool Validate() => this.ImageCount <= this.m_cMaxSimultaneousTextures && this.GetRenderTargetCount() <= this.m_cMaxRenderTargets;
|
|
|
|
internal Dx9TextureInfo AllocateTexture()
|
|
{
|
|
Dx9TextureInfo dx9TextureInfo = new Dx9TextureInfo()
|
|
{
|
|
ImageIndex = this.ImageCount
|
|
};
|
|
dx9TextureInfo.TexCoordInput = InvariantString.Format("{0}{1}", (object) "vTexCoord", (object) dx9TextureInfo.ImageIndex);
|
|
dx9TextureInfo.Sampler = InvariantString.Format("{0}{1}", (object) "Sampler", (object) dx9TextureInfo.ImageIndex);
|
|
dx9TextureInfo.DownsamplePropertyID = -1;
|
|
if (this.m_alTextureInfos == null)
|
|
this.m_alTextureInfos = new Vector<Dx9TextureInfo>();
|
|
this.m_alTextureInfos.Add(dx9TextureInfo);
|
|
return dx9TextureInfo;
|
|
}
|
|
|
|
internal void AddRequirement(
|
|
Dx9TextureInfo textureInfo,
|
|
Dx9TextureRequirements type,
|
|
object oValue)
|
|
{
|
|
textureInfo.Requirements |= (int) type;
|
|
switch (type)
|
|
{
|
|
case Dx9TextureRequirements.TexelSize:
|
|
if (textureInfo.TexelSize != null)
|
|
break;
|
|
string stName1 = InvariantString.Format("{0}{1}", (object) "TexelSize", (object) textureInfo.ImageIndex);
|
|
VariableInfo variableInfo1 = new VariableInfo()
|
|
{
|
|
IsDynamic = true,
|
|
ID = -1,
|
|
Type = Dx9VariableType.Vector2
|
|
};
|
|
variableInfo1.Name = this.GenerateGlobalVariable(variableInfo1.Type, stName1);
|
|
variableInfo1.DefaultValue = (object) new Vector2(0.0f, 0.0f);
|
|
this.AddGlobalVariable(variableInfo1);
|
|
textureInfo.TexelSize = variableInfo1.Name;
|
|
break;
|
|
case Dx9TextureRequirements.SampleBackbuffer:
|
|
textureInfo.DownsamplePropertyID = (int) oValue;
|
|
break;
|
|
case Dx9TextureRequirements.TexUVSize:
|
|
if (textureInfo.TexUVSize != null)
|
|
break;
|
|
string stName2 = InvariantString.Format("{0}{1}", (object) "TexUVSize", (object) textureInfo.ImageIndex);
|
|
VariableInfo variableInfo2 = new VariableInfo()
|
|
{
|
|
IsDynamic = true,
|
|
ID = -1,
|
|
Type = Dx9VariableType.Vector2
|
|
};
|
|
variableInfo2.Name = this.GenerateGlobalVariable(variableInfo2.Type, stName2);
|
|
variableInfo2.DefaultValue = (object) new Vector2(0.0f, 0.0f);
|
|
this.AddGlobalVariable(variableInfo2);
|
|
textureInfo.TexUVSize = variableInfo2.Name;
|
|
break;
|
|
case Dx9TextureRequirements.TexUVRefPoint:
|
|
if (textureInfo.TexUVRefPoint != null)
|
|
break;
|
|
string stName3 = InvariantString.Format("{0}{1}", (object) "TexUVRefPoint", (object) textureInfo.ImageIndex);
|
|
VariableInfo variableInfo3 = new VariableInfo()
|
|
{
|
|
IsDynamic = true,
|
|
ID = -1,
|
|
Type = Dx9VariableType.Vector2
|
|
};
|
|
variableInfo3.Name = this.GenerateGlobalVariable(variableInfo3.Type, stName3);
|
|
variableInfo3.DefaultValue = (object) new Vector2(0.0f, 0.0f);
|
|
this.AddGlobalVariable(variableInfo3);
|
|
textureInfo.TexUVRefPoint = variableInfo3.Name;
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal void AddRequirement(EffectRequirements requirement) => Bits.SetFlag(ref this.m_nRequirements, (int) requirement);
|
|
|
|
internal Dx9TextureInfo GetTextureInfo(int idxTexture) => this.m_alTextureInfos[idxTexture];
|
|
|
|
internal string PixelShaderOutput
|
|
{
|
|
get => this.m_stPixelOutput;
|
|
set => this.m_stPixelOutput = value;
|
|
}
|
|
|
|
internal string ShaderDeclarations => this.GenerateDeclarations();
|
|
|
|
internal string IncludesFragment
|
|
{
|
|
get
|
|
{
|
|
if (this.m_alIncludes == null)
|
|
return "";
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int index = 0; index < this.m_alIncludes.Count; ++index)
|
|
stringBuilder.AppendFormat("#include {0}\r\n", (object) this.m_alIncludes[index]);
|
|
return stringBuilder.ToString();
|
|
}
|
|
}
|
|
|
|
internal string PixelShader => this.GeneratePixelShader();
|
|
|
|
internal string VertexShader => this.GenerateVertexShader();
|
|
|
|
internal Vector<VariableInfo> PropertyVariables => this.m_alPropertyVariables;
|
|
|
|
internal Vector<VariableInfo> GlobalVariables => this.m_alGlobalVariables;
|
|
|
|
internal string EffectDefinition => this.m_sbEffect.ToString();
|
|
|
|
internal int ImageCount => this.m_alTextureInfos == null ? 0 : this.m_alTextureInfos.Count;
|
|
|
|
internal Vector<Dx9TextureInfo> TextureInfoList => this.m_alTextureInfos;
|
|
|
|
internal void SaveEffect(string stFilename)
|
|
{
|
|
StreamWriter streamWriter = new StreamWriter(stFilename);
|
|
streamWriter.WriteLine(this.m_sbEffect.ToString());
|
|
streamWriter.Close();
|
|
}
|
|
|
|
private string GenerateDeclarations()
|
|
{
|
|
if (this.m_sbDeclarations == null)
|
|
this.m_sbDeclarations = new StringBuilder(128);
|
|
if (this.m_sbDeclarations.Length == 0)
|
|
{
|
|
this.m_sbDeclarations.Append("struct PS_OUTPUT\r\n{\r\n float4 Color : COLOR; // Object space position\r\n};\r\n\r\n");
|
|
this.m_sbDeclarations.Append("struct VS_INPUT\r\n{\r\n float4 ObjPos : POSITION; // Object space position\r\n float4 Color : COLOR; // Vertex color\r\n");
|
|
for (int index = 0; index < this.ImageCount; ++index)
|
|
this.m_sbDeclarations.AppendFormat(" float2 TexCoord{0} : TEXCOORD{0}; // Texture {0} UV coordinates\r\n", (object) index);
|
|
this.m_sbDeclarations.Append("};\r\n\r\n");
|
|
this.m_sbDeclarations.Append("struct VS_OUTPUT\r\n{\r\n float4 ProjPos : POSITION; // Projected space position\r\n float4 Color : COLOR; // Vertex color\r\n");
|
|
if (Bits.TestFlag(this.m_nRequirements, 1))
|
|
this.m_sbDeclarations.Append(" float3 ViewPos : TEXCOORD5; // View space position\r\n");
|
|
for (int index = 0; index < this.ImageCount; ++index)
|
|
{
|
|
if (Bits.TestFlag(this.m_alTextureInfos[index].Requirements, 16))
|
|
this.m_sbDeclarations.AppendFormat(" float3 TexCoord{0} : TEXCOORD{0}; // Texture {0} UVW coordinates\r\n", (object) index);
|
|
else
|
|
this.m_sbDeclarations.AppendFormat(" float2 TexCoord{0} : TEXCOORD{0}; // Texture {0} UV coordinates\r\n", (object) index);
|
|
}
|
|
this.m_sbDeclarations.Append("};\r\n\r\n");
|
|
}
|
|
return this.m_sbDeclarations.ToString();
|
|
}
|
|
|
|
private string GenerateVertexShader()
|
|
{
|
|
if (this.m_sbVertexShader == null)
|
|
this.m_sbVertexShader = new StringBuilder(128);
|
|
if (this.m_sbVertexShader.Length == 0)
|
|
{
|
|
this.m_sbVertexShader.Append(" //\r\n // Compute the accumulated WVP matrix. If the separate matrices are not referenced\r\n // by effect elements, the D3DX preshader will combine these on the CPU and set the\r\n // result via VS constants.\r\n //\r\n\r\n float4x4 matAccumulated = mul(g_matWorldView, g_matProjection);\r\n\r\n\r\n //\r\n // Setup the resulting device vertex.\r\n //\r\n\r\n Output.ProjPos = mul(Input.ObjPos, matAccumulated);\r\n Output.Color = Input.Color;\r\n");
|
|
if (Bits.TestFlag(this.m_nRequirements, 1))
|
|
this.m_sbVertexShader.Append(" Output.ViewPos = mul(Input.ObjPos, g_matWorldView);\r\n");
|
|
for (int index = 0; index < this.ImageCount; ++index)
|
|
{
|
|
if (Bits.TestFlag(this.m_alTextureInfos[index].Requirements, 16))
|
|
this.m_sbVertexShader.AppendFormat(" Output.TexCoord{0} = float3(Input.TexCoord{0}.x * Output.ProjPos.w, Input.TexCoord{0}.y * Output.ProjPos.w, Output.ProjPos.w);\r\n", (object) index);
|
|
else
|
|
this.m_sbVertexShader.AppendFormat(" Output.TexCoord{0} = Input.TexCoord{0};\r\n", (object) index);
|
|
}
|
|
}
|
|
return this.m_sbVertexShader.ToString();
|
|
}
|
|
|
|
private string GeneratePixelShader()
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder(128);
|
|
for (int index = 0; index < this.ImageCount; ++index)
|
|
{
|
|
Dx9TextureInfo alTextureInfo = this.m_alTextureInfos[index];
|
|
if (Bits.TestFlag(alTextureInfo.Requirements, 16))
|
|
stringBuilder.AppendFormat(" float2 {0} = Input.TexCoord{1}.xy / Input.TexCoord{1}.z;\r\n", (object) alTextureInfo.TexCoordInput, (object) index);
|
|
else
|
|
stringBuilder.AppendFormat(" float2 {0} = Input.TexCoord{1};\r\n", (object) alTextureInfo.TexCoordInput, (object) index);
|
|
}
|
|
stringBuilder.Append("\r\n");
|
|
stringBuilder.Append(this.m_sbPixelShader.ToString());
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
private int GetRenderTargetCount()
|
|
{
|
|
if (this.m_alTextureInfos == null)
|
|
return 0;
|
|
int num = 0;
|
|
foreach (Dx9TextureInfo alTextureInfo in this.m_alTextureInfos)
|
|
{
|
|
if ((alTextureInfo.Requirements & 2) > 0)
|
|
{
|
|
++num;
|
|
break;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
}
|