public Variable(VectorParameter param, ShaderGpuProgramType programType)
{
ShaderType = new ShaderType(param, programType);
Name = param.Name ?? throw new Exception("Variable name cannot be null");
NameIndex = param.NameIndex;
Index = param.Index;
ArraySize = param.ArraySize;
}
public ShaderType(VectorParameter vectorParam, ShaderGpuProgramType programType)
{
Members = Array.Empty <ShaderTypeMember>();
ShaderVariableClass = vectorParam.Dim > 1 ? ShaderVariableClass.Vector : ShaderVariableClass.Scalar;
ShaderVariableType = GetVariableType(vectorParam.Type);
Rows = 1;
Columns = vectorParam.Dim;
ElementCount = (ushort)vectorParam.ArraySize;
MemberCount = 0;
MemberOffset = 0;
m_programType = programType;
}
protected override bool GetParameter(int hash)
{
if (hash == -1)
{
m_Parameter = null;
}
else
{
m_Parameter = motionController.motionGraph.GetVectorProperty(hash);
}
return(m_Parameter != null);
}
public Variable(string name, int index, int sizeToAdd, ShaderGpuProgramType prgramType)
{
if (sizeToAdd % 4 != 0 || sizeToAdd <= 0) throw new Exception($"Invalid dummy variable size {sizeToAdd}");
var param = new VectorParameter(name, ShaderParamType.Int, index, sizeToAdd / 4);
ShaderType = new ShaderType(param, prgramType);
Name = name;
NameIndex = -1;
Index = index;
ArraySize = 0;
Type = ShaderParamType.Int;
Dim = (byte)(sizeToAdd / 4);
if (Name == null) throw new Exception("Variable name cannot be null");
}
public ShaderType(VectorParameter vectorParam, ShaderGpuProgramType programType)
{
ShaderVariableClass = vectorParam.Dim > 1 ?
ShaderVariableClass.Vector :
ShaderVariableClass.Scalar;
ShaderVariableType = GetVariableType(vectorParam.Type);
Rows = 1;
Columns = vectorParam.Dim;
ElementCount = 0;
MemberCount = 0;
MemberOffset = 0;
this.programType = programType;
}
public NewCylindricalPrimitive()
{
FeatureCurves = ArrayUtils.Generate <PrimitiveCurve>(2);
SilhouetteCurves = ArrayUtils.Generate <PrimitiveCurve>(2);
Center = new PointParameter();
Axis = new VectorParameter();
Length = new ValueParameter();
RegisterParameter(() => Center);
RegisterParameter(() => Axis);
RegisterParameter(() => Length);
}
public static void RandomizeSubMatInst(ExportEntry childMat, Dictionary <string, CFVector4> vectorValues, Dictionary <string, float> scalarValues)
{
// VECTOR PARAMETERS
//Debug.WriteLine($"Randomizing matinst {childMat.InstancedFullPath}");
var vectorParameterValues = VectorParameter.GetVectorParameters(childMat);
if (vectorParameterValues != null)
{
foreach (var vpv in vectorParameterValues)
{
CFVector4 color;
if (!vectorValues.TryGetValue(vpv.ParameterName, out color))
{
color = vpv.ParameterValue;
RStructs.RandomizeTint(color, false);
vectorValues[vpv.ParameterName] = color;
}
else
{
vpv.ParameterValue = color;
}
}
//Debug.WriteLine(childMat.InstancedFullPath);
VectorParameter.WriteVectorParameters(childMat, vectorParameterValues);
}
// SCALAR PARAMETERS
var scalarParameterValues = ScalarParameter.GetScalarParameters(childMat);
if (scalarParameterValues != null)
{
foreach (var vpv in scalarParameterValues)
{
if (!scalarValues.TryGetValue(vpv.ParameterName, out float scalarVal))
{
// Write new
vpv.ParameterValue *= ThreadSafeRandom.NextFloat(0.75, 1.25);
scalarValues[vpv.ParameterName] = vpv.ParameterValue;
}
else
{
// Write existing
vpv.ParameterValue = scalarVal;
}
}
//Debug.WriteLine(childMat.InstancedFullPath);
ScalarParameter.WriteScalarParameters(childMat, scalarParameterValues);
}
}
public static Variable CreateResourceBindVariable(ShaderGpuProgramType programType)
{
Variable variable = new Variable();
variable.Name = "$Element";
var param = new VectorParameter(variable.Name, ShaderParamType.UInt, 0, 1);
variable.ShaderType = new ShaderType(param, programType);
variable.NameIndex = -1;
variable.Index = 0;
variable.ArraySize = param.ArraySize;
variable.Length = 4;
variable.Type = ShaderParamType.UInt;
return(variable);
}
public static bool RandomizeNPCExport2(ExportEntry export, RandomizationOption randOption)
{
if (!CanRandomizeNPCExport2(export))
{
return(false);
}
var props = export.GetProperties();
var isIconic = props.GetProp <BoolProperty>("bIconicAppearance");
if (isIconic != null && isIconic)
{
return(false); // Don't modify an iconic look as it has a bunch fo stuff in it that can totally break it like scalp seams.
}
Dictionary <string, CFVector4> vectorValues = new();
Dictionary <string, float> scalarValues = new();
if (export.IsA("BioPawn"))
{
ChangeColorsInSubObjects(export, vectorValues, scalarValues, props);
}
else
{
// It's a SFXSkeletalMeshActorMAT, a basic type of NPC.
var parms = VectorParameter.GetVectorParameters(export);
if (parms != null)
{
foreach (var parm in parms)
{
vectorValues[parm.ParameterName] = parm.ParameterValue;
RStructs.RandomizeTint(parm.ParameterValue, false);
}
VectorParameter.WriteVectorParameters(export, parms, "VectorParameters");
// Get submaterials and write out their properties too
ChangeColorsInSubObjects(export, vectorValues, scalarValues, props);
}
// Should we try to randomize things that don't have a skin tone...?
if (export.ObjectFlags.Has(UnrealFlags.EObjectFlags.ArchetypeObject) && PackageTools.IsLevelSubfile(Path.GetFileName(export.FileRef.FilePath)))
{
export.indexValue = ThreadSafeRandom.Next();
}
}
return(true);
}
public static Variable CreateDummyVariable(string name, int index, int sizeToAdd, ShaderGpuProgramType programType)
{
if (sizeToAdd % 4 != 0 || sizeToAdd <= 0)
{
throw new Exception($"Invalid dummy variable size {sizeToAdd}");
}
Variable variable = new Variable();
var param = new VectorParameter(name, ShaderParamType.Int, index, sizeToAdd / 4, 0);
variable.ShaderType = new ShaderType(param, programType);
variable.Name = name ?? throw new Exception("Variable name cannot be null");
variable.NameIndex = -1;
variable.Index = index;
variable.ArraySize = param.ArraySize;
variable.Type = ShaderParamType.Int;
return(variable);
}
private static void TestR(ExportEntry export)
{
if (/*export.UIndex == 36224 && */ export.ClassName == "Material")
{
var obj = ObjectBinary.From <Material>(export);
foreach (var v in obj.SM3MaterialResource.UniformPixelVectorExpressions)
{
if (v is MaterialUniformExpressionVectorParameter vp)
{
vp.DefaultA = ThreadSafeRandom.NextFloat(0, 1);
vp.DefaultR = ThreadSafeRandom.NextFloat();
vp.DefaultG = ThreadSafeRandom.NextFloat();
vp.DefaultB = ThreadSafeRandom.NextFloat();
}
else if (v is MaterialUniformExpressionAppendVector av)
{
}
}
foreach (var v in obj.SM3MaterialResource.UniformPixelVectorExpressions)
{
}
export.WriteBinary(obj);
}
if (export.UIndex == 37354 || export.UIndex == 37355)
{
var vParms = VectorParameter.GetVectorParameters(export);
if (vParms != null)
{
foreach (var vParm in vParms)
{
CFVector4 nv = new CFVector4();
nv.W = ThreadSafeRandom.NextFloat(2000);
nv.X = ThreadSafeRandom.NextFloat(2000);
nv.Y = ThreadSafeRandom.NextFloat(2000);
nv.Z = ThreadSafeRandom.NextFloat(2000);
vParm.ParameterValue = nv;
}
}
}
}
private ParameterCollection GetSpicePropertyParameters(EvaluationContext context, SpicePropertyFoundEventArgs <double> arg)
{
var vectorParameter = new VectorParameter(new List <SingleParameter>());
for (var i = 0; i < arg.Property.ArgumentCount; i++)
{
var argumentName = arg.Property[i];
if (context.Parameters.ContainsKey(argumentName))
{
var val = context.Evaluate(argumentName);
vectorParameter.Elements.Add(new WordParameter(val.ToString(CultureInfo.InvariantCulture), null));
}
else
{
vectorParameter.Elements.Add(new WordParameter(argumentName, null));
}
}
var parameters = new ParameterCollection(new List <Parameter> {
vectorParameter
});
return(parameters);
}
private void OnVariableFound(object sender, SpiceSharpBehavioral.Builders.Direct.VariableFoundEventArgs <double> e)
{
if (e.Node.NodeType != NodeTypes.Voltage && e.Node.NodeType != NodeTypes.Current && e.Node.NodeType != NodeTypes.Property)
{
var found = Variables.SingleOrDefault(variable => StringComparerProvider.Get(_caseSettings.IsParameterNameCaseSensitive).Equals(variable.Name, e.Node.Name));
if (found != null)
{
e.Result = found.Value();
}
}
else
{
if (Context.Simulation == null)
{
e.Result = 0;
}
else
{
if (e.Node.NodeType == NodeTypes.Current)
{
var name = e.Node.Name;
var parameters = new ParameterCollection();
var vectorParameter = new VectorParameter();
vectorParameter.Elements.Add(new IdentifierParameter(e.Node.Name.ToString()));
parameters.Add(vectorParameter);
string key = $"{Context.Name}_I_{parameters}_{Context.Simulation?.Name}";
if (_exporterInstances.TryGetValue(key, out Export cachedExport))
{
e.Result = cachedExport.Extract();
}
else
{
var currentExporter = new CurrentExporter();
var export = currentExporter.CreateExport(
key,
"I",
parameters,
Context,
_caseSettings);
_exporterInstances[key] = export;
e.Result = export.Extract();
}
}
else if (e.Node.NodeType == NodeTypes.Voltage)
{
var name = e.Node.Name;
var variable = Variables.FirstOrDefault(v => v.Name == name);
if (variable != null)
{
name = variable.Value().ToString();
}
var parameters = new ParameterCollection();
var vectorParameter = new VectorParameter();
vectorParameter.Elements.Add(new IdentifierParameter(name));
parameters.Add(vectorParameter);
string key = $"{Context.Name}_V_{parameters}_{Context.Simulation?.Name}";
if (_exporterInstances.TryGetValue(key, out Export cachedExport))
{
e.Result = cachedExport.Extract();
}
else
{
var currentExporter = new VoltageExporter();
var export = currentExporter.CreateExport(
key,
"V",
parameters,
Context,
_caseSettings);
_exporterInstances[key] = export;
try
{
e.Result = export.Extract();
}
catch (Exception ex)
{
if (ThrowOnErrors)
{
throw;
}
e.Result = 0;
}
}
}
}
}
}
