public override void OnInspectorGUI()
{
ShadowVolume source = (ShadowVolume)target;
source.ShadowMesh = (Mesh)EditorGUILayout.ObjectField(new GUIContent("Shadow Mesh", shadowMeshTooltip), source.ShadowMesh, typeof(Mesh), false);
source.IsSimple = EditorGUILayout.Toggle(new GUIContent("Is Simple", isSimpleTooltip), source.IsSimple);
source.Layer = EditorGUILayout.LayerField(new GUIContent("Layer", layerTooltip), source.Layer);
if (GUI.changed)
{
EditorUtility.SetDirty(target);
}
}
protected void SetupGameObject(Transform transform)
{
// Destroy existing shadow game objects before performing recursion
foreach (Transform child in transform)
{
if (child.name.Contains("Shadow"))
{
DestroyImmediate(child.gameObject);
}
}
// Recursively setup (non-shadow game object) children first
if (setupChildren)
{
foreach (Transform child in transform)
{
SetupGameObject(child);
}
}
// Add shadow game object
if (!transform.name.Contains("Shadow"))
{
// Examine current game object
MeshFilter meshFilter = transform.GetComponent <MeshFilter>();
SkinnedMeshRenderer skinnedMeshRenderer = transform.GetComponent <SkinnedMeshRenderer>();
if (meshFilter != null && meshFilter.sharedMesh != null)
{
// Add shadow volume component
ShadowVolume shadowVolume = transform.gameObject.GetComponent <ShadowVolume>();
if (shadowVolume == null)
{
shadowVolume = transform.gameObject.AddComponent <ShadowVolume>();
}
shadowVolume.IsSimple = isSimple;
shadowVolume.Layer = layer;
if (createShadowMeshes)
{
Mesh shadowMesh = ShadowAssetCreator.CreateAsset(meshFilter.sharedMesh, boundsMargin);
shadowVolume.ShadowMesh = shadowMesh;
}
}
else if (skinnedMeshRenderer != null && skinnedMeshRenderer.sharedMesh != null)
{
// Create skinned shadow game object
GameObject shadowGameObject = new GameObject("Skinned Shadow");
// Set Transform
shadowGameObject.transform.parent = transform;
shadowGameObject.transform.localPosition = Vector3.zero;
shadowGameObject.transform.localRotation = Quaternion.identity;
shadowGameObject.transform.localScale = Vector3.one;
// Set SkinnedMeshRenderer
SkinnedMeshRenderer shadowRenderer = shadowGameObject.AddComponent <SkinnedMeshRenderer>();
if (createShadowMeshes)
{
Mesh shadowMesh = ShadowAssetCreator.CreateAsset(skinnedMeshRenderer.sharedMesh, boundsMargin);
if (shadowMesh != null)
{
shadowRenderer.bones = skinnedMeshRenderer.bones;
shadowRenderer.sharedMesh = shadowMesh;
}
}
// Set SkinnedShadowVolume
SkinnedShadowVolume shadowVolume = shadowGameObject.AddComponent <SkinnedShadowVolume>();
shadowVolume.IsSimple = isSimple;
shadowVolume.gameObject.layer = layer;
}
}
}
public void Start()
{
ShadowVolumeRenderer shadowVolumeRenderer = ShadowVolumeRenderer.Instance;
if (shadowVolumeRenderer == null)
{
return;
}
ShadowVolumeBackend backend = shadowVolumeRenderer.Backend;
ShadowVolume component = GetComponent <ShadowVolume>();
GameObject shadow = new GameObject("Shadow");
shadow.layer = component.Layer;
shadow.transform.parent = gameObject.transform;
shadow.transform.localPosition = Vector3.zero;
shadow.transform.localRotation = Quaternion.identity;
shadow.AddComponent <MeshFilter>().sharedMesh = component.ShadowMesh;
Material[] materials = null;
if (backend == ShadowVolumeBackend.StencilBuffer)
{
if (component.IsSimple)
{
materials = new Material[] { component.stencilFrontBack };
}
else
{
materials = new Material[] { component.stencilBackFrontAlways, component.stencilFrontBack };
}
}
else if (backend == ShadowVolumeBackend.StencilBufferNoTwoSided)
{
if (component.IsSimple)
{
materials = new Material[] { component.stencilFront, component.stencilBack };
}
else
{
materials = new Material[] { component.stencilBackAlways, component.stencilFrontAlways, component.stencilFront, component.stencilBack };
}
}
else if (backend == ShadowVolumeBackend.AlphaChannel)
{
if (component.IsSimple)
{
materials = new Material[] { component.alphaFront, component.alphaBack };
}
else
{
materials = new Material[] { component.alphaBackAlways, component.alphaFrontAlways, component.alphaFront, component.alphaBack };
}
}
else if (backend == ShadowVolumeBackend.AlphaChannelNoBlendOp)
{
if (component.IsSimple)
{
materials = new Material[] { component.alphaFront, component.alphaBackNoBlendOp };
}
else
{
materials = new Material[] { component.alphaBackAlways, component.alphaFrontAlwaysNoBlendOp, component.alphaFront, component.alphaBackNoBlendOp };
}
}
shadow.AddComponent <MeshRenderer>().sharedMaterials = materials;
component.enabled = false;
}
