private void determineCheapCombineOp(ref StringBuilder cheapMap, RMObj obj, uint index)
{
CombineOpsTypes combineOpType = obj.CombineOpType;
string combineOps = "_combineOps" + "[" + index + "].y);";
if (!obj.IsPrim)
{
combineOps = "_combineOpsCSGs" + "[" + index + "].w);";
}
switch (combineOpType)
{
case CombineOpsTypes.Union:
cheapMap.AppendLine("\tscene = opU(scene, obj);");
break;
case CombineOpsTypes.SmoothUnion:
cheapMap.AppendLine("\tscene = opSmoothUnion(scene, obj, " + combineOps);
break;
case CombineOpsTypes.SmoothSubtraction:
cheapMap.AppendLine("\tscene = opSmoothUnion(scene, obj, " + combineOps);
break;
case CombineOpsTypes.SmoothIntersection:
cheapMap.AppendLine("\tscene = opSmoothUnion(scene, obj, " + combineOps);
break;
default:
cheapMap.AppendLine("\tscene = opU(scene, obj);");
break;
}
}
//// Start is called before the first frame update
//void Start()
//{
//}
//// Update is called once per frame
//void Update()
//{
//}
public void resetCSG()
{
_firstNode = null;
_secondNode = null;
_nodeCombineOpType = NodeCombineOpsTypes.Union;
_nodeCombineSmoothness = 0.0f;
_combineOpType = CombineOpsTypes.Union;
_combineSmoothness = 0.0f;
_isRoot = true;
}
public void displayCombineOp(GUIContent label, RMObj obj)
{
EditorGUILayout.PropertyField(_combineOpType, label);
label.text = "Combine Smoothness";
if (_combineOpType.intValue == (int)CombineOpsTypes.SmoothUnion ||
_combineOpType.intValue == (int)CombineOpsTypes.SmoothSubtraction ||
_combineOpType.intValue == (int)CombineOpsTypes.SmoothIntersection)
{
EditorGUILayout.PropertyField(_combineSmoothness);
obj.CombineSmoothness = Mathf.Clamp(_combineSmoothness.floatValue, 0.0f, Mathf.Infinity);
}
}
//private void buildPrimitives(ref StringBuilder map, ref uint primIndex)
//{
// foreach (RMPrimitive prim in _rmMemoryManager.RM_Prims)
// {
// // Skip any primitives belonging to a csg, as they will be rendered recursively by thier respective csgs.
// if (prim.CSGNode)
// continue;
// parsePrimitive(ref map, prim, ref primIndex);
// }
//}
//private void buildCSGs(ref StringBuilder map, ref uint primIndex)
//{
// uint csgIndex = 0;
// map.AppendLine("\t// ######### Render CSGs #########");
// map.AppendLine("\trmPixel obj2;");
// map.AppendLine("\trmPixel csg;");
// map.AppendLine("\trmPixel storedCSGs[MAX_CSG_CHILDREN];");
// map.AppendLine();
// foreach (CSG csg in _rmMemoryManager.CSGs)
// {
// // Skip any non-root CSGs, as they will be rendered recursively by thier parents.
// // Skip any CSGs which don't have two nodes.
// if (!csg.IsRoot || !csg.IsValid)
// continue;
// map.AppendLine("\t// ######### " + csg.gameObject.name + " #########");
// parseCSG(ref map, csg, ref primIndex, ref csgIndex);
// determineCombineOp(ref map, null, csg, csgIndex - 1);
// map.AppendLine("\t// ######### " + csg.gameObject.name + " #########");
// map.AppendLine();
// }
//}
#endregion Old
private void parseCheapObj(ref StringBuilder cheapMap, RMObj obj, ref uint primIndex, ref uint csgIndex)
{
if (!obj.Static)
{
// Determine position and geometric information
cheapMap.AppendLine("\tpos = mul(_invModelMats[" + primIndex + "], float4(p, 1.0));");
cheapMap.AppendLine("\tgeoInfo = _boundGeoInfo[" + primIndex + "];");
cheapMap.Append("\tobj = ");
// Determine primitive type
switch (obj.BoundShape)
{
case BoundingShapes.Sphere:
cheapMap.AppendLine("sdSphere(pos.xyz, geoInfo.x);");
break;
case BoundingShapes.Box:
cheapMap.AppendLine("sdBox(pos.xyz, geoInfo.xyz);");
break;
default:
Debug.LogError("Obj's bound shape, in cheap map, could not be parsed.");
break;
}
cheapMap.AppendLine();
// Determine combining operation
determineCheapCombineOp(ref cheapMap, obj, primIndex);
if (obj.IsPrim)
{
++primIndex;
}
else
{
parseCheapCSG(ref cheapMap, obj as CSG, ref primIndex, ref csgIndex);
}
}
else
{
Matrix4x4 mat;
Vector4 info;
// Determine position and geometric information
mat = obj.transform.localToWorldMatrix.inverse;
cheapMap.AppendLine("\tpos = mul(float4x4(" + mat.m00 + ", " + mat.m01 + ", " + mat.m02 + ", " + mat.m03 + ", "
+ mat.m10 + ", " + mat.m11 + ", " + mat.m12 + ", " + mat.m13 + ", "
+ mat.m20 + ", " + mat.m21 + ", " + mat.m22 + ", " + mat.m23 + ", "
+ mat.m30 + ", " + mat.m31 + ", " + mat.m32 + ", " + mat.m33 + "), float4(p, 1.0));");
info = obj.BoundGeoInfo;
cheapMap.AppendLine("\tgeoInfo = float4(" + info.x + ", " + info.y + ", " + info.z + ", " + info.w + ");");
// Determine primitive type
switch (obj.BoundShape)
{
case BoundingShapes.Sphere:
cheapMap.AppendLine("sdSphere(pos.xyz, geoInfo.x);");
break;
case BoundingShapes.Box:
cheapMap.AppendLine("sdBox(pos.xyz, geoInfo.xyz);");
break;
default:
Debug.LogError("Obj's bound shape, in cheap map, could not be parsed.");
break;
}
cheapMap.AppendLine();
// Determine combining operation
determineCheapCombineOp(ref cheapMap, obj, primIndex);
//map.AppendLine();
++primIndex;
}
}
public void displayAlterations(GUIContent label, RMObj obj)
{
EditorGUILayout.Space();
// Alterations
label.text = "Alterations";
label.tooltip = "";
EditorGUILayout.LabelField(label, EditorStyles.boldLabel);
// Clear all alterations.
if (GUILayout.Button("Clear Alts"))
{
obj.clearAlts();
}
for (int i = 0; i < _alts.Count; ++i)
{
_currentAlt = _alts[i];
activeProperty = _currentAlt.FindPropertyRelative("active");
// No alterations are active.
if (!activeProperty.boolValue)
{
break;
}
EditorGUILayout.Space();
EditorGUILayout.Space();
label.text = "Alteration " + (i + 1);
EditorGUILayout.LabelField(label, EditorStyles.boldLabel);
// Display the current alteration's information.
DisplayAltInfo(_currentAlt);
// Remove current alteration.
GUILayout.BeginHorizontal();
if (GUILayout.Button("Remove Alteration"))
{
removeAlt(_currentAlt);
obj.AltsDirty = true;
}
// Move current alteration up.
EditorGUI.BeginDisabledGroup(i == 0);
if (GUILayout.Button("Move Up"))
{
moveUp(_currentAlt, i);
obj.AltsDirty = true;
}
EditorGUI.EndDisabledGroup();
bool disabled = (i == (_alts.Count - 1));
if (i < (_alts.Count - 1))
{
disabled = !_alts[i + 1].FindPropertyRelative("active").boolValue;
}
// Move current alteration down.
EditorGUI.BeginDisabledGroup(disabled);
if (GUILayout.Button("Move Down"))
{
moveDown(_currentAlt, i);
obj.AltsDirty = true;
}
EditorGUI.EndDisabledGroup();
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
EditorGUILayout.Space();
// Add an alteration.
if (GUILayout.Button("Add Alteration"))
{
addAlt();
obj.AltsDirty = true;
}
}
public override void OnInspectorGUI()
{
//base.OnInspectorGUI();
RMObj rmObj = target as RMObj;
serializedObject.Update();
GUIContent label = new GUIContent("Shader Options", "All ray marching shaders you can add this object to.");
// Retrieve all the ray march shaders, and display them as options to be added to.
List <RayMarchShader> shaders = _rayMarcher.Shaders;
if (shaders.Count > 0)
{
// Retrieve all the shaders' names.
_shaderNames = new string[shaders.Count];
for (int i = 0; i < shaders.Count; ++i)
{
_shaderNames[i] = shaders[i].ShaderName;
}
// Display them.
_selectedShaderIndex = EditorGUILayout.Popup(label, _selectedShaderIndex, _shaderNames);
if (GUILayout.Button("Add To Shader"))
{
shaders[_selectedShaderIndex].RenderList.Add(rmObj);
}
}
else
{
_selectedShaderIndex = EditorGUILayout.Popup(label, _selectedShaderIndex, _shaderNames);
}
label.text = "Draw Order";
label.tooltip = "The order in which this object will be placed in the shader.";
EditorGUILayout.PropertyField(_drawOrder, label);
label.text = "Static";
label.tooltip = "Will hard code all info into the shader.";
EditorGUILayout.PropertyField(_static, label);
label.text = "Bound Shape";
label.tooltip = "";
EditorGUILayout.PropertyField(_boundShape, label);
label.text = "Bound Geo Info";
label.tooltip = "The dimensions of the bounding shape for this object.";
Vector4 boundGeoInfo = new Vector4(1.0f, 1.0f, 1.0f, 0.0f);
switch (_boundShape.enumValueIndex)
{
case (int)BoundingShapes.Sphere:
boundGeoInfo.x = EditorGUILayout.FloatField("Radius", _boundGeoInfo.vector4Value.x);
_boundGeoInfo.vector4Value = boundGeoInfo;
break;
case (int)BoundingShapes.Box:
boundGeoInfo.x = EditorGUILayout.FloatField("Length", _boundGeoInfo.vector4Value.x);
boundGeoInfo.z = EditorGUILayout.FloatField("Breadth", _boundGeoInfo.vector4Value.z);
boundGeoInfo.y = EditorGUILayout.FloatField("Height", _boundGeoInfo.vector4Value.y);
_boundGeoInfo.vector4Value = boundGeoInfo;
break;
default:
break;
}
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
var csg = target as CSG;
//bool firstPrimChanged = false;
//bool secondPrimChanged = false;
//RMPrimitive firstPrimRef = null;
//RMPrimitive secondPrimRef = null;
bool firstNodeChanged = false;
bool secondNodeChanged = false;
RMObj firstNodeRef = null;
RMObj secondNodeRef = null;
GUIContent label = new GUIContent("Node Combine Op", "How the two nodes will interact.");
bool nodeCombineOpChanged = false;
serializedObject.Update();
_isRoot.boolValue = EditorGUILayout.Toggle("Is Root CSG", _isRoot.boolValue);
EditorGUILayout.Toggle("Is Valid CSG", csg.IsValid);
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(_firstNode);
firstNodeChanged = EditorGUI.EndChangeCheck();
firstNodeRef = csg.FirstNode;
// Determine how the two objects will interact.
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(_nodeCombineOpType, label);
nodeCombineOpChanged = EditorGUI.EndChangeCheck();
// Display the smoothness property for certain operations.
if (_nodeCombineOpType.intValue == (int)NodeCombineOpsTypes.SmoothUnion ||
_nodeCombineOpType.intValue == (int)NodeCombineOpsTypes.SmoothSubtraction ||
_nodeCombineOpType.intValue == (int)NodeCombineOpsTypes.SmoothIntersection)
{
//csg.NodeCombineSmoothness = Mathf.Clamp(EditorGUILayout.FloatField("Node Combine Smoothness", csg.NodeCombineSmoothness), 0.0f, Mathf.Infinity);
EditorGUILayout.PropertyField(_nodeCombineSmoothness);
csg.NodeCombineSmoothness = Mathf.Clamp(_nodeCombineSmoothness.floatValue, 0.0f, Mathf.Infinity);
}
else if (_nodeCombineOpType.intValue == (int)NodeCombineOpsTypes.Lerp)
{
label.text = "Interpolation Value";
EditorGUILayout.PropertyField(_nodeCombineSmoothness, label);
//csg.NodeCombineSmoothness = Mathf.Clamp(_nodeCombineSmoothness.floatValue, 0.0f, Mathf.Infinity);
}
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(_secondNode);
secondNodeChanged = EditorGUI.EndChangeCheck();
secondNodeRef = csg.SecondNode;
EditorGUI.BeginDisabledGroup(!csg.IsRoot);
// Determine how the CSG will interact with the scene.
label.text = "CSG Combine Op";
if (csg.IsRoot)
{
label.tooltip = "How the CSG will interact with the scene.";
}
else
{
label.tooltip = "Overridden by parent CSG.";
}
displayCombineOp(label, csg);
EditorGUI.EndDisabledGroup();
// Display Alterations
displayAlterations(label, csg);
serializedObject.ApplyModifiedProperties();
// Avoids change if the same node was used for both slots.
if (csg.FirstNode && (csg.FirstNode == csg.SecondNode))
{
// First slot was the same as the second's slot.
if (firstNodeChanged)
{
firstNodeChanged = false;
csg.FirstNode = null;
}
// Second slot was the same as the first's slot.
else
{
secondNodeChanged = false;
csg.SecondNode = null;
}
}
// First node has been added, changed, or removed. (Avoids change if user selected the same first node.)
if (firstNodeChanged && (csg.FirstNode != firstNodeRef))
{
// First node was just added/changed.
if (csg.FirstNode)
{
if (csg.IsFirstPrim)
{
(csg.FirstNode as RMPrimitive).CSGNode = true;
}
else
{
(csg.FirstNode as CSG).IsRoot = false;
}
}
// Previous first node was just removed/changed, iff not previously empty.
if (firstNodeRef)
{
if (firstNodeRef.IsPrim)
{
(firstNodeRef as RMPrimitive).CSGNode = false;
}
else
{
(firstNodeRef as CSG).IsRoot = true;
}
}
}
// Second node has been added, changed, or removed. (Avoids change if user selected the same second node.)
if (secondNodeChanged && (csg.SecondNode != secondNodeRef))
{
// Second node was just added/changed.
if (csg.SecondNode)
{
if (csg.IsSecondPrim)
{
(csg.SecondNode as RMPrimitive).CSGNode = true;
}
else
{
(csg.SecondNode as CSG).IsRoot = false;
}
}
// Previous second node was just removed/changed, iff not previously empty.
if (secondNodeRef)
{
if (secondNodeRef.IsPrim)
{
(secondNodeRef as RMPrimitive).CSGNode = false;
}
else
{
(secondNodeRef as CSG).IsRoot = true;
}
}
}
// Update and reload the shader.
//if (nodeCombineOpChanged)
// Camera.main.GetComponent<ShaderBuilder>().build();
//if (combineOpChanged)
// Camera.main.GetComponent<ShaderBuilder>().build();
}
