public IEnumerator Create_Prefab_Several_Override()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var parametersIntDesc = VFXLibrary.GetParameters().Where(o => o.model.type == typeof(int)).First();
Func <VisualEffect, string> dumpPropertySheetInteger = delegate(VisualEffect target)
{
var r = "{";
var editor = Editor.CreateEditor(target);
editor.serializedObject.Update();
var propertySheet = editor.serializedObject.FindProperty("m_PropertySheet");
var fieldName = VisualEffectSerializationUtility.GetTypeField(VFXExpression.TypeToType(VFXValueType.Int32)) + ".m_Array";
var vfxField = propertySheet.FindPropertyRelative(fieldName);
for (int i = 0; i < vfxField.arraySize; ++i)
{
var itField = vfxField.GetArrayElementAtIndex(i);
var name = itField.FindPropertyRelative("m_Name").stringValue;
var value = itField.FindPropertyRelative("m_Value").intValue;
var overridden = itField.FindPropertyRelative("m_Overridden").boolValue;
r += string.Format("({0}, {1}, {2})", name, value, overridden);
if (i != vfxField.arraySize - 1)
{
r += ", ";
}
}
GameObject.DestroyImmediate(editor);
r += "}";
return(r);
};
var log = string.Empty;
var exposedProperties = new[] { "a", "b", "c" };
for (var i = 0; i < exposedProperties.Length; ++i)
{
var parameter = parametersIntDesc.CreateInstance();
parameter.SetSettingValue("m_ExposedName", exposedProperties[i]);
parameter.SetSettingValue("m_Exposed", true);
parameter.value = i + 1;
graph.AddChild(parameter);
}
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var mainObject = MakeTemporaryGameObject();
var vfx = mainObject.AddComponent <VisualEffect>();
vfx.visualEffectAsset = graph.visualEffectResource.asset;
GameObject newGameObject, prefabInstanceObject;
MakeTemporaryPrebab(mainObject, out newGameObject, out prefabInstanceObject);
GameObject.DestroyImmediate(mainObject);
yield return(null);
var currentPrefabInstanceObject = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
var overridenParametersInScene = new[] { new { name = "b", value = 666 }, new { name = "a", value = 444 } };
var overridenParametersInPrefab = new[] { new { name = "c", value = -123 } };
log += "Initial Sheet\n";
log += "Prefab : " + dumpPropertySheetInteger(prefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
log += "Instance : " + dumpPropertySheetInteger(currentPrefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
yield return(null);
foreach (var overridenParameter in overridenParametersInScene)
{
currentPrefabInstanceObject.GetComponent <VisualEffect>().SetInt(overridenParameter.name, overridenParameter.value);
}
log += "\nIntermediate Sheet\n";
log += "Prefab : " + dumpPropertySheetInteger(prefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
log += "Instance : " + dumpPropertySheetInteger(currentPrefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
yield return(null);
foreach (var overridenParameter in overridenParametersInPrefab)
{
prefabInstanceObject.GetComponent <VisualEffect>().SetInt(overridenParameter.name, overridenParameter.value);
}
yield return(null);
log += "\nEnd Sheet\n";
log += "Prefab : " + dumpPropertySheetInteger(prefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
log += "Instance : " + dumpPropertySheetInteger(currentPrefabInstanceObject.GetComponent <VisualEffect>()) + "\n";
var stringFormat = @"({0} : {1}) ";
var expectedValues = string.Empty;
for (var i = 0; i < exposedProperties.Length; ++i)
{
var expectedValue = i;
var expectedName = exposedProperties[i];
var overrideInPrefab = overridenParametersInPrefab.FirstOrDefault(o => o.name == exposedProperties[i]);
var overrideInScene = overridenParametersInScene.FirstOrDefault(o => o.name == exposedProperties[i]);
if (overrideInPrefab != null)
{
expectedValue = overrideInPrefab.value;
}
if (overrideInScene != null)
{
expectedValue = overrideInScene.value;
}
expectedValues += string.Format(stringFormat, expectedName, expectedValue);
}
var actualValues = string.Empty;
for (var i = 0; i < exposedProperties.Length; ++i)
{
var expectedName = exposedProperties[i];
var actualValue = currentPrefabInstanceObject.GetComponent <VisualEffect>().GetInt(expectedName);
actualValues += string.Format(stringFormat, expectedName, actualValue);
}
if (k_HasFixed_Several_PrefabOverride)
{
Assert.AreEqual(expectedValues, actualValues, log);
}
else
{
Assert.AreNotEqual(expectedValues, actualValues, log); //Did you fixed it ? Should enable this test : k_HasFixed_Several_PrefabOverride
}
yield return(null);
}
public IEnumerator Create_Prefab_Modify_And_Expect_No_Override()
{
var graph = VFXTestCommon.MakeTemporaryGraph();
var parametersVector3Desc = VFXLibrary.GetParameters().Where(o => o.model.type == typeof(Vector3)).First();
var exposedName = "ghjkl";
var parameter = parametersVector3Desc.CreateInstance();
parameter.SetSettingValue("m_ExposedName", exposedName);
parameter.SetSettingValue("m_Exposed", true);
parameter.value = new Vector3(0, 0, 0);
graph.AddChild(parameter);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(graph));
var mainObject = MakeTemporaryGameObject();
var vfx = mainObject.AddComponent <VisualEffect>();
vfx.visualEffectAsset = graph.visualEffectResource.asset;
Assert.IsTrue(vfx.HasVector3(exposedName));
vfx.SetVector3(exposedName, new Vector3(1, 2, 3));
GameObject newGameObject, prefabInstanceObject;
MakeTemporaryPrebab(mainObject, out newGameObject, out prefabInstanceObject);
GameObject.DestroyImmediate(mainObject);
var currentPrefabInstanceObject = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
yield return(null);
var vfxInPrefab = prefabInstanceObject.GetComponent <VisualEffect>();
var expectedNewValue = new Vector3(4, 5, 6);
if (k_HasFixed_DisabledState)
{
Assert.IsTrue(vfxInPrefab.HasVector3(exposedName));
vfxInPrefab.SetVector3(exposedName, expectedNewValue);
}
else
{
/* modifying prefab using serialized property */
var editor = Editor.CreateEditor(vfxInPrefab);
editor.serializedObject.Update();
var propertySheet = editor.serializedObject.FindProperty("m_PropertySheet");
var fieldName = VisualEffectSerializationUtility.GetTypeField(VFXExpression.TypeToType(VFXValueType.Float3)) + ".m_Array";
var vfxField = propertySheet.FindPropertyRelative(fieldName);
Assert.AreEqual(1, vfxField.arraySize);
var property = vfxField.GetArrayElementAtIndex(0);
property = property.FindPropertyRelative("m_Value");
property.vector3Value = expectedNewValue;
editor.serializedObject.ApplyModifiedPropertiesWithoutUndo();
GameObject.DestroyImmediate(editor);
EditorUtility.SetDirty(prefabInstanceObject);
}
//AssetDatabase.SaveAssets(); //Helps debug but not necessary
PrefabUtility.SavePrefabAsset(prefabInstanceObject);
yield return(null);
var currentVFXInstanciedFromPrefab = currentPrefabInstanceObject.GetComponent <VisualEffect>();
Assert.IsTrue(currentVFXInstanciedFromPrefab.HasVector3(exposedName));
var refExposedValue = currentVFXInstanciedFromPrefab.GetVector3(exposedName);
var newInstanciedFromPrefab = PrefabUtility.InstantiatePrefab(prefabInstanceObject) as GameObject;
var newVFXInstanciedFromPrefab = newInstanciedFromPrefab.GetComponent <VisualEffect>();
Assert.IsTrue(newVFXInstanciedFromPrefab.HasVector3(exposedName));
var newExposedValue = newVFXInstanciedFromPrefab.GetVector3(exposedName);
var overrides = PrefabUtility.GetObjectOverrides(currentPrefabInstanceObject);
Assert.AreEqual(newExposedValue.x, expectedNewValue.x); Assert.AreEqual(newExposedValue.y, expectedNewValue.y); Assert.AreEqual(newExposedValue.z, expectedNewValue.z); //< Expected to work
if (k_HasFixed_PrefabOverride)
{
//Known issue : Failing due to fogbugz 1117103
Assert.AreEqual(refExposedValue.x, expectedNewValue.x); Assert.AreEqual(refExposedValue.y, expectedNewValue.y); Assert.AreEqual(refExposedValue.z, expectedNewValue.z);
Assert.IsEmpty(overrides);
}
}
public static Type GetMatchingScalar(Type otherType)
{
return(VFXExpression.GetMatchingScalar(otherType));
}
protected override sealed VFXExpression[] BuildExpression(VFXExpression[] inputExpression)
{
VFXExpression parameters = new VFXExpressionCombine(inputExpression[1], inputExpression[3], inputExpression[4]);
VFXExpression rangeMultiplier = (inputExpression[5].y - inputExpression[5].x);
VFXExpression result;
VFXExpression rangeMin = VFXValue.Constant(0.0f);
VFXExpression rangeMax = VFXValue.Constant(1.0f);
if (dimensions == DimensionCount.One)
{
if (type == NoiseType.Value)
{
result = new VFXExpressionValueNoise1D(inputExpression[0], parameters, inputExpression[2]);
}
else if (type == NoiseType.Perlin)
{
result = new VFXExpressionPerlinNoise1D(inputExpression[0], parameters, inputExpression[2]);
rangeMin = VFXValue.Constant(-1.0f);
}
else
{
result = new VFXExpressionCellularNoise1D(inputExpression[0], parameters, inputExpression[2]);
}
VFXExpression x = VFXOperatorUtility.Fit(result.x, rangeMin, rangeMax, inputExpression[5].x, inputExpression[5].y);
VFXExpression y = result.y * rangeMultiplier;
return(new[] { x, y });
}
else if (dimensions == DimensionCount.Two)
{
if (type == NoiseType.Value)
{
result = new VFXExpressionValueNoise2D(inputExpression[0], parameters, inputExpression[2]);
}
else if (type == NoiseType.Perlin)
{
result = new VFXExpressionPerlinNoise2D(inputExpression[0], parameters, inputExpression[2]);
rangeMin = VFXValue.Constant(-1.0f);
}
else
{
result = new VFXExpressionCellularNoise2D(inputExpression[0], parameters, inputExpression[2]);
}
VFXExpression x = VFXOperatorUtility.Fit(result.x, rangeMin, rangeMax, inputExpression[5].x, inputExpression[5].y);
VFXExpression y = result.y * rangeMultiplier;
VFXExpression z = result.z * rangeMultiplier;
return(new[] { x, new VFXExpressionCombine(y, z) });
}
else
{
if (type == NoiseType.Value)
{
result = new VFXExpressionValueNoise3D(inputExpression[0], parameters, inputExpression[2]);
}
else if (type == NoiseType.Perlin)
{
result = new VFXExpressionPerlinNoise3D(inputExpression[0], parameters, inputExpression[2]);
rangeMin = VFXValue.Constant(-1.0f);
}
else
{
result = new VFXExpressionCellularNoise3D(inputExpression[0], parameters, inputExpression[2]);
}
VFXExpression x = VFXOperatorUtility.Fit(result.x, rangeMin, rangeMax, inputExpression[5].x, inputExpression[5].y);
VFXExpression y = result.y * rangeMultiplier;
VFXExpression z = result.z * rangeMultiplier;
VFXExpression w = result.w * rangeMultiplier;
return(new[] { x, new VFXExpressionCombine(y, z, w) });
}
}
protected VFXExpression CalculateVolumeFactor(PositionMode positionMode, VFXExpression radius, VFXExpression thickness)
{
VFXExpression factor = VFXValue.Constant(0.0f);
switch (positionMode)
{
case PositionMode.Surface:
factor = VFXValue.Constant(0.0f);
break;
case PositionMode.Volume:
factor = VFXValue.Constant(1.0f);
break;
case PositionMode.ThicknessAbsolute:
case PositionMode.ThicknessRelative:
{
if (positionMode == PositionMode.ThicknessAbsolute)
{
thickness = thickness / radius;
}
factor = VFXOperatorUtility.Saturate(thickness);
break;
}
}
return new VFXExpressionPow(VFXValue.Constant(1.0f) - factor, VFXValue.Constant(thicknessDimensions));
}
// HACK: This is very implementation-specific :(
protected string CallFunction()
{
var data = GetData();
var context = (VFXContext)GetParent();
var expressionGraph = GetGraph()
.GetPropertyValue <VFXGraphCompiledData>("compiledData")
.GetFieldValue <VFXExpressionGraph>("m_ExpressionGraph");
var gpuMapper = expressionGraph.BuildGPUMapper(context);
var uniformMapper = new VFXUniformMapper(gpuMapper, context.doesGenerateShader);
var blockIndex = context.activeChildrenWithImplicit
.Select((value, index) => new
{
value,
index
})
.Where(pair => pair.value == this)
.Select(pair => pair.index + 1)
.FirstOrDefault() - 1;
var writer = new VFXShaderWriter();
var expressionToName = data
.GetAttributes()
.ToDictionary(o =>
new VFXAttributeExpression(o.attrib) as VFXExpression,
o => (new VFXAttributeExpression(o.attrib)).GetCodeString(null));
expressionToName = expressionToName
.Union(uniformMapper.expressionToCode).ToDictionary(s => s.Key, s => s.Value);
var blockParameters = mergedAttributes.Select(o => new VFXShaderWriter.FunctionParameter
{
name = o.attrib.name, expression = new VFXAttributeExpression(o.attrib) as VFXExpression, mode = o.mode
}).ToList();
foreach (var blockParameter in parameters)
{
var expReduced = gpuMapper.FromNameAndId(blockParameter.name, blockIndex);
if (VFXExpression.IsTypeValidOnGPU(expReduced.valueType))
{
blockParameters.Add(new VFXShaderWriter.FunctionParameter
{
name = blockParameter.name, expression = expReduced, mode = VFXAttributeMode.None
});
}
}
var scoped = blockParameters.Any(o => !expressionToName.ContainsKey(o.expression));
if (scoped)
{
expressionToName = new Dictionary <VFXExpression, string>(expressionToName);
writer.EnterScope();
foreach (var exp in blockParameters.Select(o => o.expression))
{
if (expressionToName.ContainsKey(exp))
{
continue;
}
writer.WriteVariable(exp, expressionToName);
}
}
writer.WriteCallFunction(GetMethodName(), blockParameters, gpuMapper, expressionToName);
if (scoped)
{
writer.ExitScope();
}
return(writer.builder.ToString());
}
