void OnSceneGUI()
{
ShadowTextureRenderer shadowRenderer = target as ShadowTextureRenderer;
if (shadowRenderer.shadowTexture == null || shadowRenderer.GetComponent <Projector>().material == null)
{
return;
}
if (m_lastPosition != shadowRenderer.transform.position || m_lastRotation != shadowRenderer.transform.rotation)
{
// This function call will have the following error on Unity 5.6.0:
// Rendering camera 'XXXX', but calling code does not set it up as current camera (current camera: 'Main Camera') UnityEngine.Camera:Render()
// But it seems like there are no way to avoid this error message.
shadowRenderer.ForceRenderTexture();
m_lastPosition = shadowRenderer.transform.position;
m_lastRotation = shadowRenderer.transform.rotation;
}
if (m_blitMaterial == null)
{
m_blitMaterial = FindMaterial("DynamicShadowProjector/Blit/Blit");
}
int mipLevel = shadowRenderer.mipLevel + 1;
int w = shadowRenderer.textureWidth;
int h = shadowRenderer.textureHeight;
for (int i = 1; i < mipLevel; ++i)
{
if ((w >> i) <= 4 || (h >> i) <= 4)
{
mipLevel = i;
break;
}
}
int displayWidth = 128;
float mipBias = Mathf.Log(displayWidth / w) / Mathf.Log(2.0f);
int displayHeight = h * displayWidth / w;
int marginSize = 4;
int windowWidth = mipLevel * (displayWidth + marginSize) + marginSize;
int windowHeight = displayHeight + 2 * GUI.skin.window.border.bottom + marginSize;
int windowPosX = Screen.width - windowWidth - 10;
int windowPosY = Screen.height - windowHeight - GUI.skin.window.border.top - 10;
GUI.WindowFunction func = id => {
if (Event.current.type.Equals(EventType.Repaint))
{
int x = marginSize;
int y = GUI.skin.window.border.top;
for (int i = 0; i < mipLevel; ++i)
{
m_blitMaterial.SetFloat("_MipLevel", i);
m_blitMaterial.SetFloat("_MipBias", mipBias + i);
Graphics.DrawTexture(new Rect(x, y, displayWidth, displayHeight), shadowRenderer.shadowTexture, m_blitMaterial);
x += displayWidth + marginSize;
}
}
};
GUI.Window(0, new Rect(windowPosX, windowPosY, windowWidth, windowHeight), func, "Shadow Texture");
}
void OnVisibilityChanged(bool isVisible)
{
#if UNITY_EDITOR
if (m_shadowRenderer == null)
{
m_shadowRenderer = GetComponent <ShadowTextureRenderer>();
}
if (m_commandBuffer == null)
{
CreateCommandBuffer();
UpdateCommandBuffer();
return;
}
if (m_isCommandBufferDirty)
{
UpdateCommandBuffer();
}
#endif
if (isVisible)
{
m_shadowRenderer.AddCommandBuffer(m_commandBuffer);
}
else
{
m_shadowRenderer.RemoveCommandBuffer(m_commandBuffer);
}
}
public override void SetupCullingParameters(ref ScriptableCullingParameters cullingParameters, ref CameraData cameraData)
{
ShadowTextureRenderer shadowTextureRenderer = cameraData.camera.GetComponent <ShadowTextureRenderer>();
if (shadowTextureRenderer == null)
{
#if UNITY_EDITOR
Debug.LogWarning("No ShadowTextureRenderer found.");
#endif
return;
}
shadowTextureRenderer.UpdateVisibilityAndPrepareRendering();
cullingParameters.cullingMask = 0;
if (shadowTextureRenderer.isProjectorVisible)
{
DrawSceneObject drawScene = cameraData.camera.GetComponent <DrawSceneObject>();
if (drawScene != null)
{
cullingParameters.cullingMask = (uint)drawScene.cullingMask.value;
}
DrawTargetObject drawTarget = shadowTextureRenderer.GetComponent <DrawTargetObject>();
if (drawTarget != null)
{
drawTarget.SendMessage("OnPreCull");
}
shadowTextureRenderer.ConfigureRenderTarget(m_renderShadowTexturePass, ref cameraData);
}
cullingParameters.cullingOptions = CullingOptions.None;
cullingParameters.shadowDistance = 0;
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
Camera camera = renderingData.cameraData.camera;
DynamicShadowProjectorRenderer.DynamicShadowProjectorComponents components = m_renderer.GetDynamicShadowProjectorComponents(renderingData.cameraData.camera);
ShadowTextureRenderer shadowTextureRenderer = components.shadowTextureRenderer;
if (shadowTextureRenderer == null || !shadowTextureRenderer.isProjectorVisible)
{
return;
}
DrawSceneObject drawScene = components.drawSceneObject;
if (drawScene != null)
{
if (m_overrideOpaqueMaterial == null)
{
m_overrideOpaqueMaterial = new Material(shadowTextureRenderer.m_opaqueShadowShaderForLWRP);
}
else if (m_overrideOpaqueMaterial.shader != shadowTextureRenderer.m_opaqueShadowShaderForLWRP)
{
m_overrideOpaqueMaterial.shader = shadowTextureRenderer.m_opaqueShadowShaderForLWRP;
}
if (m_overrideTransparentMaterial == null)
{
m_overrideTransparentMaterial = new Material(shadowTextureRenderer.m_transparentShadowShaderForLWRP);
}
else if (m_overrideTransparentMaterial.shader != shadowTextureRenderer.m_transparentShadowShaderForLWRP)
{
m_overrideTransparentMaterial.shader = shadowTextureRenderer.m_transparentShadowShaderForLWRP;
}
DrawingSettings drawingSettings = new DrawingSettings(m_shaderTagIds[0], new SortingSettings(camera));
for (int i = 1; i < m_shaderTagIds.Length; ++i)
{
drawingSettings.SetShaderPassName(i, m_shaderTagIds[i]);
}
// draw opaque objects
drawingSettings.overrideMaterial = m_overrideOpaqueMaterial;
drawingSettings.overrideMaterialPassIndex = 0;
drawingSettings.enableDynamicBatching = renderingData.supportsDynamicBatching;
drawingSettings.enableInstancing = true;
drawingSettings.perObjectData = PerObjectData.None;
FilteringSettings opaqueFilteringSettings = new FilteringSettings(new RenderQueueRange(RenderQueueRange.opaque.lowerBound, 2500), drawScene.cullingMask);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref opaqueFilteringSettings);
// draw transparent objects
drawingSettings.overrideMaterial = m_overrideTransparentMaterial;
FilteringSettings transparentFilteringSettings = new FilteringSettings(new RenderQueueRange(2500, RenderQueueRange.transparent.upperBound), drawScene.cullingMask);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref transparentFilteringSettings);
}
DrawTargetObject drawTarget = components.drawTargetObject;
if (drawTarget != null)
{
context.ExecuteCommandBuffer(drawTarget.commandBuffer);
}
shadowTextureRenderer.ExecutePostRenderProcess(context);
}
// message handlers
void Awake()
{
m_shadowRenderer = GetComponent <ShadowTextureRenderer>();
if (m_target != null)
{
m_localTargetPosition = transform.InverseTransformPoint(m_target.position);
}
CreateCommandBuffer();
}
public override void Setup(ScriptableRenderContext context, ref RenderingData renderingData)
{
ShadowTextureRenderer shadowTextureRenderer = renderingData.cameraData.camera.GetComponent <ShadowTextureRenderer>();
if (shadowTextureRenderer != null && shadowTextureRenderer.enabled && shadowTextureRenderer.isProjectorVisible)
{
EnqueuePass(m_renderShadowTexturePass);
}
}
private void OnEnable()
{
gesture = this.GetComponent <TransformGesture>();
transformer = this.GetComponent <Transformer>();
rb = this.GetComponent <Rigidbody2D>();
shadowTexRend = projector.GetComponent <ShadowTextureRenderer>();
transformer.enabled = false;
rb.isKinematic = false;
gesture.TransformStarted += transformStartedHandler;
gesture.TransformCompleted += transformCompletedHandler;
}
public override void Setup(ScriptableRenderContext context, ref RenderingData renderingData)
{
renderingData.cameraData.isStereoEnabled = false;
renderingData.cameraData.isSceneViewCamera = false;
DynamicShadowProjectorComponents components = GetDynamicShadowProjectorComponents(renderingData.cameraData.camera);
ShadowTextureRenderer shadowTextureRenderer = components.shadowTextureRenderer;
if (shadowTextureRenderer != null && shadowTextureRenderer.isActiveAndEnabled && shadowTextureRenderer.isProjectorVisible)
{
EnqueuePass(m_renderShadowTexturePass);
}
}
void OnSceneGUI()
{
ShadowTextureRenderer shadowRenderer = target as ShadowTextureRenderer;
if (shadowRenderer.shadowTexture == null || shadowRenderer.GetComponent <Projector>().material == null)
{
return;
}
if (m_blitMaterial == null)
{
m_blitMaterial = FindMaterial("DynamicShadowProjector/Blit/Blit");
}
int mipLevel = shadowRenderer.mipLevel + 1;
int w = shadowRenderer.textureWidth;
int h = shadowRenderer.textureHeight;
for (int i = 1; i < mipLevel; ++i)
{
if ((w >> i) <= 4 || (h >> i) <= 4)
{
mipLevel = i;
break;
}
}
int displayWidth = 128;
float mipBias = Mathf.Log(displayWidth / w) / Mathf.Log(2.0f);
int displayHeight = h * displayWidth / w;
int marginSize = 4;
int windowWidth = mipLevel * (displayWidth + marginSize) + marginSize;
int windowHeight = displayHeight + 2 * GUI.skin.window.border.bottom + marginSize;
int windowPosX = Screen.width - windowWidth - 10;
int windowPosY = Screen.height - windowHeight - GUI.skin.window.border.top - 10;
GUI.WindowFunction func = id => {
if (Event.current.type.Equals(EventType.Repaint))
{
int x = marginSize;
int y = GUI.skin.window.border.top;
for (int i = 0; i < mipLevel; ++i)
{
m_blitMaterial.SetFloat("_MipLevel", i);
m_blitMaterial.SetFloat("_MipBias", mipBias + i);
Graphics.DrawTexture(new Rect(x, y, displayWidth, displayHeight), shadowRenderer.shadowTexture, m_blitMaterial);
x += displayWidth + marginSize;
}
}
};
GUI.Window(0, new Rect(windowPosX, windowPosY, windowWidth, windowHeight), func, "Shadow Texture");
}
void RestoreShadowTextureRenderer()
{
if (m_testFallback)
{
m_testFallback = false;
MipmappedShadowFallback fallback = target as MipmappedShadowFallback;
ShadowTextureRenderer shadowRenderer = fallback.GetComponent <ShadowTextureRenderer>();
shadowRenderer.hideFlags &= ~HideFlags.NotEditable;
shadowRenderer.mipLevel = m_mipLevel;
shadowRenderer.blurLevel = m_blurLevel;
shadowRenderer.blurSize = m_blurSize;
shadowRenderer.multiSampling = m_multiSampling;
shadowRenderer.superSampling = m_superSampling;
shadowRenderer.textureWidth = m_textureWidth;
shadowRenderer.textureHeight = m_textureHeight;
m_projector.material = m_projectorMaterial;
m_projector.material.shader = m_projectorShader;
m_testFallback = false;
}
}
void TestFallback()
{
if (!m_testFallback)
{
MipmappedShadowFallback fallback = target as MipmappedShadowFallback;
ShadowTextureRenderer shadowRenderer = fallback.GetComponent <ShadowTextureRenderer>();
m_mipLevel = shadowRenderer.mipLevel;
m_blurLevel = shadowRenderer.blurLevel;
m_blurSize = shadowRenderer.blurSize;
m_multiSampling = shadowRenderer.multiSampling;
m_superSampling = shadowRenderer.superSampling;
m_textureWidth = shadowRenderer.textureWidth;
m_textureHeight = shadowRenderer.textureHeight;
m_projectorShader = m_projector.material.shader;
m_projectorMaterial = m_projector.material;
m_testFallback = true;
fallback.ApplyFallback(m_projector);
shadowRenderer.hideFlags |= HideFlags.NotEditable;
}
}
void OnEnable()
{
ShadowTextureRenderer shadowRenderer = target as ShadowTextureRenderer;
bool modified = false;
if (shadowRenderer.blurShader == null)
{
shadowRenderer.blurShader = FindMaterial("DynamicShadowProjector/Blit/Blur");
ClearMaterialProperties(shadowRenderer.blurShader);
modified = true;
}
if (shadowRenderer.downsampleShader == null)
{
shadowRenderer.downsampleShader = FindMaterial("DynamicShadowProjector/Blit/Downsample");
ClearMaterialProperties(shadowRenderer.downsampleShader);
modified = true;
}
if (shadowRenderer.copyMipmapShader == null)
{
shadowRenderer.copyMipmapShader = FindMaterial("DynamicShadowProjector/Blit/CopyMipmap");
ClearMaterialProperties(shadowRenderer.copyMipmapShader);
modified = true;
}
if (shadowRenderer.eraseShadowShader == null)
{
shadowRenderer.eraseShadowShader = FindMaterial("DynamicShadowProjector/Blit/EraseShadow");
ClearMaterialProperties(shadowRenderer.eraseShadowShader);
modified = true;
}
Projector projector = shadowRenderer.GetComponent <Projector>();
if (projector.material != null)
{
RemoveUnusedMaterialProperties(projector.material);
}
if (modified)
{
EditorUtility.SetDirty(shadowRenderer);
serializedObject.Update();
}
}
public void ApplyFallback(Projector projector)
{
if (m_fallbackShaderOrMaterial is Shader)
{
projector.material.shader = m_fallbackShaderOrMaterial as Shader;
}
else if (m_fallbackShaderOrMaterial is Material)
{
projector.material = m_fallbackShaderOrMaterial as Material;
}
ShadowTextureRenderer shadowRenderer = projector.GetComponent <ShadowTextureRenderer>();
shadowRenderer.blurLevel = m_blurLevel;
shadowRenderer.blurSize = m_blurSize;
shadowRenderer.mipLevel = 0;
if (m_modifyTextureSize)
{
shadowRenderer.textureWidth = m_textureWidth;
shadowRenderer.textureHeight = m_textureHeight;
shadowRenderer.multiSampling = m_multiSampling;
shadowRenderer.superSampling = m_superSampling;
}
}
public override void OnInspectorGUI()
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Online Document");
if (GUILayout.Button("<color=blue>http://nyahoon.com/products/dynamic-shadow-projector/shadow-texture-renderer-component</color>", richTextStyle))
{
Application.OpenURL("http://nyahoon.com/products/dynamic-shadow-projector/shadow-texture-renderer-component");
}
EditorGUILayout.EndHorizontal();
bool isGUIEnabled = GUI.enabled;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_shadowColor"));
EditorGUILayout.IntPopup(serializedObject.FindProperty("m_textureWidth"), s_textureSizeDisplayOption, s_textureSizeOption);
EditorGUILayout.IntPopup(serializedObject.FindProperty("m_textureHeight"), s_textureSizeDisplayOption, s_textureSizeOption);
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_multiSampling"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_superSampling"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("changeScale"));
SerializedProperty prop = serializedObject.FindProperty("m_blurLevel");
EditorGUILayout.IntPopup(prop, s_blurLevelDisplayOption, s_blurLevelOption);
++EditorGUI.indentLevel;
GUI.enabled = isGUIEnabled && 0 < prop.intValue;
ShadowTextureRenderer shadowRenderer = target as ShadowTextureRenderer;
EditorGUILayout.Slider(serializedObject.FindProperty("m_blurSize"), 1.0f, shadowRenderer.blurFilter == ShadowTextureRenderer.BlurFilter.Uniform ? 6.0f : 4.0f);
GUI.enabled = isGUIEnabled;
--EditorGUI.indentLevel;
prop = serializedObject.FindProperty("m_mipLevel");
EditorGUILayout.PropertyField(prop);
++EditorGUI.indentLevel;
GUI.enabled = isGUIEnabled && 0 < prop.intValue;
SerializedProperty fastBlur = serializedObject.FindProperty("m_singlePassMipmapBlur");
EditorGUILayout.PropertyField(fastBlur);
float maxBlurSize;
if (fastBlur.boolValue)
{
maxBlurSize = 1.0f;
}
else
{
maxBlurSize = shadowRenderer.blurFilter == ShadowTextureRenderer.BlurFilter.Uniform ? 3.0f : 2.0f;
}
EditorGUILayout.Slider(serializedObject.FindProperty("m_mipmapBlurSize"), 0.0f, maxBlurSize);
if (shadowRenderer.GetComponent <MipmappedShadowFallback>() == null)
{
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Add Fallback Component"))
{
Undo.AddComponent <MipmappedShadowFallback>(shadowRenderer.gameObject);
}
EditorGUILayout.EndHorizontal();
GUI.enabled = isGUIEnabled;
--EditorGUI.indentLevel;
}
else if (prop.intValue == 0)
{
GUI.enabled = isGUIEnabled;
--EditorGUI.indentLevel;
EditorGUILayout.BeginHorizontal();
GUILayout.TextArea("<color=red>Still has Mipmap Fallback Component!</color>", richTextStyle);
if (GUILayout.Button("Remove the Component"))
{
Undo.DestroyObjectImmediate(shadowRenderer.GetComponent <MipmappedShadowFallback>());
}
EditorGUILayout.EndHorizontal();
}
else
{
GUI.enabled = isGUIEnabled;
--EditorGUI.indentLevel;
}
prop = serializedObject.FindProperty("m_testViewClip");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Don't update while out of view");
prop.boolValue = EditorGUILayout.Toggle(prop.boolValue);
EditorGUILayout.EndHorizontal();
++EditorGUI.indentLevel;
GUI.enabled = isGUIEnabled && prop.boolValue;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_camerasForViewClipTest"), true);
GUI.enabled = isGUIEnabled;
--EditorGUI.indentLevel;
s_showAdvancedOptions = GUILayout.Toggle(s_showAdvancedOptions, "Show Advanced Options");
if (s_showAdvancedOptions)
{
++EditorGUI.indentLevel;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_blurFilter"));
prop = serializedObject.FindProperty("m_mipmapFalloff");
EditorGUILayout.PropertyField(prop);
if (prop.intValue == (int)ShadowTextureRenderer.MipmapFalloff.Custom)
{
prop = serializedObject.FindProperty("m_customMipmapFalloff");
if (shadowRenderer.customMipmapFalloff != null && shadowRenderer.customMipmapFalloff.Length != prop.arraySize)
{
serializedObject.Update();
prop = serializedObject.FindProperty("m_customMipmapFalloff");
}
EditorGUILayout.PropertyField(prop, true);
}
float near = EditorGUILayout.FloatField("Near Clip Plane", shadowRenderer.cameraNearClipPlane);
if (m_cameraSerializedObject == null)
{
m_camera = shadowRenderer.GetComponent <Camera>();
m_cameraSerializedObject = new SerializedObject(shadowRenderer.GetComponent <Camera>());
}
if (near != shadowRenderer.cameraNearClipPlane)
{
Undo.RecordObject(m_camera, "Inspector");
shadowRenderer.cameraNearClipPlane = near;
}
bool bShowCamera = (m_camera.hideFlags & HideFlags.HideInInspector) == 0;
bool newValue = EditorGUILayout.Toggle("Show Camera in Inspector", bShowCamera);
if (bShowCamera != newValue)
{
if (newValue)
{
m_camera.hideFlags &= ~HideFlags.HideInInspector;
}
else
{
m_camera.hideFlags |= HideFlags.HideInInspector;
}
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_blurShader"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_downsampleShader"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_copyMipmapShader"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_preferredTextureFormats"), true);
--EditorGUI.indentLevel;
}
serializedObject.ApplyModifiedProperties();
}
public RenderShadowTexturePass(ShadowTextureRenderer renderer)
{
renderPassEvent = RenderPassEvent.BeforeRendering;
m_renderer = renderer;
}
void Awake()
{
if (instance != null)
{
GameObject.Destroy(this.gameObject);
return;
}
selfTrans = transform;
m_camera = ArtWrap.mainCamera;
m_shadowTextureRenderer = GetComponent <ShadowTextureRenderer>();
if (m_shadowTextureRenderer != null)
{
m_shadowTextureRenderer.camerasForViewClipTest = new Camera[] { m_camera }
}
;
//添加默认的，因为要根据默认的设置参数
m_defaultDrawObject = GetComponent <DrawTargetObject>();
m_defaultDrawObject.enabled = false;
m_drawObjects = new List <DrawTargetObject>();
m_drawObjects.Add(m_defaultDrawObject);
//设置阴影跟随平行光
SetLight();
instance = this;
}
void OnDestroy()
{
instance = null;
}
void Update()
{
if (m_followTrans != null)
{
//设置坐标偏移
m_posOff = -this.transform.forward * 20;
selfTrans.parent.position = m_followTrans.position + m_posOff;
}
for (int i = m_drawObjects.Count - 1; i >= 0; i--)
{
if (m_drawObjects[i].target == null)
{
m_drawObjects.RemoveAt(i);
return;
}
}
}
void SetLight()
{
//设置默认值
selfTrans.localPosition = Vector3.zero;
selfTrans.localRotation = Quaternion.identity;
selfTrans.parent.rotation = Quaternion.Euler(DEFAULTANGLE, 0, 0);
//根据场景平行光，设置阴影的方向
GameObject MapScene = GameObject.Find("MapScene");
if (MapScene == null)
{
return;
}
Light[] lights = MapScene.GetComponentsInChildren <Light>();
int lightCount = 0;
for (int i = 0; i < lights.Length; ++i)
{
if (lights[i].gameObject.name.Equals(LIGHTNAME))
{
lightCount++;
m_sceneLight = lights[i].gameObject;
}
}
if (lightCount > 1)
{
Debuger.LogError("场景中有多个角色平行光");
}
//设置灯光方向
if (m_sceneLight != null)
{
m_sceneLight.AddComponentIfNoExist <TargetDirection>();
}
}
void ShowObject(Transform trans, bool isShow)
{
#if USE_DRAW_POOL
//关闭影子
for (int i = 0; i < m_drawObjects.Count; i++)
{
if (m_drawObjects[i].target == m_role.m_go.transform)
{
m_drawObjects[i].enabled = isShow;
}
}
#else
if (isShow)
{
AddDrawTarget(trans);
}
else
{
RemoveDrawTarget(trans);
}
#endif
}
void AddDrawTarget(Transform trans)
{
//如果已经添加过了，就不要再添加了
for (int i = 0; i < m_drawObjects.Count; i++)
{
if (m_drawObjects[i].target == trans)
{
m_drawObjects[i].enabled = true;
m_drawObjects[i].target = trans;
Debuger.LogError("重复添加阴影");
return;
}
}
DrawTargetObject drawTarget = null;
#if USE_DRAW_POOL
for (int i = 0; i < m_drawObjects.Count; i++)
{
if (s_instce.m_drawObjects[i].target == null)
{
drawTarget = m_drawObjects[i];
m_drawObjects[i].enabled = true;
break;
}
}
#endif
//重新创建一个新的
if (drawTarget == null)
{
drawTarget = gameObject.AddComponent <DrawTargetObject>();
drawTarget.followTarget = false;
drawTarget.shadowShader = m_defaultDrawObject.shadowShader;
drawTarget.replacementShaders = m_defaultDrawObject.replacementShaders;
drawTarget.layerMask = m_defaultDrawObject.layerMask;
m_drawObjects.Add(drawTarget);
}
drawTarget.target = trans;
}
void SetFollow(Transform trans)
{
m_followTrans = trans;
}
void RemoveDrawTarget(Transform trans)
{
for (int i = m_drawObjects.Count - 1; i >= 0; i--)
{
if (m_drawObjects[i].target == trans)
{
#if USE_DRAW_POOL
s_instance.m_drawObjects[i].target = null;
s_instance.m_drawObjects[i].enabled = false;
s_instance.m_drawObjects[i].Clear();
#else
Object.Destroy(m_drawObjects[i]);
m_drawObjects.RemoveAt(i);
#endif
}
}
}
}
