public void ReturnsConstant([Range(0, 10)] int input)
{
var uInput = (uint)input;
using (var module = Module.Create("test_constant"))
{
var def = module.AddFunction(
Type.Int32, "constant", new Type[0], (f, b) =>
{
var value = ConstantInt.Get(Type.Int32, uInput);
var ret = b.CreateRet(value);
});
module.Verify();
Initialize.X86.All();
using (var engine = ExecutionEngine.CreateMCJITCompilerForModule(module))
{
var func = engine.GetDelegate <Int32Delegate>(def);
Assert.AreEqual(input, func());
}
}
}
static void HandleConstants(GraphBuilder builder, out INode node, out PortMapper portToOffsetMapping,
IConstantNodeModel constantNodeModel)
{
portToOffsetMapping = new PortMapper();
var outputPortId = constantNodeModel.OutputPort?.UniqueId ?? "";
switch (constantNodeModel)
{
case StringConstantModel stringConstantModel:
{
var index = builder.StoreStringConstant(stringConstantModel.value ?? string.Empty);
var cf = new ConstantString {
Value = new StringReference(index, StringReference.Storage.Managed)
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case BooleanConstantNodeModel booleanConstantNodeModel:
{
var cf = new ConstantBool {
Value = booleanConstantNodeModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case IntConstantModel intConstantModel:
{
var cf = new ConstantInt {
Value = intConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case FloatConstantModel floatConstantModel:
{
var cf = new ConstantFloat {
Value = floatConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case Vector2ConstantModel vector2ConstantModel:
{
var cf = new ConstantFloat2 {
Value = vector2ConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case Vector3ConstantModel vector3ConstantModel:
{
var cf = new ConstantFloat3 {
Value = vector3ConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case Vector4ConstantModel vector4ConstantModel:
{
var cf = new ConstantFloat4 {
Value = vector4ConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case QuaternionConstantModel quaternionConstantModel:
{
var cf = new ConstantQuaternion {
Value = quaternionConstantModel.value
};
node = MapPort(portToOffsetMapping, outputPortId, Direction.Output, ref cf.ValuePort.Port, cf);
return;
}
case ObjectConstantModel _:
{
throw new NotImplementedException(
"Conversion and all - either a prefab (might live in a graph) or a scene object (must be injected during runtime bootstrap)");
// portToOffsetMapping = new Dictionary<IPortModel, uint>();
// var cf = new ConstantEntity {Value = objectConstantModel.value};
// MapPort(portToOffsetMapping, objectConstantModel.OutputPort, ref cf.ValuePort.Port, nodeId);
// node = cf;
// return;
}
default:
throw new NotImplementedException();
}
}
private void Load(ShaderModel shader)
{
ConstantDeclarations = shader.ParseConstantTable();
foreach (var constantDeclaration in ConstantDeclarations)
{
RegisterType registerType;
switch (constantDeclaration.RegisterSet)
{
case RegisterSet.Bool:
registerType = RegisterType.ConstBool;
break;
case RegisterSet.Float4:
registerType = RegisterType.Const;
break;
case RegisterSet.Int4:
registerType = RegisterType.Input;
break;
case RegisterSet.Sampler:
registerType = RegisterType.Sampler;
break;
default:
throw new InvalidOperationException();
}
if (registerType == RegisterType.Sampler)
{
// Use declaration from declaration instruction instead
continue;
}
for (int r = 0; r < constantDeclaration.RegisterCount; r++)
{
var registerKey = new RegisterKey(registerType, constantDeclaration.RegisterIndex + r);
var registerDeclaration = new RegisterDeclaration(registerKey);
_registerDeclarations.Add(registerKey, registerDeclaration);
}
}
foreach (var instruction in shader.Instructions.Where(i => i.HasDestination))
{
if (instruction.Opcode == Opcode.Dcl)
{
var registerDeclaration = new RegisterDeclaration(instruction);
RegisterKey registerKey = registerDeclaration.RegisterKey;
_registerDeclarations.Add(registerKey, registerDeclaration);
switch (registerKey.Type)
{
case RegisterType.Input:
case RegisterType.MiscType:
MethodInputRegisters.Add(registerKey, registerDeclaration);
break;
case RegisterType.Output:
case RegisterType.ColorOut:
MethodOutputRegisters.Add(registerKey, registerDeclaration);
break;
}
}
else if (instruction.Opcode == Opcode.Def)
{
var constant = new Constant(
instruction.GetParamRegisterNumber(0),
instruction.GetParamSingle(1),
instruction.GetParamSingle(2),
instruction.GetParamSingle(3),
instruction.GetParamSingle(4));
_constantDefinitions.Add(constant);
}
else if (instruction.Opcode == Opcode.DefI)
{
var constantInt = new ConstantInt(instruction.GetParamRegisterNumber(0),
instruction.Params[1],
instruction.Params[2],
instruction.Params[3],
instruction.Params[4]);
_constantIntDefinitions.Add(constantInt);
}
else if (shader.Type == ShaderType.Pixel)
{
// Find all assignments to color outputs, because pixel shader outputs are not declared.
int destIndex = instruction.GetDestinationParamIndex();
RegisterType registerType = instruction.GetParamRegisterType(destIndex);
if (registerType == RegisterType.ColorOut)
{
int registerNumber = instruction.GetParamRegisterNumber(destIndex);
var registerKey = new RegisterKey(registerType, registerNumber);
if (MethodOutputRegisters.ContainsKey(registerKey) == false)
{
var reg = new RegisterDeclaration(registerKey);
MethodOutputRegisters[registerKey] = reg;
}
}
}
}
}
private static Constant Get <TData>(IntegerType type, params TData[] data) => GetGeneric(type, (x, y) => ConstantInt.Get(x, y), data);
public void DocumentNode(SearcherItem searcherItem, INodeModel nodeModel)
{
INode node;
switch (nodeModel)
{
case IDotsNodeModel baseDotsNodeModel:
node = baseDotsNodeModel.Node;
break;
case StringConstantModel _:
node = new ConstantString();
break;
case BooleanConstantNodeModel _:
node = new ConstantBool();
break;
case IntConstantModel _:
node = new ConstantInt();
break;
case FloatConstantModel _:
node = new ConstantFloat();
break;
case Vector2ConstantModel _:
node = new ConstantFloat2();
break;
case Vector3ConstantModel _:
node = new ConstantFloat3();
break;
case Vector4ConstantModel _:
node = new ConstantFloat4();
break;
case QuaternionConstantModel _:
node = new ConstantQuaternion();
break;
default:
return;
}
var nodeType = node.GetType();
var executionType = GetNodeExecutionType(nodeType, node);
var title = Attribute.IsDefined(node.GetType(), typeof(WorkInProgressAttribute))
? $"{searcherItem.Name} [WIP]"
: searcherItem.Name;
SectionTitle(title, 1);
var nodeDescription = GetNodeDescription(nodeType, executionType, out string exampleText, out string dataSetup);
if (!String.IsNullOrEmpty(nodeDescription))
{
Paragraph(nodeDescription);
}
GetPortsDescription(executionType, node);
if (exampleText != null)
{
SectionTitle("Examples", 2);
Paragraph(exampleText);
}
if (dataSetup != null)
{
SectionTitle("Data Setup", 2);
Paragraph(dataSetup);
}
}
public void AddCase(ConstantInt onVal, BasicBlock dest) => LLVM.AddCase(this.Unwrap(), onVal.Unwrap(), dest.Unwrap <LLVMBasicBlockRef>());
