private void DrawBCL()
{
EditorGUI.LabelField(new Rect(paddedleft + 12, line, 60, LINEHEIGHT), showBclContent, (GUIStyle)"MiniLabel");
//bool bclToggle = EditorGUI.Foldout(new Rect(paddedleft, line, 16, LINEHEIGHT), fc.expandBCL, GUIContent.none/*, (GUIStyle)"OL Toggle"*/);
bool bclToggle = EditorGUI.Toggle(new Rect(paddedleft, line, 32, LINEHEIGHT), GUIContent.none, fc.expandBCL, (GUIStyle)"Foldout");
if (fc.expandBCL != bclToggle)
{
haschanged = true;
Undo.RecordObject(p.serializedObject.targetObject, "Toggle Show BCL Details");
fc.expandBCL = bclToggle;
}
float labelw = 48;
float fieldL = ir.xMin + labelw;
float fieldw = ir.width - labelw;
float fldWdth4th = fieldw / 4;
float fldWdth8th = fieldw / 8;
float fldWdth16th = fieldw / 16;
if (fc.expandBCL)
{
SolidTextures.DrawTexture(new Rect(fieldL, line, fieldw, BCL_HEIGHT - SPACING), SolidTextures.darken052D);
}
DrawBCLField(BitCullingLevel.DropAll, fieldL, fldWdth4th, fldWdth8th, fldWdth16th);
DrawBCLField(BitCullingLevel.DropHalf, fieldL, fldWdth4th, fldWdth8th, fldWdth16th);
DrawBCLField(BitCullingLevel.DropThird, fieldL, fldWdth4th, fldWdth8th, fldWdth16th);
DrawBCLField(BitCullingLevel.NoCulling, fieldL, fldWdth4th, fldWdth8th, fldWdth16th);
line += LINEHEIGHT;
if (!fc.expandBCL)
{
return;
}
//SolidTextures.DrawTexture(new Rect(paddedleft, line -1, paddedwidth, 1), SolidTextures.contrastgray2D);
EditorGUI.LabelField(new Rect(paddedleft, line, labelw, LINEHEIGHT), "bits", (GUIStyle)"MiniLabel");
// Reset Button
if (GUI.Button(new Rect(fieldL - 18 - 2, line, 18, LINEHEIGHT), rstLabel, (GUIStyle)"minibuttonleft"))
{
haschanged = true;
Undo.RecordObject(p.serializedObject.targetObject, "Reset BCL To Default");
fc.SetBits(fc.Bits);
}
line += LINEHEIGHT;
EditorGUI.LabelField(new Rect(paddedleft, line, labelw, LINEHEIGHT), "zones", (GUIStyle)"MiniLabel");
line += LINEHEIGHT;
line += SPACING;
}
private void DrawBCLField(BitCullingLevel bcl, float fieldL, float fldWdth4th, float fldWdth8th, float fldWdth16th)
{
int holdindent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
float lines = line;
float left = fieldL + fldWdth4th * (3 - (int)bcl);
if (fc.expandBCL)
{
if (bcl == BitCullingLevel.DropAll || bcl == BitCullingLevel.DropThird)
{
SolidTextures.DrawTexture(new Rect(left, line, fldWdth4th, BCL_HEIGHT), SolidTextures.darken052D);
}
string clvl =
r.width > 300 ?
(((int)bcl == 0) ? "Cull None" : ((int)bcl == 1) ? "Lvl 1" : ((int)bcl == 2) ? "Lvl 2" : "Cull All") :
(((int)bcl == 0) ? "None" : ((int)bcl == 1) ? "Lvl 1" : ((int)bcl == 2) ? "Lvl 2" : "All");
EditorGUI.LabelField(new Rect(left, lines, fldWdth4th, LINEHEIGHT), clvl, (GUIStyle)"ProjectBrowserGridLabel");
lines += LINEHEIGHT;
}
EditorGUI.indentLevel = 0;
int bits = EditorGUI.DelayedIntField(new Rect(left + fldWdth16th, lines + 1, fldWdth8th, LINEHEIGHT), fc.GetBits(bcl), MINI_TXT_FLD_STYLE);
EditorGUI.indentLevel = 0;
if (bits != fc.GetBits(bcl))
{
haschanged = true;
Undo.RecordObject(p.serializedObject.targetObject, "BCL " + bcl + " changed");
fc.SetBits(bits, bcl);
Debug.Log("bcl " + bcl + " " + bits + " " + fc.GetBits(bcl));
}
if (fc.expandBCL)
{
lines += LINEHEIGHT;
var rng = (double)Math.Abs(fc.Max - fc.Min);
string str = ((fc.GetBits(bcl) == 0) ? 0 : (rng / Math.Pow(2, fc.Bits - fc.GetBits(bcl)))).ToString("####0.#####");
EditorGUI.LabelField(new Rect(left, lines, fldWdth4th, LINEHEIGHT), str, (GUIStyle)"ProjectBrowserGridLabel");
}
EditorGUI.indentLevel = holdindent;
}
public override void OnGUI(Rect r, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(r, label, property);
base.OnGUI(r, property, label);
// Hackjob way to get the target
fc = (FloatCrusher)DrawerUtils.GetParent(property.FindPropertyRelative("_min"));
height = CalculateHeight(fc);
this.r = r;
savedIndentLevel = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
line = r.yMin;
colortex =
(fc.axis == Axis.X) ? SolidTextures.red2D :
(fc.axis == Axis.Y) ? SolidTextures.green2D :
(fc.axis == Axis.Z) ? SolidTextures.blue2D :
SolidTextures.gray2D;
SolidTextures.DrawTexture(new Rect(r.xMin - 1, line - 1, r.width + 2, height + 2), SolidTextures.lowcontrast2D);
SolidTextures.DrawTexture(new Rect(r.xMin, line, r.width, height), colortex);
line += SPACING;
DrawHeader(r, label);
if (fc.enabled)
{
line += HHEIGHT + SPACING;
DrawResolution();
DrawCodecSettings(property);
line += LINEHEIGHT + 3;
DrawFooter();
}
EditorGUI.indentLevel = savedIndentLevel;
EditorGUI.EndProperty();
}
public override void OnGUI(Rect r, SerializedProperty property, GUIContent label)
{
gc.text = label.text;
gc.tooltip = label.tooltip;
EditorGUI.BeginProperty(r, label, property);
base.OnGUI(r, property, label);
//property.serializedObject.ApplyModifiedProperties();
//property.serializedObject.Update();
//haschanged = true;
// Hacky way to get the real object
TransformCrusher target = (TransformCrusher)DrawerUtils.GetParent(property.FindPropertyRelative("posCrusher"));
float currentline = r.yMin;
SerializedProperty pos = property.FindPropertyRelative("posCrusher");
SerializedProperty rot = property.FindPropertyRelative("rotCrusher");
SerializedProperty scl = property.FindPropertyRelative("sclCrusher");
SerializedProperty isExpanded = property.FindPropertyRelative("isExpanded");
float ph = EditorGUI.GetPropertyHeight(pos);
float rh = EditorGUI.GetPropertyHeight(rot);
float sh = EditorGUI.GetPropertyHeight(scl);
/// Header
bool _isExpanded = EditorGUI.Foldout(new Rect(r.xMin, currentline, r.width, TITL_HGHT), isExpanded.boolValue, "");
if (isExpanded.boolValue != _isExpanded)
{
isExpanded.boolValue = _isExpanded;
property.serializedObject.ApplyModifiedProperties();
}
EditorGUI.LabelField(new Rect(r.xMin, currentline, r.width, TITL_HGHT), gc); // property.displayName /*new GUIContent("Transform Crusher " + label)*//*, (GUIStyle)"BoldLabel"*/);
int totalbits = target.TallyBits();
int frag0bits = Mathf.Clamp(totalbits, 0, 64);
int frag1bits = Mathf.Clamp(totalbits - 64, 0, 64);
int frag2bits = Mathf.Clamp(totalbits - 128, 0, 64);
int frag3bits = Mathf.Clamp(totalbits - 192, 0, 64);
string bitstr = frag0bits.ToString();
if (frag1bits > 0)
{
bitstr += "|" + frag1bits;
}
if (frag2bits > 0)
{
bitstr += "|" + frag2bits;
}
if (frag3bits > 0)
{
bitstr += "|" + frag3bits;
}
bitstr = bitstr + " bits";
EditorGUI.LabelField(new Rect(paddedleft, currentline, paddedwidth, 16), bitstr, miniLabelRight);
if (isExpanded.boolValue)
{
Rect ir = r; // EditorGUI.IndentedRect(r);;
ir.yMin = ir.yMin + HEADR_HGHT + 2;
ir.xMin -= BOUNDING_PADDING;
ir.xMax += BOUNDING_PADDING;
ir.yMax -= 6;
currentline += BOUNDING_PADDING;
//EditorGUI.LabelField(ir, GUIContent.none, /*(GUIStyle)"RectangleToolVBar");// */(GUIStyle)"HelpBox");
ir = EditorGUI.IndentedRect(ir);
//ir.xMin += 1; ir.xMax -= 1;
//ir.yMin += 1; ir.yMax -= 1;
SolidTextures.DrawTexture(ir, SolidTextures.darken202D);
/// TRS Element Boxes
currentline += TITL_HGHT;
//float leftConnectorY = currentline;
DrawSet(r, currentline, ph, pos);
currentline += ph + SET_PAD;
DrawSet(r, currentline, rh, rot);
currentline += rh + SET_PAD;
DrawSet(r, currentline, sh, scl);
currentline += sh /*+ SET_PAD*/;
/// Connecting line between TRS Elements
//SolidTextures.DrawTexture(new Rect(4, leftConnectorY + 4, 4, currentline - leftConnectorY), SolidTextures.lowcontrast2D);
//EditorGUI.LabelField(new Rect(0, leftConnectorY + 4, 4, currentline - leftConnectorY - 12), GUIContent.none, (GUIStyle)"MiniSliderVertical");
}
EditorGUI.EndProperty();
}
public override void OnGUI(Rect r, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(r, label, property);
base.OnGUI(r, property, label);
property.serializedObject.Update();
target = (QuatCrusher)DrawerUtils.GetParent(property.FindPropertyRelative("bits"));
MonoBehaviour component = (MonoBehaviour)property.serializedObject.targetObject;
if (target.transform == null)
{
target.transform = component.transform;
}
line = r.yMin;
float standalonesheight = target.isStandalone ? (SPACING + LINEHEIGHT) * 2 : 0;
float boxheight = SPACING + HHEIGHT + SPACING + LINEHEIGHT + standalonesheight + SPACING;
SolidTextures.DrawTexture(new Rect(r.xMin - 1, line - 1, r.width + 2, boxheight + 2), SolidTextures.lowcontrast2D);
SolidTextures.DrawTexture(new Rect(r.xMin, line, r.width, boxheight), SolidTextures.gray2D);
line += SPACING;
DrawHeader(new Rect(r));
line += HHEIGHT + SPACING;
CompressLevel clvl = (CompressLevel)EditorGUI.EnumPopup(new Rect(paddedleft, line, labelwidth - PADDING, LINEHEIGHT), GUIContent.none, target.CompressLevel);
if (!QC_ISPRO)
{
// In case we went from pro to free... quietly set this back to non-custom.
if (target.CompressLevel == CompressLevel.SetBits)
{
target.Bits = (int)target.CompressLevel; // CompressLevel = CompressLevel.uint32Med;
}
else if (clvl == CompressLevel.SetBits)
{
ProFeatureDialog("");
target.CompressLevel = (CompressLevel)target.Bits;
}
else
{
target.CompressLevel = clvl;
}
}
else if (clvl != target.CompressLevel)
{
target.CompressLevel = clvl;
}
var bitssp = property.FindPropertyRelative("bits");
GUI.enabled = (QC_ISPRO);
EditorGUI.PropertyField(new Rect(fieldleft, line, fieldwidth, LINEHEIGHT), bitssp, GUIContent.none);
GUI.enabled = true;
if (QC_ISPRO && bitssp.intValue != target.Bits)
{
target.CompressLevel = CompressLevel.SetBits;
}
if (target.isStandalone)
{
line += LINEHEIGHT + SPACING;
EditorGUI.PropertyField(new Rect(paddedleft, line, paddedwidth, LINEHEIGHT), property.FindPropertyRelative("transform"));
line += LINEHEIGHT + SPACING;
EditorGUI.PropertyField(new Rect(paddedleft, line, paddedwidth, LINEHEIGHT), property.FindPropertyRelative("local"));
}
property.serializedObject.ApplyModifiedProperties();
EditorGUI.EndProperty();
}
public override void OnGUI(Rect r, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(r, label, property);
haschanged = false;
p = property;
base.OnGUI(r, property, label);
bool isWrappedInElementCrusher = DrawerUtils.GetParent(property) is ElementCrusher;
bool disableRange = (label.tooltip != null && label.tooltip.Contains("DISABLE_RANGE"));
gc_fc.text = label.text;
gc_fc.tooltip = (disableRange) ? null : label.tooltip;
holdindent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
int hash = fc.GetHashCode();
height = CalculateHeight(fc, hash);
this.r = r;
line = r.yMin;
colortex =
(fc.axis == Axis.X) ? SolidTextures.red2D :
(fc.axis == Axis.Y) ? SolidTextures.green2D :
(fc.axis == Axis.Z) ? SolidTextures.blue2D :
SolidTextures.gray2D;
if (!isWrappedInElementCrusher)
{
Rect outline = ir;
outline.xMin--;
outline.yMin--;
outline.xMax++;
outline.yMax++;
SolidTextures.DrawTexture(outline, SolidTextures.lowcontrast2D);
}
SolidTextures.DrawTexture(ir, colortex);
//SolidTextures.DrawTexture(new Rect(ir.xMin, line, ir.width, height), colortex);
//SolidTextures.DrawTexture(new Rect(ir.xMin + 1, ir.yMin + 1, ir.width - 2, ir.height - 2), colortex);
line++;
line += SPACING;
fc.expanded = DrawHeader(r, gc_fc, fc.expanded);
line += PADDING + HEADR_HGHT;
if (fc.Enabled && fc.expanded)
{
bool noSettings = (fc.BitsDeterminedBy == BitsDeterminedBy.HalfFloat || fc.BitsDeterminedBy == BitsDeterminedBy.Uncompressed || fc.BitsDeterminedBy == BitsDeterminedBy.Disabled);
DrawCompressionMethod();
EditorGUI.BeginDisabledGroup(disableRange);
if (!noSettings && !(fc.TRSType == TRSType.Normal))
{
DrawCodecSettings(property);
}
EditorGUI.EndDisabledGroup();
if (!noSettings)
{
DrawAccurateCenter();
}
if (!noSettings && fc.showBCL)
{
DrawBCL();
}
if (!noSettings)
{
DrawActualValues();
}
}
if (haschanged)
{
EditorUtility.SetDirty(property.serializedObject.targetObject);
}
EditorGUI.indentLevel = holdindent;
EditorGUI.EndProperty();
}
public override void OnGUI(Rect r, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(r, label, property);
haschanged = false;
base.OnGUI(r, property, label);
holdindent = EditorGUI.indentLevel;
property.serializedObject.ApplyModifiedProperties();
property.serializedObject.Update();
target = (QuatCrusher)DrawerUtils.GetParent(property.FindPropertyRelative("bits"));
line = r.yMin;
//float standalonesheight = target.isStandalone ? (SPACING + LINEHEIGHT) * 2 : 0;
//float boxheight = SPACING + HEADR_HGHT + SPACING + LINEHEIGHT + standalonesheight + SPACING;
SolidTextures.DrawTexture(ir, SolidTextures.gray2D);
//SolidTextures.DrawTexture(new Rect(ir.xMin - 1, line - 1, r.width + 2, boxheight + 2), SolidTextures.lowcontrast2D);
//SolidTextures.DrawTexture(new Rect(ir.xMin, line, r.width, boxheight), SolidTextures.gray2D);
line += SPACING;
DrawHeader(new Rect(r));
line += HEADR_HGHT + SPACING + SPACING;
EditorGUI.indentLevel = 0;
CompressLevel clvl = (CompressLevel)EditorGUI.EnumPopup(new Rect(ir.xMin + PADDING, line, labelwidth - PADDING, LINEHEIGHT), GUIContent.none, target.CompressLevel);
EditorGUI.indentLevel = holdindent;
if (!QC_ISPRO)
{
// In case we went from pro to free... quietly set this back to non-custom.
if (target.CompressLevel == CompressLevel.SetBits)
{
if (target.Bits != (int)target.CompressLevel)
{
haschanged = true;
target.Enabled = true;
target.Bits = (int)target.CompressLevel; // CompressLevel = CompressLevel.uint32Med;
}
}
else if (clvl == CompressLevel.SetBits)
{
ProFeatureDialog("");
if (target.CompressLevel != (CompressLevel)target.Bits)
{
haschanged = true;
target.CompressLevel = (CompressLevel)target.Bits;
}
}
else
{
if (target.CompressLevel != clvl)
{
target.Enabled = true;
haschanged = true;
target.CompressLevel = clvl;
}
}
}
else if (clvl != target.CompressLevel)
{
haschanged = true;
target.CompressLevel = clvl;
}
//var bitssp = property.FindPropertyRelative("bits");
GUI.enabled = (QC_ISPRO);
int newbits = EditorGUI.IntSlider(new Rect(fieldleft, line, fieldwidth, LINEHEIGHT), GUIContent.none, target.Bits, 16, 64);
//bool bitschanged = EditorGUI.PropertyField(new Rect(fieldleft, line, fieldwidth, LINEHEIGHT), bitssp, GUIContent.none);
GUI.enabled = true;
if (QC_ISPRO && newbits != target.Bits)
{
//if (target.CompressLevel != CompressLevel.SetBits)
//{
haschanged = true;
target.Bits = newbits;
//target.CompressLevel = CompressLevel.SetBits;
//}
property.serializedObject.Update();
}
if (target.isStandalone)
{
line += LINEHEIGHT + SPACING;
EditorGUI.PropertyField(new Rect(paddedleft, line, paddedwidth, LINEHEIGHT), property.FindPropertyRelative("transform"));
line += LINEHEIGHT + SPACING;
EditorGUI.PropertyField(new Rect(paddedleft, line, paddedwidth, LINEHEIGHT), property.FindPropertyRelative("local"));
}
property.serializedObject.ApplyModifiedProperties();
if (haschanged)
{
EditorUtility.SetDirty(property.serializedObject.targetObject);
//AssetDatabase.SaveAssets();
}
EditorGUI.EndProperty();
}
public override void OnGUI(Rect r, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(r, label, property);
base.OnGUI(r, property, label);
// Hacky way to get the real object
ElementCrusher target = (ElementCrusher)DrawerUtils.GetParent(property.FindPropertyRelative("xcrusher"));
SerializedProperty uniformAxes = property.FindPropertyRelative("uniformAxes");
SerializedProperty x = property.FindPropertyRelative("xcrusher");
SerializedProperty y = property.FindPropertyRelative("ycrusher");
SerializedProperty z = property.FindPropertyRelative("zcrusher");
SerializedProperty u = property.FindPropertyRelative("ucrusher");
SerializedProperty q = property.FindPropertyRelative("qcrusher");
float xh = EditorGUI.GetPropertyHeight(x);
float yh = EditorGUI.GetPropertyHeight(y);
float zh = EditorGUI.GetPropertyHeight(z);
float wh = EditorGUI.GetPropertyHeight(u);
float qh = EditorGUI.GetPropertyHeight(q);
bool isQuatCrush = target.TRSType == TRSType.Quaternion;
bool isUniformScale = target.TRSType == TRSType.Scale && target.uniformAxes != 0;
float boxesheight =
isQuatCrush ? qh :
isUniformScale ? wh :
xh + yh + zh;
float currentline = r.yMin + TOP_PAD;
GUI.Box(new Rect(r.xMin - 1, currentline - 1, r.width + 2, TITL_HGHT + boxesheight + 2), GUIContent.none, (GUIStyle)"flow shader node 0 on");
SolidTextures.DrawTexture(new Rect(r.xMin - 1, currentline - 1, r.width + 2, 16 + 2), SolidTextures.lowcontrast2D);
SolidTextures.DrawTexture(new Rect(r.xMin, currentline, r.width, 16 + SPACING), SolidTextures.contrastgray2D);
if (target.enableTRSTypeSelector)
{
target.TRSType = (TRSType)EditorGUI.EnumPopup(new Rect(r.xMin, currentline + 1, 78, LINEHEIGHT), target.TRSType);
}
else if (target.TRSType == TRSType.Quaternion || target.TRSType == TRSType.Euler)
{
target.TRSType = (TRSType)EditorGUI.EnumPopup(new Rect(r.xMin, currentline + 1, 78, LINEHEIGHT), (RotationType)target.TRSType);
}
else
{
GUIContent title = new GUIContent(System.Enum.GetName(typeof(TRSType), target.TRSType)); // + " Crshr");
EditorGUI.LabelField(new Rect(paddedleft, currentline, r.width, LINEHEIGHT), title, (GUIStyle)"MiniBoldLabel");
}
int localtoggleleft = 80;
target.local = GUI.Toggle(new Rect(paddedright - localtoggleleft, currentline + 1, 20, LINEHEIGHT), target.local, GUIContent.none, (GUIStyle)"OL Toggle");
EditorGUI.LabelField(new Rect(paddedright - localtoggleleft + 14, currentline, 80, LINEHEIGHT), new GUIContent("Lcl"), (GUIStyle)"MiniLabel");
EditorGUI.LabelField(new Rect(paddedleft, currentline, paddedwidth, 16), target.TallyBits() + " Bits", FloatCrusherDrawer.miniLabelRight);
// Scale Uniform Enum
if (target.TRSType == TRSType.Scale)
{
target.uniformAxes =
(ElementCrusher.UniformAxes)EditorGUI.EnumPopup(new Rect(paddedright - 78 - 84, currentline + 1, 78, 16), GUIContent.none, target.uniformAxes);
}
currentline += TITL_HGHT;
if (target.TRSType == TRSType.Scale && uniformAxes.enumValueIndex != 0)
{
//SolidTextures.DrawTexture(new Rect(r.xMin - 3, currentline - 1, r.width + 6, wh + 2), SolidTextures.black2D);
EditorGUI.PropertyField(new Rect(r.xMin, currentline, r.width, wh), u);
}
else if (target.TRSType == TRSType.Quaternion)
{
EditorGUI.PropertyField(new Rect(r.xMin, currentline, r.width, wh), q);
}
else
{
//SolidTextures.DrawTexture(new Rect(r.xMin - 3, currentline - 1, r.width + 6, xh + yh +zh + 2), SolidTextures.black2D);
EditorGUI.PropertyField(new Rect(r.xMin, currentline, r.width, xh), x);
currentline += xh;
EditorGUI.PropertyField(new Rect(r.xMin, currentline, r.width, yh), y);
currentline += yh;
EditorGUI.PropertyField(new Rect(r.xMin, currentline, r.width, zh), z);
}
EditorGUI.EndProperty();
}