void OnEnable()
{
if (skeletonRenderer == null)
{
return;
}
if (block == null)
{
block = new MaterialPropertyBlock();
}
mainMeshRenderer = skeletonRenderer.GetComponent <MeshRenderer>();
skeletonRenderer.GenerateMeshOverride -= HandleRender;
skeletonRenderer.GenerateMeshOverride += HandleRender;
if (copyMeshRendererFlags)
{
bool useLightProbes = mainMeshRenderer.useLightProbes;
bool receiveShadows = mainMeshRenderer.receiveShadows;
for (int i = 0; i < partsRenderers.Count; i++)
{
var currentRenderer = partsRenderers[i];
if (currentRenderer == null)
{
continue; // skip null items.
}
var mr = currentRenderer.MeshRenderer;
mr.useLightProbes = useLightProbes;
mr.receiveShadows = receiveShadows;
}
}
}
public static void EditorAssignSpriteMaskMaterials(SkeletonRenderer skeleton)
{
var maskMaterials = skeleton.maskMaterials;
var maskInteraction = skeleton.maskInteraction;
var meshRenderer = skeleton.GetComponent <MeshRenderer>();
if (maskMaterials.materialsMaskDisabled.Length > 0 && maskMaterials.materialsMaskDisabled[0] != null &&
maskInteraction == SpriteMaskInteraction.None)
{
meshRenderer.materials = maskMaterials.materialsMaskDisabled;
}
else if (maskInteraction == SpriteMaskInteraction.VisibleInsideMask)
{
if (maskMaterials.materialsInsideMask.Length == 0 || maskMaterials.materialsInsideMask[0] == null)
{
EditorInitSpriteMaskMaterialsInsideMask(skeleton);
}
meshRenderer.materials = maskMaterials.materialsInsideMask;
}
else if (maskInteraction == SpriteMaskInteraction.VisibleOutsideMask)
{
if (maskMaterials.materialsOutsideMask.Length == 0 || maskMaterials.materialsOutsideMask[0] == null)
{
EditorInitSpriteMaskMaterialsOutsideMask(skeleton);
}
meshRenderer.materials = maskMaterials.materialsOutsideMask;
}
}
private static bool EditorConfirmDisabledMaskMaterialsInit(SkeletonRenderer skeleton)
{
var maskMaterials = skeleton.maskMaterials;
if (maskMaterials.materialsMaskDisabled.Length > 0 && maskMaterials.materialsMaskDisabled[0] != null)
{
return(true);
}
var meshRenderer = skeleton.GetComponent <MeshRenderer>();
Material[] currentMaterials = meshRenderer.sharedMaterials;
if (currentMaterials.Length == 0 || currentMaterials[0] == null)
{
Debug.LogWarning("No materials found assigned at " + skeleton.name);
return(false);
}
// We have to be sure that there has not been a recompilation or similar events that led to
// inside- or outside-mask materials being assigned to meshRenderer.sharedMaterials.
string firstMaterialPath = UnityEditor.AssetDatabase.GetAssetPath(currentMaterials[0]);
if (firstMaterialPath.Contains(MATERIAL_FILENAME_SUFFIX_INSIDE_MASK) ||
firstMaterialPath.Contains(MATERIAL_FILENAME_SUFFIX_OUTSIDE_MASK))
{
maskMaterials.materialsMaskDisabled = new Material[currentMaterials.Length];
for (int i = 0; i < currentMaterials.Length; ++i)
{
string path = UnityEditor.AssetDatabase.GetAssetPath(currentMaterials[i]);
string correctPath = null;
if (path.Contains(MATERIAL_FILENAME_SUFFIX_INSIDE_MASK))
{
correctPath = path.Replace(MATERIAL_FILENAME_SUFFIX_INSIDE_MASK, "");
}
else if (path.Contains(MATERIAL_FILENAME_SUFFIX_OUTSIDE_MASK))
{
correctPath = path.Replace(MATERIAL_FILENAME_SUFFIX_OUTSIDE_MASK, "");
}
if (correctPath != null)
{
Material material = UnityEditor.AssetDatabase.LoadAssetAtPath <Material>(correctPath);
if (material == null)
{
Debug.LogWarning("No original ignore-mask material found for path " + correctPath);
}
maskMaterials.materialsMaskDisabled[i] = material;
}
}
}
else
{
maskMaterials.materialsMaskDisabled = currentMaterials;
}
return(true);
}
void OnEnable()
{
if (skeletonRenderer == null)
{
return;
}
if (copiedBlock == null)
{
copiedBlock = new MaterialPropertyBlock();
}
mainMeshRenderer = skeletonRenderer.GetComponent <MeshRenderer>();
#if SPINE_OPTIONAL_RENDEROVERRIDE
skeletonRenderer.GenerateMeshOverride -= HandleRender;
skeletonRenderer.GenerateMeshOverride += HandleRender;
#endif
#if UNITY_5_4_OR_NEWER
if (copyMeshRendererFlags)
{
var lightProbeUsage = mainMeshRenderer.lightProbeUsage;
bool receiveShadows = mainMeshRenderer.receiveShadows;
for (int i = 0; i < partsRenderers.Count; i++)
{
var currentRenderer = partsRenderers[i];
if (currentRenderer == null)
{
continue; // skip null items.
}
var mr = currentRenderer.MeshRenderer;
mr.lightProbeUsage = lightProbeUsage;
mr.receiveShadows = receiveShadows;
}
}
#else
if (copyMeshRendererFlags)
{
var useLightProbes = mainMeshRenderer.useLightProbes;
bool receiveShadows = mainMeshRenderer.receiveShadows;
for (int i = 0; i < partsRenderers.Count; i++)
{
var currentRenderer = partsRenderers[i];
if (currentRenderer == null)
{
continue; // skip null items.
}
var mr = currentRenderer.MeshRenderer;
mr.useLightProbes = useLightProbes;
mr.receiveShadows = receiveShadows;
}
}
#endif
}
void OnEnable()
{
if (skeletonRenderer == null)
{
return;
}
if (copiedBlock == null)
{
copiedBlock = new MaterialPropertyBlock();
}
mainMeshRenderer = skeletonRenderer.GetComponent <MeshRenderer>();
#if SPINE_OPTIONAL_RENDEROVERRIDE
skeletonRenderer.GenerateMeshOverride -= HandleRender;
skeletonRenderer.GenerateMeshOverride += HandleRender;
#endif
if (copyMeshRendererFlags)
{
var lightProbeUsage = mainMeshRenderer.lightProbeUsage;
bool receiveShadows = mainMeshRenderer.receiveShadows;
var reflectionProbeUsage = mainMeshRenderer.reflectionProbeUsage;
var shadowCastingMode = mainMeshRenderer.shadowCastingMode;
var motionVectorGenerationMode = mainMeshRenderer.motionVectorGenerationMode;
var probeAnchor = mainMeshRenderer.probeAnchor;
for (int i = 0; i < partsRenderers.Count; i++)
{
var currentRenderer = partsRenderers[i];
if (currentRenderer == null)
{
continue; // skip null items.
}
var mr = currentRenderer.MeshRenderer;
mr.lightProbeUsage = lightProbeUsage;
mr.receiveShadows = receiveShadows;
mr.reflectionProbeUsage = reflectionProbeUsage;
mr.shadowCastingMode = shadowCastingMode;
mr.motionVectorGenerationMode = motionVectorGenerationMode;
mr.probeAnchor = probeAnchor;
}
}
}
private void OnEnable()
{
if (skeletonRenderer == null)
{
return;
}
if (copiedBlock == null)
{
copiedBlock = new MaterialPropertyBlock();
}
mainMeshRenderer = skeletonRenderer.GetComponent <MeshRenderer>();
skeletonRenderer.GenerateMeshOverride -= HandleRender;
skeletonRenderer.GenerateMeshOverride += HandleRender;
if (!copyMeshRendererFlags)
{
return;
}
LightProbeUsage lightProbeUsage = mainMeshRenderer.lightProbeUsage;
bool receiveShadows = mainMeshRenderer.receiveShadows;
ReflectionProbeUsage reflectionProbeUsage = mainMeshRenderer.reflectionProbeUsage;
ShadowCastingMode shadowCastingMode = mainMeshRenderer.shadowCastingMode;
MotionVectorGenerationMode motionVectorGenerationMode = mainMeshRenderer.motionVectorGenerationMode;
Transform probeAnchor = mainMeshRenderer.probeAnchor;
for (int i = 0; i < partsRenderers.Count; i++)
{
SkeletonPartsRenderer skeletonPartsRenderer = partsRenderers[i];
if (!(skeletonPartsRenderer == null))
{
MeshRenderer meshRenderer = skeletonPartsRenderer.MeshRenderer;
meshRenderer.lightProbeUsage = lightProbeUsage;
meshRenderer.receiveShadows = receiveShadows;
meshRenderer.reflectionProbeUsage = reflectionProbeUsage;
meshRenderer.shadowCastingMode = shadowCastingMode;
meshRenderer.motionVectorGenerationMode = motionVectorGenerationMode;
meshRenderer.probeAnchor = probeAnchor;
}
}
}
protected virtual void DrawInspectorGUI()
{
// JOHN: todo: support multiediting.
SkeletonRenderer component = (SkeletonRenderer)target;
using (new EditorGUILayout.HorizontalScope()) {
EditorGUILayout.PropertyField(skeletonDataAsset);
const string ReloadButtonLabel = "Reload";
float reloadWidth = GUI.skin.label.CalcSize(new GUIContent(ReloadButtonLabel)).x + 20;
if (GUILayout.Button(ReloadButtonLabel, GUILayout.Width(reloadWidth)))
{
if (component.skeletonDataAsset != null)
{
foreach (AtlasAsset aa in component.skeletonDataAsset.atlasAssets)
{
if (aa != null)
{
aa.Reset();
}
}
component.skeletonDataAsset.Reset();
}
component.Initialize(true);
}
}
if (!component.valid)
{
component.Initialize(true);
component.LateUpdate();
if (!component.valid)
{
return;
}
}
#if NO_PREFAB_MESH
if (meshFilter == null)
{
meshFilter = component.GetComponent <MeshFilter>();
}
if (isInspectingPrefab)
{
meshFilter.sharedMesh = null;
}
#endif
// Initial skin name.
{
string[] skins = new string[component.skeleton.Data.Skins.Count];
int skinIndex = 0;
for (int i = 0; i < skins.Length; i++)
{
string skinNameString = component.skeleton.Data.Skins.Items[i].Name;
skins[i] = skinNameString;
if (skinNameString == initialSkinName.stringValue)
{
skinIndex = i;
}
}
skinIndex = EditorGUILayout.Popup("Initial Skin", skinIndex, skins);
initialSkinName.stringValue = skins[skinIndex];
}
EditorGUILayout.Space();
// Sorting Layers
SpineInspectorUtility.SortingPropertyFields(sortingProperties, applyModifiedProperties: true);
// More Render Options...
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox)) {
EditorGUI.indentLevel++;
advancedFoldout = EditorGUILayout.Foldout(advancedFoldout, "Advanced");
if (advancedFoldout)
{
EditorGUI.indentLevel++;
SeparatorsField(separatorSlotNames);
EditorGUILayout.PropertyField(meshes,
new GUIContent("Render MeshAttachments", "Disable to optimize rendering for skeletons that don't use Mesh Attachments"));
EditorGUILayout.PropertyField(immutableTriangles,
new GUIContent("Immutable Triangles", "Enable to optimize rendering for skeletons that never change attachment visbility"));
EditorGUILayout.Space();
const float MinZSpacing = -0.1f;
const float MaxZSpacing = 0f;
EditorGUILayout.Slider(zSpacing, MinZSpacing, MaxZSpacing);
// Optional fields. May be disabled in SkeletonRenderer.
if (normals != null)
{
EditorGUILayout.PropertyField(normals, new GUIContent("Add Normals"));
}
if (tangents != null)
{
EditorGUILayout.PropertyField(tangents, new GUIContent("Solve Tangents"));
}
if (frontFacing != null)
{
EditorGUILayout.PropertyField(frontFacing);
}
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
}
protected virtual void DrawInspectorGUI()
{
SkeletonRenderer component = (SkeletonRenderer)target;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PropertyField(skeletonDataAsset);
float reloadWidth = GUI.skin.label.CalcSize(new GUIContent("Reload")).x + 20;
if (GUILayout.Button("Reload", GUILayout.Width(reloadWidth)))
{
if (component.skeletonDataAsset != null)
{
foreach (AtlasAsset aa in component.skeletonDataAsset.atlasAssets)
{
if (aa != null)
{
aa.Reset();
}
}
component.skeletonDataAsset.Reset();
}
component.Initialize(true);
}
EditorGUILayout.EndHorizontal();
if (!component.valid)
{
component.Initialize(true);
component.LateUpdate();
if (!component.valid)
{
return;
}
}
// Initial skin name.
{
String[] skins = new String[component.skeleton.Data.Skins.Count];
int skinIndex = 0;
for (int i = 0; i < skins.Length; i++)
{
String name = component.skeleton.Data.Skins.Items[i].Name;
skins[i] = name;
if (name == initialSkinName.stringValue)
{
skinIndex = i;
}
}
skinIndex = EditorGUILayout.Popup("Initial Skin", skinIndex, skins);
initialSkinName.stringValue = skins[skinIndex];
}
EditorGUILayout.Space();
// Sorting Layers
{
var renderer = component.GetComponent <Renderer>();
if (renderer != null)
{
EditorGUI.BeginChangeCheck();
if (EditorGUILayoutSortingLayerField != null && sortingLayerIDProperty != null)
{
EditorGUILayoutSortingLayerField.Invoke(null, new object[] { new GUIContent("Sorting Layer"), sortingLayerIDProperty, EditorStyles.popup });
}
else
{
renderer.sortingLayerID = EditorGUILayout.IntField("Sorting Layer ID", renderer.sortingLayerID);
}
renderer.sortingOrder = EditorGUILayout.IntField("Order in Layer", renderer.sortingOrder);
if (EditorGUI.EndChangeCheck())
{
rendererSerializedObject.ApplyModifiedProperties();
EditorUtility.SetDirty(renderer);
}
}
}
// More Render Options...
{
advancedFoldout = EditorGUILayout.Foldout(advancedFoldout, "Advanced");
if (advancedFoldout)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(submeshSeparators, true);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(meshes,
new GUIContent("Render Mesh Attachments", "Disable to optimize rendering for skeletons that don't use Mesh Attachments"));
EditorGUILayout.PropertyField(immutableTriangles,
new GUIContent("Immutable Triangles", "Enable to optimize rendering for skeletons that never change attachment visbility"));
EditorGUILayout.Space();
const float MinZSpacing = -0.1f;
const float MaxZSpacing = 0f;
EditorGUILayout.Slider(zSpacing, MinZSpacing, MaxZSpacing);
EditorGUILayout.PropertyField(normals);
EditorGUILayout.PropertyField(tangents);
EditorGUILayout.PropertyField(front);
EditorGUILayout.Separator();
EditorGUI.indentLevel--;
}
}
}
