//public float amplify = 1.0f;
// Virtual method for all mods
public override void SetValues(MegaModifier mod)
{
MegaBend bm = (MegaBend)mod;
//angle = bm.angle;
dir = bm.dir;
axis = bm.axis;
}
static void RenderGizmoSelected(MegaModifier mod, GizmoType gizmoType)
{
if ( GUI.changed )
{
Debug.Log("Editing " + mod.ModName());
}
}
void AddMod(GameObject go, string name, bool modobj)
{
if (go)
{
MeshFilter mf = go.GetComponent <MeshFilter>();
if (mf != null)
{
if (modobj)
{
MegaModifyObject mod = go.GetComponent <MegaModifyObject>();
if (mod == null)
{
mod = go.AddComponent <MegaModifyObject>();
mod.NormalMethod = NormalMethod;
}
}
if (name != null)
{
MegaModifier md = (MegaModifier)UnityEngineInternal.APIUpdaterRuntimeServices.AddComponent(go, "Assets/Mega-Fiers/Editor/MegaFiers/MegaFiersWindow.cs (390,38)", name);
if (md)
{
md.gizCol1 = col1;
md.gizCol2 = col2;
}
}
}
}
}
//bool showweight = true;
public void CommonModParamsBasic(MegaModifier mod)
{
// Basic mod stuff
//showmodparams = EditorGUILayout.Foldout(showmodparams, "Modifier Common Params");
//if ( showmodparams )
//{
mod.ModEnabled = EditorGUILayout.Toggle("Mod Enabled", mod.ModEnabled);
mod.DisplayGizmo = EditorGUILayout.Toggle("Display Gizmo", mod.DisplayGizmo);
int order = EditorGUILayout.IntField("Order", mod.Order);
if ( order != mod.Order )
{
mod.Order = order;
MegaModifiers context = mod.GetComponent<MegaModifiers>();
if ( context != null )
context.BuildList();
}
mod.gizCol1 = EditorGUILayout.ColorField("Giz Col 1", mod.gizCol1);
mod.gizCol2 = EditorGUILayout.ColorField("Giz Col 2", mod.gizCol2);
mod.steps = EditorGUILayout.IntField("Gizmo Detail", mod.steps);
if ( mod.steps < 1 )
mod.steps = 1;
//}
//mod.useWeights = EditorGUILayout.Toggle("Use Weights", mod.useWeights);
//if ( mod.useWeights )
// mod.weightChannel = (MegaWeightChannel)EditorGUILayout.EnumPopup("Weight Channel", mod.weightChannel);
}
static void RenderGizmoSelected(MegaModifier mod, GizmoType gizmoType)
{
if (GUI.changed)
{
Debug.Log("Editing " + mod.ModName());
}
}
void AddModType(GameObject go, System.Type name, bool modobj)
{
if (go)
{
MeshFilter mf = go.GetComponent <MeshFilter>();
if (mf != null)
{
if (modobj)
{
MegaModifyObject mod = go.GetComponent <MegaModifyObject>();
if (mod == null)
{
mod = go.AddComponent <MegaModifyObject>();
mod.NormalMethod = NormalMethod;
}
}
if (name != null)
{
MegaModifier md = (MegaModifier)go.AddComponent(name);
if (md)
{
md.gizCol1 = col1;
md.gizCol2 = col2;
}
}
}
}
}
public override void OnInspectorGUI()
{
MegaModifier mod = (MegaModifier)target;
serializedObject.Update();
if (mod.useUndo)
{
undoManager.CheckUndo();
}
DrawGUI();
serializedObject.ApplyModifiedProperties();
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
if (mod.useUndo)
{
undoManager.CheckDirty();
}
}
public void CommonModParamsBasic(MegaModifier mod)
{
EditorGUILayout.PropertyField(labelProp, new GUIContent("Label"));
EditorGUILayout.PropertyField(maxlodProp, new GUIContent("MaxLOD"));
EditorGUILayout.PropertyField(modenabledProp, new GUIContent("Mod Enabled"));
EditorGUILayout.PropertyField(displaygizmoProp, new GUIContent("Display Gizmo"));
int order = mod.Order;
EditorGUILayout.PropertyField(orderProp, new GUIContent("Order"));
if (order != mod.Order)
{
mod.Order = order;
MegaModifiers context = mod.GetComponent <MegaModifiers>();
if (context != null)
{
context.BuildList();
}
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Gizmo Col");
EditorGUILayout.PropertyField(gizcol1Prop, GUIContent.none, true); //, new GUIContent("Display Gizmo"));
EditorGUILayout.PropertyField(gizcol2Prop, GUIContent.none, true); //, new GUIContent("Display Gizmo"));
EditorGUILayout.EndHorizontal();
EditorGUILayout.PropertyField(gizmodetailProp, new GUIContent("Gizmo Detail")); //, new GUIContent("Display Gizmo"));
}
// Virtual method for all mods
public override void SetValues(MegaModifier mod)
{
MegaBend bm = (MegaBend)mod;
dir = bm.dir;
axis = bm.axis;
}
private void OnEnable()
{
src = target as MegaModifier;
// Instantiate undoManager
if (src != null)
{
undoManager = new MegaUndo(src, src.ModName() + " change");
}
#if false
labelProp = serializedObject.FindProperty("Label");
maxlodProp = serializedObject.FindProperty("MaxLOD");
modenabledProp = serializedObject.FindProperty("ModEnabled");
displaygizmoProp = serializedObject.FindProperty("DisplayGizmo");
orderProp = serializedObject.FindProperty("Order");
gizcol2Prop = serializedObject.FindProperty("gizCol2");
gizcol1Prop = serializedObject.FindProperty("gizCol1");
gizmodetailProp = serializedObject.FindProperty("steps");
offsetProp = serializedObject.FindProperty("Offset");
gizmoposProp = serializedObject.FindProperty("gizmoPos");
gizmorotProp = serializedObject.FindProperty("gizmoRot");
gizmoscaleProp = serializedObject.FindProperty("gizmoScale");
#endif
Enable();
}
private void OnEnable()
{
src = target as MegaModifier;
// Instantiate undoManager
undoManager = new MegaUndo(src, src.ModName() + " change");
}
void AddModType(GameObject go, System.Type name, bool modobj)
{
if (go)
{
if (!name.IsSubclassOf(typeof(MegaModifier)) && !name.IsSubclassOf(typeof(MegaWarp)))
{
go.AddComponent(name);
}
else
{
MeshFilter mf = go.GetComponent <MeshFilter>();
if (mf != null)
{
if (modobj)
{
if (name.IsSubclassOf(typeof(MegaModifier)))
{
MegaModifyObject mod = go.GetComponent <MegaModifyObject>();
if (mod == null)
{
mod = go.AddComponent <MegaModifyObject>();
mod.NormalMethod = NormalMethod;
}
}
}
if (name != null)
{
if (name.IsSubclassOf(typeof(MegaModifier)))
{
MegaModifier md = (MegaModifier)go.AddComponent(name);
if (md)
{
md.gizCol1 = col1;
md.gizCol2 = col2;
}
}
else
{
if (name.IsSubclassOf(typeof(MegaWarp)))
{
MegaWarp md = (MegaWarp)go.AddComponent(name);
if (md)
{
md.GizCol1 = col1;
md.GizCol2 = col2;
}
}
else
{
go.AddComponent(name);
}
}
}
}
}
}
}
public virtual void DrawSceneGUI()
{
MegaModifier mod = (MegaModifier)target;
if (mod.ModEnabled && mod.DisplayGizmo && MegaModifiers.GlobalDisplay && showmodparams)
{
MegaModifiers context = mod.GetComponent <MegaModifiers>();
if (context != null && context.Enabled && context.DrawGizmos)
{
//mod.Offset = -Handles.PositionHandle(-mod.Offset, Quaternion.identity);
float a = mod.gizCol1.a;
Color col = Color.white;
Quaternion rot = mod.transform.localRotation;
Handles.matrix = Matrix4x4.identity;
if (mod.Offset != Vector3.zero)
{
Vector3 pos = mod.transform.localToWorldMatrix.MultiplyPoint(-mod.Offset);
Handles.Label(pos, mod.ModName() + " Offset\n" + mod.Offset.ToString("0.000"));
col = Color.blue;
col.a = a;
Handles.color = col;
Handles.ArrowCap(0, pos, rot * Quaternion.Euler(180.0f, 0.0f, 0.0f), mod.GizmoSize());
col = Color.green;
col.a = a;
Handles.color = col;
Handles.ArrowCap(0, pos, rot * Quaternion.Euler(90.0f, 0.0f, 0.0f), mod.GizmoSize());
col = Color.red;
col.a = a;
Handles.color = col;
Handles.ArrowCap(0, pos, rot * Quaternion.Euler(0.0f, -90.0f, 0.0f), mod.GizmoSize());
}
// gizmopos
if (mod.gizmoPos != Vector3.zero)
{
Vector3 pos = mod.transform.localToWorldMatrix.MultiplyPoint(-mod.gizmoPos);
Handles.Label(pos, mod.ModName() + " Pos\n" + mod.gizmoPos.ToString("0.000"));
col = Color.blue;
col.a = a;
Handles.color = col;
Handles.ArrowCap(0, pos, rot * Quaternion.Euler(180.0f, 0.0f, 0.0f), mod.GizmoSize());
col = Color.green;
col.a = a;
Handles.color = col;
Handles.ArrowCap(0, pos, rot * Quaternion.Euler(90.0f, 0.0f, 0.0f), mod.GizmoSize());
col = Color.red;
col.a = a;
Handles.color = col;
Handles.ArrowCap(0, pos, rot * Quaternion.Euler(0.0f, -90.0f, 0.0f), mod.GizmoSize());
}
Handles.matrix = Matrix4x4.identity;
}
}
}
public void ModReset(MegaModifier m)
{
if (m != null)
{
m.SetModMesh(cachedMesh);
BuildList();
}
}
// Virtual method for all mods
public override void SetValues(MegaModifier mod)
{
MegaBend bm = (MegaBend)mod;
angle = bm.angle;
dir = bm.dir;
axis = bm.axis;
doRegion = bm.doRegion;
from = bm.from;
to = bm.to;
}
public override void PostCopy(MegaModifier src)
{
MegaFFD ffd = (MegaFFD)src;
pt = new Vector3[64];
for (int c = 0; c < 64; c++)
{
pt[c] = ffd.pt[c];
}
}
// Virtual method for all mods
public override void SetValues(MegaModifier mod)
{
MegaBend bm = (MegaBend)mod;
angle = bm.angle;
dir = bm.dir;
axis = bm.axis;
doRegion = bm.doRegion;
from = bm.from;
to = bm.to;
}
void Done()
{
for (int m = 0; m < mods.Length; m++)
{
MegaModifier mod = mods[m];
if (mod.valid)
{
mod.ModEnd(this);
}
}
}
public MegaModifier Add(Type type)
{
MegaModifier mod = (MegaModifier)gameObject.AddComponent(type);
if (mod != null)
{
BuildList();
}
return(mod);
}
public MegaModifier Add(string type)
{
MegaModifier mod = (MegaModifier)UnityEngineInternal.APIUpdaterRuntimeServices.AddComponent(gameObject, "Assets/Mega-Fiers/Scripts/MegaFiers/Modifiers/MegaModifiers.cs (614,36)", type);
if (mod != null)
{
BuildList();
}
return(mod);
}
void DoWork1(int start, int end)
{
for (int m = 0; m < mods.Length; m++)
{
MegaModifier mod = mods[m];
if (mod.valid)
{
mod.DoWork(this, 0, start, end, Cores + 1);
}
}
}
// Used for copying and prefabs
public virtual void Copy(MegaModifier dst)
{
dst.ModEnabled = ModEnabled;
dst.DisplayGizmo = DisplayGizmo;
dst.Order = Order;
dst.Offset = Offset;
dst.gizmoPos = gizmoPos;
dst.gizmoRot = gizmoRot;
dst.gizmoScale = gizmoScale;
dst.gizCol1 = gizCol1;
dst.gizCol2 = gizCol2;
}
public MegaModifier Add(string type)
{
Type t = System.Reflection.Assembly.GetExecutingAssembly().GetType(type);
MegaModifier mod = (MegaModifier)gameObject.AddComponent(t);
if (mod != null)
{
BuildList();
}
return(mod);
}
public override void PostCopy(MegaModifier src)
{
MegaMorphBase mor = (MegaMorphBase)src;
chanBank = new List <MegaMorphChan>();
for (int c = 0; c < mor.chanBank.Count; c++)
{
MegaMorphChan chan = new MegaMorphChan();
MegaMorphChan.Copy(mor.chanBank[c], chan);
chanBank.Add(chan);
}
}
public override void PostCopy(MegaModifier src)
{
MegaMorphBase mor = (MegaMorphBase)src;
chanBank = new List<MegaMorphChan>();
for ( int c = 0; c < mor.chanBank.Count; c++ )
{
MegaMorphChan chan = new MegaMorphChan();
MegaMorphChan.Copy(mor.chanBank[c], chan);
chanBank.Add(chan);
}
}
public virtual void DrawGUI()
{
MegaModifier mod = (MegaModifier)target;
MegaModifiers context = mod.GetComponent <MegaModifiers>();
if (context == null)
{
EditorGUILayout.LabelField("You need to Add a Mega Modify Object Component");
return;
}
//showhelp = EditorGUILayout.Foldout(showhelp, "Help");
//if ( showhelp )
//{
//if ( image == null )
//image = LoadImage();
//if ( image != null )
//{
//float w = Screen.width - 12.0f;
//float h = (w / image.width) * image.height;
//if ( h > image.height )
//h = image.height;
//GUILayout.Label((Texture)image, GUIStyle.none, GUILayout.Width(w), GUILayout.Height(h));
//}
//}
if (DisplayCommon())
{
CommonModParams((MegaModifier)target);
}
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
if (Inspector())
{
DrawDefaultInspector();
}
//if ( showhelp )
//GUILayout.TextArea(GetHelpString());
}
// Seperate task info for a morph mod as wont be doing all verts
void DoWork(object info)
{
MegaTaskInfo inf = (MegaTaskInfo)info;
while (isRunning)
{
inf.pauseevent.WaitOne(Timeout.Infinite);
switch (inf.jobtype)
{
case MegaJobType.Modifier:
if (inf.end > 0)
{
for (int m = 0; m < inf.modcontext.mod.mods.Length; m++)
{
MegaModifier mod = inf.modcontext.mod.mods[m];
if (mod.valid)
{
mod.DoWork(this, inf.index, inf.start, inf.end, Cores + 1);
}
}
//inf.end = 0; // Done the job
}
break;
case MegaJobType.FaceNormalCalc:
RecalcFaceNormalsMT(inf.modcontext.mod, inf.index, Cores + 1);
break;
case MegaJobType.VertexNormalCalc:
RecalcVertexNormalsMT(inf.modcontext.mod, inf.index, Cores + 1);
break;
case MegaJobType.FaceTangentCalc:
BuildFaceTangentsMT(inf.modcontext.mod, inf.index, Cores + 1);
break;
case MegaJobType.VertexTangentCalc:
BuildVertexTangentsMT(inf.modcontext.mod, inf.index, Cores + 1);
break;
}
inf.end = 0; // Done the job
}
}
//bool showweight = true;
//private static GUILayoutOption colWidth = GUILayout.MaxWidth(75.0f);
#if true
public void CommonModParamsBasic(MegaModifier mod)
{
// Basic mod stuff
//showmodparams = EditorGUILayout.Foldout(showmodparams, "Modifier Common Params");
//if ( showmodparams )
//{
mod.Label = EditorGUILayout.TextField("Label", mod.Label);
mod.MaxLOD = EditorGUILayout.IntField("MaxLOD", mod.MaxLOD);
mod.ModEnabled = EditorGUILayout.Toggle("Mod Enabled", mod.ModEnabled);
mod.useUndo = EditorGUILayout.Toggle("Use Undo", mod.useUndo);
mod.DisplayGizmo = EditorGUILayout.Toggle("Display Gizmo", mod.DisplayGizmo);
int order = EditorGUILayout.IntField("Order", mod.Order);
if (order != mod.Order)
{
mod.Order = order;
MegaModifiers context = mod.GetComponent <MegaModifiers>();
if (context != null)
{
context.BuildList();
}
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Gizmo Col");
//mod.gizCol1 = EditorGUILayout.ColorField("Giz Col 1", mod.gizCol1, colWidth);
//mod.gizCol2 = EditorGUILayout.ColorField("Giz Col 2", mod.gizCol2, colWidth);
mod.gizCol1 = EditorGUILayout.ColorField(mod.gizCol1); //, colWidth);
mod.gizCol2 = EditorGUILayout.ColorField(mod.gizCol2); //, colWidth);
EditorGUILayout.EndHorizontal();
mod.steps = EditorGUILayout.IntField("Gizmo Detail", mod.steps);
if (mod.steps < 1)
{
mod.steps = 1;
}
//}
//mod.useWeights = EditorGUILayout.Toggle("Use Weights", mod.useWeights);
//if ( mod.useWeights )
// mod.weightChannel = (MegaWeightChannel)EditorGUILayout.EnumPopup("Weight Channel", mod.weightChannel);
}
static public GameObject DoCopyObjects(GameObject from)
{
MegaModifyObject fromMod = from.GetComponent <MegaModifyObject>();
GameObject to;
if (fromMod)
{
to = CopyMesh(from, fromMod);
}
else
{
to = CopyMesh(from);
}
MegaModifyObject mo = to.AddComponent <MegaModifyObject>();
CopyModObj(fromMod, mo);
MegaModifier[] mods = from.GetComponents <MegaModifier>();
for (int i = 0; i < mods.Length; i++)
{
Component com = CopyComponent(mods[i], to);
// TODO: Add method to modifiers so can deal with any special cases
if (com)
{
MegaModifier mod = (MegaModifier)com;
mod.PostCopy(mods[i]);
}
}
MegaWrap wrap = from.GetComponent <MegaWrap>();
if (wrap)
{
CopyComponent(wrap, to);
}
if (mo)
{
mo.MeshUpdated();
}
to.name = from.name + " - Copy";
return(to);
}
public void CommonModParams(MegaModifier mod)
{
showmodparams = EditorGUILayout.Foldout(showmodparams, "Modifier Common Params");
if (showmodparams)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Rst Off"))
{
mod.Offset = Vector3.zero;
EditorUtility.SetDirty(target);
}
if (GUILayout.Button("Rst Pos"))
{
mod.gizmoPos = Vector3.zero;
EditorUtility.SetDirty(target);
}
if (GUILayout.Button("Rst Rot"))
{
mod.gizmoRot = Vector3.zero;
EditorUtility.SetDirty(target);
}
if (GUILayout.Button("Rst Scl"))
{
mod.gizmoScale = Vector3.one;
EditorUtility.SetDirty(target);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.PropertyField(offsetProp, new GUIContent("Offset"), true);
EditorGUILayout.PropertyField(gizmoposProp, new GUIContent("Gizmo Pos"), true);
EditorGUILayout.PropertyField(gizmorotProp, new GUIContent("Gizmo Rot"), true);
EditorGUILayout.PropertyField(gizmoscaleProp, new GUIContent("Gizmo Scale"), true);
CommonModParamsBasic(mod);
}
}
public override void OnInspectorGUI()
{
MegaModifier mod = (MegaModifier)target;
if (mod.useUndo)
{
undoManager.CheckUndo();
}
DrawGUI();
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
if (mod.useUndo)
{
undoManager.CheckDirty();
}
}
public void CommonModParams(MegaModifier mod)
{
showmodparams = EditorGUILayout.Foldout(showmodparams, "Modifier Common Params");
if (showmodparams)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Rst Off"))
{
mod.Offset = Vector3.zero;
EditorUtility.SetDirty(target);
}
if (GUILayout.Button("Rst Pos"))
{
mod.gizmoPos = Vector3.zero;
EditorUtility.SetDirty(target);
}
if (GUILayout.Button("Rst Rot"))
{
mod.gizmoRot = Vector3.zero;
EditorUtility.SetDirty(target);
}
if (GUILayout.Button("Rst Scl"))
{
mod.gizmoScale = Vector3.one;
EditorUtility.SetDirty(target);
}
EditorGUILayout.EndHorizontal();
mod.Offset = EditorGUILayout.Vector3Field("Offset", mod.Offset);
mod.gizmoPos = EditorGUILayout.Vector3Field("Gizmo Pos", mod.gizmoPos);
mod.gizmoRot = EditorGUILayout.Vector3Field("Gizmo Rot", mod.gizmoRot);
mod.gizmoScale = EditorGUILayout.Vector3Field("Gizmo Scale", mod.gizmoScale);
CommonModParamsBasic(mod);
}
}
void PrepareForMT()
{
selection = null;
for (int m = 0; m < mods.Length; m++)
{
MegaModifier mod = mods[m];
mod.valid = false;
if (mod != null && mod.ModEnabled)
{
modContext.Offset = mod.Offset;
modContext.bbox = mod.bbox;
mod.SetTM();
if (mod.ModLateUpdate(modContext))
{
mod.valid = true;
if ((mod.ChannelsReq() & MegaModChannel.Verts) != 0)
{
mod.verts = GetSourceVerts(); // is this a ref or does it do a copy
mod.sverts = GetDestVerts();
}
if (UpdateMesh < 1)
{
UpdateMesh = 1;
}
dirtyChannels |= mod.ChannelsChanged();
}
mod.selection = selection;
mod.PrepareMT(this, Cores + 1);
}
}
}
// Needs to be an override for ModReset
public void GroupModReset(MegaModifier m)
{
if (m != null)
{
int i;
for (i = 0; i < targets.Count; i++)
{
GameObject targ = targets[i].go;
Bounds b = new Bounds();
Mesh cm = targets[i].cachedMesh;
if (cm != null)
{
b = cm.bounds;
}
for (int t = 0; t < targets.Count; t++)
{
Mesh ms = targets[t].cachedMesh;
if (t != i && ms != null)
{
Vector3 pos = targets[t].go.transform.position;
pos = targ.transform.InverseTransformPoint(pos);
Bounds mb = new Bounds(pos, targets[t].cachedMesh.bounds.size);
b.Encapsulate(mb);
}
}
targets[i].bbox.min = b.min;
targets[i].bbox.max = b.max;
targets[i].Offset = -b.center;
}
}
}
void Update()
{
// Not need to check every frame
if ((Time.time - lastLODCheckTime) > LODCheckInterval)
{
float distanceToCamera = Vector3.Distance(transform.position, theCamera.transform.position);
int selectedLOD = levelsOfDetail.Length - 1;
for (int i = levelsOfDetail.Length - 1; i >= 0; i--)
{
if (distanceToCamera > levelsOfDetail[i].distance)
{
selectedLOD = i;
break;
}
}
if (selectedLOD != currentLOD)
{
currentLOD = selectedLOD;
MegaModifyObject modifyObject;
modifyObject = meshContainer.GetComponent <MegaModifyObject>();
if (modifyObject != null)
{
// Change meshFilter to use new mesh
meshContainer.GetComponent <MeshFilter>().mesh = levelsOfDetail[selectedLOD].mesh;
modifyObject.MeshUpdated();
// Update modifiers stack state depending on its MaxLOD specified in Unity Editor
for (int i = 0; i < modifyObject.mods.Length; i++)
{
MegaModifier m = modifyObject.mods[i];
m.ModEnabled = (m.MaxLOD >= currentLOD);
}
}
}
lastLODCheckTime = Time.time;
}
}
// Needs to be an override for ModReset
public void GroupModReset(MegaModifier m)
{
if ( m != null )
{
int i;
for ( i = 0; i < targets.Count; i++ )
{
GameObject targ = targets[i].go;
Bounds b = new Bounds();
Mesh cm = targets[i].cachedMesh;
if ( cm != null )
b = cm.bounds;
for ( int t = 0; t < targets.Count; t++ )
{
Mesh ms = targets[t].cachedMesh;
if ( t != i && ms != null )
{
Vector3 pos = targets[t].go.transform.position;
pos = targ.transform.InverseTransformPoint(pos);
Bounds mb = new Bounds(pos, targets[t].cachedMesh.bounds.size);
b.Encapsulate(mb);
}
}
targets[i].bbox.min = b.min;
targets[i].bbox.max = b.max;
targets[i].Offset = -b.center;
}
}
}
public override void PostCopy(MegaModifier src)
{
MegaFFD ffd = (MegaFFD)src;
pt = new Vector3[64];
for ( int c = 0; c < 64; c++ )
{
pt[c] = ffd.pt[c];
}
}
// Virtual method for all mods
public override void SetValues(MegaModifier mod)
{
//MegaTreeBend bm = (MegaTreeBend)mod;
}
private static int CompareOrder(MegaModifier m1, MegaModifier m2)
{
return m1.Order - m2.Order;
}
private void OnEnable()
{
src = target as MegaModifier;
// Instantiate undoManager
undoManager = new MegaUndo(src, src.ModName() + " change");
}
// Used for copying and prefabs
public virtual void Copy(MegaModifier dst)
{
dst.ModEnabled = ModEnabled;
dst.DisplayGizmo = DisplayGizmo;
dst.Order = Order;
dst.Offset = Offset;
dst.gizmoPos = gizmoPos;
dst.gizmoRot = gizmoRot;
dst.gizmoScale = gizmoScale;
dst.gizCol1 = gizCol1;
dst.gizCol2 = gizCol2;
}
public virtual void PostCopy(MegaModifier dst)
{
}
public void CommonModParams(MegaModifier mod)
{
showmodparams = EditorGUILayout.Foldout(showmodparams, "Modifier Common Params");
if ( showmodparams )
{
EditorGUILayout.BeginHorizontal();
if ( GUILayout.Button("Rst Off") )
{
mod.Offset = Vector3.zero;
EditorUtility.SetDirty(target);
}
if ( GUILayout.Button("Rst Pos") )
{
mod.gizmoPos = Vector3.zero;
EditorUtility.SetDirty(target);
}
if ( GUILayout.Button("Rst Rot") )
{
mod.gizmoRot = Vector3.zero;
EditorUtility.SetDirty(target);
}
if ( GUILayout.Button("Rst Scl") )
{
mod.gizmoScale = Vector3.one;
EditorUtility.SetDirty(target);
}
EditorGUILayout.EndHorizontal();
mod.Offset = EditorGUILayout.Vector3Field("Offset", mod.Offset);
mod.gizmoPos = EditorGUILayout.Vector3Field("Gizmo Pos", mod.gizmoPos);
mod.gizmoRot = EditorGUILayout.Vector3Field("Gizmo Rot", mod.gizmoRot);
mod.gizmoScale = EditorGUILayout.Vector3Field("Gizmo Scale", mod.gizmoScale);
CommonModParamsBasic(mod);
#if false
mod.ModEnabled = EditorGUILayout.Toggle("Mod Enabled", mod.ModEnabled);
mod.DisplayGizmo = EditorGUILayout.Toggle("Display Gizmo", mod.DisplayGizmo);
int order = EditorGUILayout.IntField("Order", mod.Order);
if ( order != mod.Order )
{
mod.Order = order;
MegaModifiers context = mod.GetComponent<MegaModifiers>();
if ( context != null )
context.BuildList();
}
mod.gizCol1 = EditorGUILayout.ColorField("Giz Col 1", mod.gizCol1);
mod.gizCol2 = EditorGUILayout.ColorField("Giz Col 2", mod.gizCol2);
//showweight = EditorGUILayout.Foldout(showweight, "Modifier Weight Params");
//if ( showweight )
{
//mod.useWeights = EditorGUILayout.Toggle("Use Weights", mod.useWeights);
//if ( mod.useWeights )
//{
//mod.weightChannel = (MegaWeightChannel)EditorGUILayout.EnumPopup("Weight Channel", mod.weightChannel);
//}
}
#endif
}
}
void ShowGCommon(MegaModifier md, int i)
{
if ( (i & 1) == 1 )
GUI.color = bcol; //Color.red;
else
GUI.color = bcol1; //Color.red;
if ( GUILayout.Button(md.ModName(), GUILayout.Width(butwidth)) )
showgmod[i] = showgmod[i] ? false : true;
GUI.color = Color.white; //Color.red;
if ( showgmod[i] )
{
md.ModEnabled = GUILayout.Toggle(md.ModEnabled, "Enabled");
if ( showgcommon )
{
ProSlider("Offset", ref md.Offset, -4.0f, 4.0f, objsize);
ProSlider("Pos", ref md.gizmoPos, -4.0f, 4.0f, objsize);
ProSlider("Rot", ref md.gizmoRot, -90.0f, 90.0f, objsize);
int order = EditInt("Order", md.Order);
if ( order != md.Order )
{
md.Order = order;
gcontext.Sort();
}
}
}
}
public void ModReset(MegaModifier m)
{
if ( m != null )
{
m.SetModMesh(cachedMesh);
BuildList();
}
}
void ShowGUI(MegaModifier mod)
{
switch ( mod.ModName() )
{
case "Bend":
{
MegaBend bmod = (MegaBend)mod;
bmod.angle = AngleSlider("Angle", bmod.angle, 2.0f);
bmod.dir = AngleSlider("Direction", bmod.dir, 1.0f);
bmod.axis = (MegaAxis)XYZ("Axis", (int)bmod.axis);
bmod.doRegion = GUILayout.Toggle(bmod.doRegion, "DoRegion");
if ( bmod.doRegion )
{
bmod.from = Slider("From", bmod.from, -40.0f, 0.0f);
bmod.to = Slider("To", bmod.to, 0.0f, 40.0f);
}
}
break;
case "Hump":
MegaHump hmod = (MegaHump)mod;
Vector3 size = mod.bbox.Size();
float sz = size.magnitude * 4.0f;
hmod.amount = ProSlider("Amount", hmod.amount, -2.0f, 2.0f, sz); //objsize);
hmod.cycles = Slider("Cycles", hmod.cycles, 0.0f, 20.0f);
hmod.phase = Slider("Phase", hmod.phase, 0.0f, 10.0f);
hmod.axis = (MegaAxis)XYZ("Axis", (int)hmod.axis);
hmod.animate = GUILayout.Toggle(hmod.animate, "Animate");
if ( hmod.animate )
hmod.speed = Slider("Speed", hmod.speed, -10.0f, 10.0f);
break;
case "Twist":
{
MegaTwist tmod = (MegaTwist)mod;
tmod.angle = AngleSlider("Angle", tmod.angle, 2.0f);
tmod.Bias = Slider("Bias", tmod.Bias, -40.0f, 40.0f);
tmod.axis = (MegaAxis)XYZ("Axis", (int)tmod.axis);
tmod.doRegion = GUILayout.Toggle(tmod.doRegion, "DoRegion");
if ( tmod.doRegion )
{
tmod.from = Slider("From", tmod.from, -40.0f, 0.0f);
tmod.to = Slider("To", tmod.to, 0.0f, 40.0f);
}
}
break;
case "Taper":
{
MegaTaper tmod = (MegaTaper)mod;
tmod.amount = Slider("Amount", tmod.amount, -10.0f, 10.0f);
tmod.axis = (MegaAxis)XYZ("Axis", (int)tmod.axis);
tmod.EAxis = (MegaEffectAxis)EAxisXYZ("EffectAxis", (int)tmod.EAxis);
tmod.dir = AngleSlider("Direction", tmod.dir, 1.0f);
tmod.crv = Slider("Curve", tmod.crv, -10.0f, 10.0f);
tmod.sym = GUILayout.Toggle(tmod.sym, "Symmetry");
tmod.doRegion = GUILayout.Toggle(tmod.doRegion, "Limit Effect");
if ( tmod.doRegion )
{
tmod.from = ProSlider("From", tmod.from, 0.0f, 1.0f, objsize);
tmod.to = ProSlider("To", tmod.to, 0.0f, 1.0f, objsize);
}
}
break;
case "FFD3x3x3":
MegaFFD fmod = (MegaFFD)mod;
for ( int i = 0; i < 27; i++ )
{
string name = "p" + i;
fmod.pt[i] = ProSlider(name, ref fmod.pt[i], -2.0f, 2.0f, objsize);
}
break;
case "Noise":
MegaNoise nmod = (MegaNoise)mod;
nmod.Scale = Slider("Scale", nmod.Scale, 0.0f, 10.0f);
nmod.Freq = Slider("Freq", nmod.Freq, 0.0f, 30.0f);
nmod.Phase = Slider("Phase", nmod.Phase, 0.0f, 10.0f);
nmod.Strength = ProSlider("Strength", ref nmod.Strength, 0.0f, 1.0f, objsize);
nmod.Animate = GUILayout.Toggle(nmod.Animate, "Animate");
nmod.Fractal = GUILayout.Toggle(nmod.Fractal, "Fractal");
if ( nmod.Fractal )
{
nmod.Rough = Slider("Rough", nmod.Rough, 0.0f, 1.0f);
nmod.Iterations = Slider("Iterations", nmod.Iterations, 0.0f, 10.0f);
}
break;
case "Ripple":
MegaRipple rmod = (MegaRipple)mod;
rmod.animate = GUILayout.Toggle(rmod.animate, "Animate");
if ( rmod.animate )
rmod.Speed = Slider("Speed", rmod.Speed, -4.0f, 4.0f);
rmod.amp = ProSlider("Amp", rmod.amp, -1.0f, 1.0f, objsize);
rmod.amp2 = ProSlider("Amp2", rmod.amp2, -1.0f, 1.0f, objsize);
rmod.flex = Slider("Flex", rmod.flex, -10.0f, 10.0f);
rmod.wave = Slider("Wave", rmod.wave, -25.0f, 25.0f);
rmod.phase = Slider("Phase", rmod.phase, -100.0f, 100.0f);
rmod.Decay = Slider("decay", rmod.Decay, 0.0f, 500.0f);
break;
case "Wave":
MegaWave wmod = (MegaWave)mod;
wmod.animate = GUILayout.Toggle(wmod.animate, "Animate");
if ( wmod.animate )
wmod.Speed = Slider("Speed", wmod.Speed, -4.0f, 4.0f);
wmod.amp = ProSlider("Amp", wmod.amp, -1.0f, 1.0f, objsize * 0.75f);
wmod.amp2 = ProSlider("Amp2", wmod.amp2, -1.0f, 1.0f, objsize * 0.75f);
wmod.flex = Slider("Flex", wmod.flex, -10.0f, 10.0f);
wmod.wave = Slider("Wave", wmod.wave, -100.0f, 100.0f);
wmod.phase = Slider("Phase", wmod.phase, -100.0f, 100.0f);
wmod.Decay = Slider("decay", wmod.Decay, 0.0f, 50.0f);
wmod.dir = Slider("Direction", wmod.dir, 0.0f, 90.0f);
break;
case "Stretch":
{
MegaStretch smod = (MegaStretch)mod;
smod.amount = Slider("Amount", smod.amount, -4.0f, 4.0f);
smod.amplify = Slider("Amplify", smod.amplify, -2.0f, 2.0f);
smod.axis = (MegaAxis)XYZ("Axis", (int)smod.axis);
}
break;
case "Bubble":
{
MegaBubble bmod = (MegaBubble)mod;
bmod.radius = ProSlider("Radius", bmod.radius, -1.0f, 4.0f, objsize);
bmod.falloff = ProSlider("Falloff", bmod.falloff, -1.0f, 1.0f, objsize);
}
break;
case "Spherify":
{
MegaSpherify smod = (MegaSpherify)mod;
smod.percent = Slider("Percent", smod.percent, 0.0f, 100.0f);
}
break;
case "Skew":
{
MegaSkew smod = (MegaSkew)mod;
smod.amount = ProSlider("Amount", smod.amount, -2.0f, 2.0f, objsize);
smod.dir = AngleSlider("Dir", smod.dir, 1.0f);
smod.axis = (MegaAxis)XYZ("Axis", (int)smod.axis);
}
break;
case "Melt":
MegaMelt mmod = (MegaMelt)mod;
mmod.Amount = Slider("Amount ", mmod.Amount, 0.0f, 100.0f);
mmod.Spread = Slider("Spread", mmod.Spread, 0.0f, 100.0f);
InitMatList();
GUILayout.Label("Solidity");
mmod.MaterialType = (MegaMeltMat)GUILayout.SelectionGrid((int)mmod.MaterialType, MatList, 2, "toggle");
if ( mmod.MaterialType == MegaMeltMat.Custom )
mmod.Solidity = Slider("Custom", mmod.Solidity, 0.0f, 10.0f);
mmod.axis = (MegaAxis)XYZ("Axis", (int)mmod.axis);
mmod.FlipAxis = GUILayout.Toggle(mmod.FlipAxis, "Flip Axis");
break;
}
}
static void RenderGizmo(MegaModifier mod, GizmoType gizmoType)
{
}
public virtual void SetValues(MegaModifier mod)
{
}
