internal ShaderVariable GetVariable(string name)
{
ShaderVariable v = null;
this._variables.TryGetValue(name, out v);
return(v);
}
public ShaderVariable GetShaderVar(BinaryReader read)
{
object[] objs = GetObjects(read);
ShaderVariable ret = new ShaderVariable();
ret.name = name;
ret.type = VarType.Float;
if (format.compType == FormatComponentType.UInt)
{
ret.type = VarType.UInt;
}
if (format.compType == FormatComponentType.SInt)
{
ret.type = VarType.Int;
}
if (format.compType == FormatComponentType.Double)
{
ret.type = VarType.Double;
}
ret.columns = Math.Min(format.compCount, 4);
ret.rows = Math.Min(matrixdim, 4);
ret.members = new ShaderVariable[0] {
};
ret.value.fv = new float[16];
ret.value.uv = new uint[16];
ret.value.iv = new int[16];
for (uint row = 0; row < ret.rows; row++)
{
for (uint col = 0; col < ret.columns; col++)
{
uint dst = row * ret.columns + col;
uint src = row * format.compCount + col;
object o = objs[src];
if (o is float)
{
ret.value.fv[dst] = (float)o;
}
else if (o is uint)
{
ret.value.uv[dst] = (uint)o;
}
else if (o is int)
{
ret.value.iv[dst] = (int)o;
}
}
}
return(ret);
}
public string StringRep(ShaderVariable var, bool useType)
{
if (displayInts.Checked || (useType && var.type == VarType.Int))
{
return(var.Row(0, VarType.Int));
}
if (useType && var.type == VarType.UInt)
{
return(var.Row(0, VarType.UInt));
}
return(var.Row(0, VarType.Float).ToString());
}
static IrShaderVariable ParseVariable(ShaderVariable variable)
{
return(new IrShaderVariable()
{
Member = ParseShaderTypeMember(variable.Member),
BaseType = variable.BaseType,
Size = variable.Size,
Flags = variable.Flags,
DefaultValue = variable.DefaultValue,
StartTexture = variable.StartTexture,
TextureSize = variable.TextureSize,
StartSampler = variable.StartSampler,
SamplerSize = variable.SamplerSize
});
}
//internal void OnClear(int tech, int pass)
//{
// if (Clearded != null)
// Clearded(tech, pass);
// //foreach (var v in variables)
// //{
// // v.Variable.Deferred = true;
// //}
//}
internal void AddVariable(string name, ShaderVariable v)
{
VariableBinding binding = new VariableBinding
{
Variable = v,
Setter = program.CreateUniformSetter(name)
};
if (binding.Setter == null)
{
throw new NullReferenceException("The IUniformSetter is null");
}
_variables.Add(binding);
}
void WriteVariable(ShaderVariable variable, int indentLevel = 1, bool packOffset = true)
{
Output.Append($"{GetShaderTypeDeclaration(variable.ShaderType, indentLevel, root:false)} {variable.Name}");
if (variable.ShaderType.ElementCount > 0)
{
Output.AppendFormat("[{0}]", variable.ShaderType.ElementCount);
}
if (variable.DefaultValue != null)
{
if (variable.DefaultValue.Count > 1)
{
Output.AppendFormat(" = {0}({1})",
GetShaderTypeDeclaration(variable.ShaderType),
string.Join(", ", variable.DefaultValue));
}
else
{
Output.AppendFormat(" = {0}", variable.DefaultValue[0]);
}
}
// packoffset needs to be disabled for globals
if (EmitPackingOffset && packOffset)
{
var componentOffset = variable.StartOffset % 16 / 4;
string componentPacking = "";
switch (componentOffset)
{
case 1:
componentPacking = ".y";
break;
case 2:
componentPacking = ".z";
break;
case 3:
componentPacking = ".w";
break;
}
Output.AppendFormat(" : packoffset(c{0}{1})", variable.StartOffset / 16, componentPacking);
}
Output.Append($"; // Offset {variable.StartOffset} Size {variable.Size} CBSize {variable.Member.GetCBVarSize(true)}");
if (variable.Flags.HasFlag(ShaderVariableFlags.Used))
{
Output.Append($" [unused]");
}
Output.AppendLine();
}
ShaderVariable[] ApplyFormatOverride(byte[] data)
{
if (m_FormatOverride == null || m_FormatOverride.Length == 0)
{
return(null);
}
var stream = new MemoryStream(data);
var reader = new BinaryReader(stream);
ShaderVariable[] ret = new ShaderVariable[m_FormatOverride.Length];
int i = 0;
try
{
for (i = 0; i < m_FormatOverride.Length; i++)
{
stream.Seek(m_FormatOverride[i].offset, SeekOrigin.Begin);
ret[i] = m_FormatOverride[i].GetShaderVar(reader);
}
}
catch (System.IO.EndOfStreamException)
{
for (; i < m_FormatOverride.Length; i++)
{
ret[i] = new ShaderVariable();
ret[i].name = "-";
ret[i].type = VarType.Float;
ret[i].rows = ret[i].columns = 1;
ret[i].members = new ShaderVariable[0] {
};
ret[i].value.fv = new float[16];
ret[i].value.uv = new uint[16];
ret[i].value.iv = new int[16];
ret[i].value.dv = new double[16];
}
}
reader.Dispose();
stream.Dispose();
return(ret);
}
public override void OnInspectorGUI()
{
ShaderVariable sv = target as ShaderVariable;
if (GUILayout.Button("Apply color"))
{
sv.SetColor();
}
EditorGUI.BeginChangeCheck();
sv.color = EditorGUILayout.ColorField(sv.color);
if (EditorGUI.EndChangeCheck())
{
sv.SetColor();
}
base.OnInspectorGUI();
}
private static void CompareConstantBufferVariable(ShaderReflectionVariable expected,
ShaderVariable actual)
{
//Assert.AreEqual(expected.Description.DefaultValue, actual.DefaultValue); // TODO
Assert.AreEqual((int)expected.Description.Flags, (int)actual.Flags);
Assert.AreEqual(expected.Description.Name, actual.Name);
Assert.AreEqual(expected.Description.SamplerSize, actual.SamplerSize);
Assert.AreEqual(expected.Description.Size, actual.Size);
Assert.AreEqual((uint)expected.Description.StartOffset, actual.StartOffset);
if (expected.Description.StartSampler != -1 && actual.StartSampler != 0)
{
Assert.AreEqual(expected.Description.StartSampler, actual.StartSampler);
}
if (expected.Description.StartTexture != -1 && actual.StartTexture != 0)
{
Assert.AreEqual(expected.Description.StartTexture, actual.StartTexture);
}
Assert.AreEqual(expected.Description.TextureSize, actual.TextureSize);
CompareConstantBufferVariableType(expected.GetVariableType(), actual.ShaderType);
}
ShaderVariable[] ApplyFormatOverride(byte[] data)
{
if (m_FormatOverride == null || m_FormatOverride.Length == 0)
{
return(null);
}
var stream = new MemoryStream(data);
var reader = new BinaryReader(stream);
ShaderVariable[] ret = new ShaderVariable[m_FormatOverride.Length];
for (int i = 0; i < m_FormatOverride.Length; i++)
{
stream.Seek(m_FormatOverride[i].offset, SeekOrigin.Begin);
ret[i] = m_FormatOverride[i].GetShaderVar(reader);
}
reader.Dispose();
stream.Dispose();
return(ret);
}
public Assign(ShaderVariable result, VertexAttribute value) : this(result, () => value.Name)
{
}
public Assign(ShaderVariable result, ShaderVariable value) : this(result, () => value.Ref.ToString())
{
}
internal void SetVariable(string name, ShaderVariable v)
{
_variables.Add(name, v);
}
private void ReadMaterialData(string relative_path)
{
BinaryReader reader = new BinaryReader(Project.directory_path + "\\" + relative_path);
if (!reader.is_ok)
{
return;
}
MaterialData material_data = new MaterialData();
material_data.Read(reader);
AssetDatabase asset_database = (AssetDatabase)App.Current.Resources["asset_database"];
AssetCacheData pixel_shader_cache = asset_database.Find(material_data.pixel_shader_id, AssetType.kShader);
ShaderData pixelShader = ReadShaderData(pixel_shader_cache.path);
ub = new UniformBuffer(pixelShader, material_data.uniform_buffers[0].data);
inspector_.ClearInspectors();
foreach (var pair in ub.name_map_)
{
ShaderVariable var = ub.data_map_[pair.Value];
InspectorTypes type = InspectorTypes.kNumber;
switch (var.type_)
{
case ShaderVarType.kBool:
type = InspectorTypes.kCheckbox;
break;
case ShaderVarType.kFloat:
case ShaderVarType.kDouble:
type = InspectorTypes.kSlider;
break;
case ShaderVarType.kUint:
case ShaderVarType.kUint8:
case ShaderVarType.kInt:
type = InspectorTypes.kNumber;
break;
case ShaderVarType.kMat3:
type = InspectorTypes.kMatrix3x3;
break;
case ShaderVarType.kMat4:
type = InspectorTypes.kMatrix4x4;
break;
case ShaderVarType.kVec2:
type = InspectorTypes.kVector2;
break;
case ShaderVarType.kVec3:
type = InspectorTypes.kVector3;
break;
case ShaderVarType.kVec4:
type = InspectorTypes.kVector4;
break;
}
inspector_.AddInspector(pair.Key, type,
new VarRef(() => ub.data_map_[pair.Value].data_,
val => {
ub.data_map_[pair.Value].Set(val);
material_data.uniform_buffers[0].data = ub.ConstructDataBuffer();
StoreMaterialData(relative_path, material_data);
}));
}
}
public override ShaderVariableI Variable(string name)
{
// Try to find existing variable
foreach (var variable in variables)
{
if (variable.Name == name) return variable;
}
// Otherwise add a variable instance
#if SILVERLIGHT
int vsRegisterIndex = -1, psRegisterIndex = -1;
for (int i = 0; i != vsVariableNames.Count; ++i)
{
if (vsVariableNames[i] == name)
{
vsRegisterIndex = vsVariableRegistries[i];
break;
}
}
for (int i = 0; i != psVariableNames.Count; ++i)
{
if (psVariableNames[i] == name)
{
psRegisterIndex = psVariableRegistries[i];
break;
}
}
if (vsRegisterIndex == -1 && psRegisterIndex == -1)
{
Debug.ThrowError("Shader", string.Format("Shader variable '{0}' does not exist", name));
}
var variableOut = new ShaderVariable(video, vsRegisterIndex, psRegisterIndex, name);
variables.Add(variableOut);
return variableOut;
#else
var parameter = effect.Parameters[name];
if (parameter == null)
{
Debug.ThrowError("Shader", string.Format("Shader variable '{0}' does not exist", name));
}
var variableOut = new ShaderVariable(parameter, name);
variables.Add(variableOut);
return variableOut;
#endif
}
public Assign(ShaderVariable result, VertexAttribute value, string components = null) : this(result, () => value.Name, components)
{
}
public void SetVariable(string name, object value)
{
ShaderVariable variable;
if (!variablemap.TryGetValue(name, out variable))
{
variable = new ShaderVariable();
variable.Variable = Effect.GetVariableByName(name);
variable.Value = null;
variablemap.Add(name, variable);
}
if (!variable.Variable.IsValid) return;
if (variable.Value == value) return;
if (value is float)
variable.Variable.AsScalar().Set((float)value);
else if (value is Vector2)
variable.Variable.AsVector().Set((Vector2)value);
else if (value is Vector3)
variable.Variable.AsVector().Set((Vector3)value);
else if (value is Vector4)
variable.Variable.AsVector().Set((Vector4)value);
else if (value is ShaderResourceView)
variable.Variable.AsResource().SetResource(value as ShaderResourceView);
else if (value is SamplerState)
variable.Variable.AsSampler().SetSamplerState(0, value as SamplerState);
else if (value is Matrix)
variable.Variable.AsMatrix().SetMatrix((Matrix)value);
}
public Assign(ShaderVariable result, Func <string> expression, string components = null)
{
this.result = result;
this.expression = expression;
this.components = components;
}
public Reference(ShaderVariable variable, ShaderType.Field field) : base(variable)
{
this.field = field;
}
public ShaderFieldVariable(ShaderContext context, ShaderVariable baseVariable, ShaderType.Field field)
: base(context, $"{baseVariable.Name}_field_{field.Name}", field.ShaderTypeName, baseVariable.ArrayCount)
{
reference = new Reference(baseVariable, field);
}
public TextureSampling(ShaderVariable result, ShaderVariable sampler, ShaderVariable coord) : base(result,
() => $"texture2D({sampler.Ref}, {coord.Ref})")
{
}
public void UpdateDebugging()
{
if (m_Trace == null || m_Trace.states.Length == 0)
{
//curInstruction.Text = "0";
for (int i = 0; i < m_DisassemblyView.Lines.Count; i++)
{
m_DisassemblyView.Lines[i].DeleteMarkerSet(CurrentLineMarkers);
m_DisassemblyView.Lines[i].DeleteMarkerSet(FinishedMarkers);
}
return;
}
var state = m_Trace.states[CurrentStep];
//curInstruction.Text = CurrentStep.ToString();
UInt32 nextInst = state.nextInstruction;
bool done = false;
if (CurrentStep == m_Trace.states.Length - 1)
{
nextInst--;
done = true;
}
// add current instruction marker
for (int i = 0; i < m_DisassemblyView.Lines.Count; i++)
{
m_DisassemblyView.Lines[i].DeleteMarkerSet(CurrentLineMarkers);
m_DisassemblyView.Lines[i].DeleteMarkerSet(FinishedMarkers);
if (m_DisassemblyView.Lines[i].Text.Trim().StartsWith(nextInst.ToString() + ":"))
{
m_DisassemblyView.Lines[i].AddMarkerSet(done ? FinishedMarkers : CurrentLineMarkers);
m_DisassemblyView.Caret.LineNumber = i;
if (!m_DisassemblyView.Lines[i].IsVisible)
{
m_DisassemblyView.Scrolling.ScrollToCaret();
}
}
}
m_DisassemblyView.Invalidate();
if (constantRegs.Nodes.IsEmpty())
{
constantRegs.BeginUpdate();
for (int i = 0; i < m_Trace.cbuffers.Length; i++)
{
for (int j = 0; j < m_Trace.cbuffers[i].variables.Length; j++)
{
if (m_Trace.cbuffers[i].variables[j].rows > 0 || m_Trace.cbuffers[i].variables[j].columns > 0)
{
constantRegs.Nodes.Add(new TreelistView.Node(new object[] {
m_Trace.cbuffers[i].variables[j].name,
"cbuffer",
StringRep(m_Trace.cbuffers[i].variables[j], false)
}));
}
}
}
foreach (var input in m_Trace.inputs)
{
constantRegs.Nodes.Add(new TreelistView.Node(new object[] { input.name, input.type.ToString() + " input", StringRep(input, true) }));
}
var pipestate = m_Core.CurD3D11PipelineState;
foreach (var slot in m_ShaderDetails.Resources)
{
if (slot.IsSampler)
{
continue;
}
var res = m_Stage.SRVs[slot.bindPoint];
if (slot.IsUAV)
{
if (m_Stage.stage == ShaderStageType.Pixel)
{
res = pipestate.m_OM.UAVs[slot.bindPoint - pipestate.m_OM.UAVStartSlot];
}
else
{
res = m_Stage.UAVs[slot.bindPoint];
}
}
bool found = false;
var name = slot.bindPoint + " (" + slot.name + ")";
foreach (var tex in m_Core.CurTextures)
{
if (tex.ID == res.Resource)
{
constantRegs.Nodes.Add(new TreelistView.Node(new object[] {
"t" + name, "Texture",
tex.width + "x" + tex.height + "x" + (tex.depth > 1 ? tex.depth : tex.arraysize) +
"[" + tex.mips + "] @ " + tex.format + " - " + tex.name
}));
found = true;
break;
}
}
if (!found)
{
foreach (var buf in m_Core.CurBuffers)
{
if (buf.ID == res.Resource)
{
string prefix = "u";
if (slot.IsSRV)
{
prefix = "t";
}
constantRegs.Nodes.Add(new TreelistView.Node(new object[] {
prefix + name, "Buffer",
buf.length + " - " + buf.name
}));
found = true;
break;
}
}
}
if (!found)
{
string prefix = "u";
if (slot.IsSRV)
{
prefix = "t";
}
constantRegs.Nodes.Add(new TreelistView.Node(new object[] {
prefix + name, "Resource",
"unknown"
}));
}
}
constantRegs.EndUpdate();
}
else
{
constantRegs.BeginUpdate();
int c = 0;
for (int i = 0; i < m_Trace.cbuffers.Length; i++)
{
for (int j = 0; j < m_Trace.cbuffers[i].variables.Length; j++)
{
if (m_Trace.cbuffers[i].variables[j].rows > 0 || m_Trace.cbuffers[i].variables[j].columns > 0)
{
constantRegs.Nodes[c++].SetData(new object[] {
m_Trace.cbuffers[i].variables[j].name,
"cbuffer",
StringRep(m_Trace.cbuffers[i].variables[j], false)
});
}
}
}
constantRegs.EndUpdate();
}
if (variableRegs.Nodes.IsEmpty())
{
for (int i = 0; i < state.registers.Length; i++)
{
variableRegs.Nodes.Add("a");
}
for (int i = 0; i < state.outputs.Length; i++)
{
variableRegs.Nodes.Add("a");
}
}
variableRegs.BeginUpdate();
int v = 0;
for (int i = 0; i < state.registers.Length; i++)
{
variableRegs.Nodes[v++].SetData(new object[] { state.registers[i].name, "register", StringRep(state.registers[i], false) });
}
for (int i = 0; i < state.outputs.Length; i++)
{
variableRegs.Nodes[v++].SetData(new object[] { state.outputs[i].name, "register", StringRep(state.outputs[i], false) });
}
variableRegs.EndUpdate();
watchRegs.BeginUpdate();
for (int i = 0; i < watchRegs.Items.Count - 1; i++)
{
ListViewItem item = watchRegs.Items[i];
item.SubItems[1].Text = "register";
string reg = item.SubItems[0].Text.Trim();
var regexp = "^([rvo])([0-9]+)(\\.[xyzwrgba]+)?(,[xfiud])?$";
var match = Regex.Match(reg, regexp);
if (match.Success)
{
var regtype = match.Groups[1].Value;
var regidx = match.Groups[2].Value;
var swizzle = match.Groups[3].Value.Replace(".", "");
var regcast = match.Groups[4].Value.Replace(",", "");
if (regcast == "")
{
if (displayInts.Checked)
{
regcast = "i";
}
else
{
regcast = "f";
}
}
ShaderVariable[] vars = null;
if (regtype == "r")
{
vars = state.registers;
}
else if (regtype == "v")
{
vars = m_Trace.inputs;
}
else if (regtype == "o")
{
vars = state.outputs;
}
int regindex = -1;
if (int.TryParse(regidx, out regindex))
{
if (regindex >= 0 && regindex < vars.Length)
{
ShaderVariable vr = vars[regindex];
if (swizzle == "")
{
swizzle = "xyzw".Substring(0, (int)vr.columns);
if (regcast == "d")
{
swizzle = "xy";
}
}
string val = "";
for (int s = 0; s < swizzle.Length; s++)
{
char swiz = swizzle[s];
int elindex = 0;
if (swiz == 'x' || swiz == 'r')
{
elindex = 0;
}
if (swiz == 'y' || swiz == 'g')
{
elindex = 1;
}
if (swiz == 'z' || swiz == 'b')
{
elindex = 2;
}
if (swiz == 'w' || swiz == 'a')
{
elindex = 3;
}
if (regcast == "i")
{
val += vr.value.iv[elindex];
}
else if (regcast == "f")
{
val += Formatter.Format(vr.value.fv[elindex]);
}
else if (regcast == "u")
{
val += vr.value.uv[elindex];
}
else if (regcast == "x")
{
val += String.Format("0x{0:X8}", vr.value.uv[elindex]);
}
else if (regcast == "d")
{
if (elindex < 2)
{
val += vr.value.dv[elindex];
}
else
{
val += "-";
}
}
if (s < swizzle.Length - 1)
{
val += ", ";
}
}
item.SubItems[2].Text = val;
continue;
}
}
}
item.SubItems[2].Text = "Error evaluating expression";
}
watchRegs.EndUpdate();
}
public Assign(ShaderVariable result, Func <string> expression)
{
this.result = result;
this.expression = expression;
}
public Assign(ShaderVariable result, ShaderVariable value, string components = null) : this(result, () => value.Ref.ToString(), components)
{
}
Expression CallUniform(Source src, Expression obj, ShaderVariable var, int index)
{
return(ILFactory.CallMethod(src, obj, "Uniform", new Constant(src, Essentials.Int, index), var.Value));
}
private object GenType(Type baseType)
{
TypeBuilder tb;
if (baseType != null)
{
tb = baseType.IsInterface ?
Mb.DefineType(_namespace + "." + "_$" + baseType.Name + Id, TypeAttributes.Class | TypeAttributes.Public, typeof(object), new Type[] { baseType }) :
Mb.DefineType(_namespace + "." + "_$" + baseType.Name + Id, TypeAttributes.Class | TypeAttributes.Public, baseType);
}
else
{
tb = Mb.DefineType(_namespace + "." + "$dI" + Id, TypeAttributes.Class | TypeAttributes.Public);
}
Id++;
var commit = typeof(ShaderVariable).GetMethod("Commit");
List <KeyValuePair <FieldBuilder, ShaderVariable> > createFields = new List <KeyValuePair <FieldBuilder, ShaderVariable> >();
foreach (var v in _varlookup)
{
if (v.Value.NetType != null)
{
ShaderVariable effectVar = v.Value.Variable;
var tField = tb.DefineField(v.Key + "bakingField", effectVar.GetType(), FieldAttributes.Static | FieldAttributes.Public | FieldAttributes.SpecialName);
createFields.Add(new KeyValuePair <FieldBuilder, ShaderVariable>(tField, effectVar));
PropertyBuilder prop = null;
PropertyInfo pi = null;
if (baseType == null)
{
prop = tb.DefineProperty(v.Key, PropertyAttributes.None, v.Value.NetType, null);
pi = prop;
}
else
{
pi = v.Value.NetProp;
}
//define getter
DefineGetter(tb, tField, prop, baseType, pi);
//define setter
DefineSetter(tb, commit, tField, prop, baseType, pi);
}
else if (baseType != null)
{
var prop = v.Value.NetProp ?? baseType.GetProperty(v.Key);
var tField = tb.DefineField(v.Key + "bakingField", prop.PropertyType, FieldAttributes.Static | FieldAttributes.Public | FieldAttributes.SpecialName);
#region Getter
MethodBuilder getter;
var attr = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.ReuseSlot;
getter = tb.DefineMethod(prop.GetMethod.Name, attr, prop.PropertyType, Type.EmptyTypes);
// define getter
// return field.Value;
var il = getter.GetILGenerator();
il.Emit(OpCodes.Ldsfld, tField);
il.Emit(OpCodes.Ret);
if (!baseType.IsInterface)
{
tb.DefineMethodOverride(getter, baseType.GetMethod(getter.Name));
}
#endregion
#region Setter
MethodBuilder setter = tb.DefineMethod(prop.SetMethod.Name, attr, typeof(void), new Type[] { prop.PropertyType });
// field = value
il = setter.GetILGenerator();
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stsfld, tField);
il.Emit(OpCodes.Ret);
if (!baseType.IsInterface)
{
tb.DefineMethodOverride(setter, baseType.GetMethod(setter.Name));
}
#endregion
}
}
Type type = tb.CreateType();
var inst = Activator.CreateInstance(type);
foreach (var f in createFields)
{
type.GetField(f.Key.Name).SetValue(null, f.Value);
//f.Key.SetValue(inst, f.Value);
}
return(inst);
}
