void BuildEjobDescription()
{
if (_ejobDescription == null)
{
using (var handler = SymbolHandler.Create(SymbolOptions.CaseInsensitive)) {
var address = handler.LoadSymbolsForModule(@"%systemroot%\system32\ntoskrnl.exe");
if (address == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
var types = handler.EnumTypes(address, "_ejob");
Debug.Assert(types != null && types.Count == 1);
_ejobDescription = handler.BuildStructDescriptor(address, types[0].TypeIndex);
}
}
}
// A key difference between Material Shader and VFX Shader generation is how surface properties are provided. Material Shaders
// simply provide properties via UnityPerMaterial cbuffer. VFX expects these same properties to be computed in the vertex
// stage (because we must evaluate them with the VFX blocks), and packed with the interpolators for the fragment stage.
static StructDescriptor AppendVFXInterpolator(StructDescriptor interpolator, VFXContext context, VFXContextCompiledData contextData)
{
var fields = interpolator.fields.ToList();
var expressionToName = context.GetData().GetAttributes().ToDictionary(o => new VFXAttributeExpression(o.attrib) as VFXExpression, o => (new VFXAttributeExpression(o.attrib)).GetCodeString(null));
expressionToName = expressionToName.Union(contextData.uniformMapper.expressionToCode).ToDictionary(s => s.Key, s => s.Value);
var mainParameters = contextData.gpuMapper.CollectExpression(-1).ToArray();
// Warning/TODO: FragmentParameters are created from the ShaderGraphVfxAsset.
// We may ultimately need to move this handling of VFX Interpolators + SurfaceDescriptionFunction function signature directly into the SG Generator (since it knows about the exposed properties).
foreach (string fragmentParameter in context.fragmentParameters)
{
var filteredNamedExpression = mainParameters.FirstOrDefault(o => fragmentParameter == o.name &&
!(expressionToName.ContainsKey(o.exp) && expressionToName[o.exp] == o.name)); // if parameter already in the global scope, there's nothing to do
if (filteredNamedExpression.exp != null)
{
var type = VFXExpression.TypeToType(filteredNamedExpression.exp.valueType);
if (!kVFXShaderValueTypeMap.TryGetValue(type, out var shaderValueType))
{
continue;
}
// TODO: NoInterpolation only for non-strips.
fields.Add(new FieldDescriptor(HDStructFields.VaryingsMeshToPS.name, filteredNamedExpression.name, "", shaderValueType, subscriptOptions: StructFieldOptions.Static, interpolation: "nointerpolation"));
}
}
// VFX Object Space Interpolators
fields.Add(HDStructFields.VaryingsMeshToPS.worldToElement0);
fields.Add(HDStructFields.VaryingsMeshToPS.worldToElement1);
fields.Add(HDStructFields.VaryingsMeshToPS.worldToElement2);
fields.Add(HDStructFields.VaryingsMeshToPS.elementToWorld0);
fields.Add(HDStructFields.VaryingsMeshToPS.elementToWorld1);
fields.Add(HDStructFields.VaryingsMeshToPS.elementToWorld2);
interpolator.fields = fields.ToArray();
return(interpolator);
}
protected object InternalGetValue(Type type, int index)
{
try {
if (type == typeof(bool))
{
return(Options.GetValue <DTB.NodeInt32>(index + 1).Number != 0);
}
else if (type == typeof(int))
{
return(Options.GetValue <DTB.NodeInt32>(index + 1).Number);
}
else if (type == typeof(uint))
{
return((uint)Options.GetValue <DTB.NodeInt32>(index + 1).Number);
}
else if (type == typeof(float))
{
return(Options.GetValue <DTB.NodeFloat32>(index + 1).Number);
}
else if (type == typeof(string))
{
return(Options.GetValue <DTB.NodeString>(index + 1).Text);
}
else if (type == typeof(byte[]))
{
return(Options.GetValue <DTB.NodeData>(index + 1).Contents);
}
else if (type.IsSubclassOf(typeof(Struct)))
{
Struct st = (Struct)type.GetConstructor(Type.EmptyTypes).Invoke(new object[0]);
StructDescriptor desc = RegisteredStructs[type];
for (int i = 0; i < desc.Types.Length; i++)
{
st.Values[i] = InternalGetValue(desc.Types[i], index * desc.Types.Length + i);
}
return(st);
}
} catch { }
return(null);
}
public Struct(StructDescriptor sd)
{
var s = sd.CreateAnInstance() as Struct;
Attributes = s.Attributes;
Name = s.Name;
}
public override void Visit(StructDeclarationNode node)
{
// User Defined Struct Name
string structName = node.StructName.Value;
List<Member> structMembers = new List<Member>();
foreach (IPsiNode member in node.StructMemberList)
{
member.Accept(this);
structMembers.Add(lastCompiledMember);
}
// Message
string msg = "Struct Found : " + structName + " { ";
foreach (Member member in structMembers)
{
msg += member.ToString();
if (member != structMembers[structMembers.Count - 1])
msg += ", ";
}
msg += " }";
AddInformation(msg, node.NodeValueInfo);
// Check Existance
if (IsUserDefinedTypeFounded(structName))
{
AddError(CompilerErrorCode.TypeCollision,
string.Format("User defined type \"{0}\" is already used, this will be skipped!", structName),
node.NodeValueInfo);
}
else
{
// Create a Struct Descriptor
var desc = new StructDescriptor { Name = structName };
foreach (var member in structMembers)
{
if (member.Type == TypeEnum.Undefined)
{
AddWarning(CompilerErrorCode.NotSupported,
"User defined types in records is not supported, member will be skipped!",
node.NodeValueInfo);
}
else
{
// Check Existance
if (IsAttributeFounded(desc.Attributes, member.Name))
{
AddError(CompilerErrorCode.StructAttributeNameCollision, string.Format(
"Struct \"{0}\" has already a member \"{1}\", member will be skipped!", desc.Name, member.Name),
node.NodeValueInfo);
}
else
{
desc.Attributes.Add(
new AttributeDescriptor
{
Value = member.Value,
Descriptor = new VariableDescriptor
{
IsReference = member.IsReference,
Name = member.Name,
Type = new TypeIdentifier
{
TypeEnum = member.Type,
TypeName = member.TypeName,
Dimensions = new List<int>(member.DimensionCount)
}
}
});
}
}
}
// Add to UserDefinedTypeInfoList
UserDefinedTypeInfoList.Add(
new UserDefinedTypeInfo(
new TypeIdentifier
{
UserDefinedType = desc,
TypeEnum = TypeEnum.UserDefinedType,
TypeName = desc.Name
},
SourceFileName,
node.NodeValueInfo));
}
}
public unsafe StructDescriptor BuildStructDescriptor(ulong dllBase, int typeIndex)
{
if (Win32.SymGetTypeInfo(_hProcess, dllBase, typeIndex, SymbolTypeInfo.ChildrenCount, out int childrenCount))
{
var structDesc = new StructDescriptor(childrenCount);
if (Win32.SymGetTypeInfo(_hProcess, dllBase, typeIndex, SymbolTypeInfo.Length, out ulong size))
{
structDesc.Length = (int)size;
}
var childrenParams = new FindChildrenParams {
Count = childrenCount
};
structDesc.Length = (int)size;
if (Win32.SymGetTypeInfo(_hProcess, dllBase, typeIndex, SymbolTypeInfo.FindChildren, ref childrenParams))
{
for (var i = 0; i < childrenParams.Count; i++)
{
var sym = SymbolInfo.Create();
var child = childrenParams.Child[i];
if (GetSymbolFromIndex(dllBase, child, ref sym))
{
if (Win32.SymGetTypeInfo(_hProcess, dllBase, child, SymbolTypeInfo.Offset, out int offset) &&
Win32.SymGetTypeInfo(_hProcess, dllBase, child, SymbolTypeInfo.Tag, out SymbolTag tag))
{
sym.Tag = tag;
sym.TypeIndex = child;
var member = new StructMember(sym, offset);
structDesc.AddMember(member);
}
else if (Win32.SymGetTypeInfo(_hProcess, dllBase, child, SymbolTypeInfo.Value, out Variant value))
{
sym.Tag = SymbolTag.Enum;
sym.Value = value.lValue;
sym.TypeIndex = child;
var member = new StructMember(sym, 0);
switch (sym.Size)
{
case 8:
member.Value = value.lValue;
break;
case 2:
member.Value = value.sValue;
break;
case 1:
member.Value = value.bValue;
break;
default:
member.Value = value.iValue;
break;
}
structDesc.AddMember(member);
}
}
}
}
return(structDesc);
}
return(null);
}
public Struct(StructDescriptor desc)
{
Descriptor = desc;
Values = new object[desc.Types.Length];
}
public static void RegisterStruct(Type type, StructDescriptor desc)
{
RegisteredStructs.Add(type, desc);
}
