public static GameObject CreateGameObject(Transform parent, GameObject prefabObj)
{
GameObject newChild = (GameObject)NcSafeTool.SafeInstantiate(prefabObj);
if (parent != null)
{ // 원본 transform을 유지 시켜주자
NcTransformTool trans = new NcTransformTool(newChild.transform);
newChild.transform.parent = parent;
trans.CopyToLocalTransform(newChild.transform);
}
return newChild;
}
public static GameObject CreateGameObject(Transform parent, string name)
{
GameObject newChild = new GameObject(name);
if (parent != null)
{ // 원본 transform을 유지 시켜주자
NcTransformTool trans = new NcTransformTool(newChild.transform);
newChild.transform.parent = parent;
trans.CopyToLocalTransform(newChild.transform);
}
return newChild;
}
// Property -------------------------------------------------------------------------
public override bool ShowPopupWindow(Object selObj)
{
if ((selObj is Transform))
{
m_PopupPosition = FXMakerLayout.GetGUIMousePosition();
m_SelectedTransform = selObj as Transform;
if (m_CopyTransform == null)
m_CopyTransform = new NcTransformTool();
SaveTransform();
enabled = true;
} else {
enabled = false;
}
m_nWorldLocalSelIndex = EditorPrefs.GetInt ("FxmPopup_Transform.m_nWorldLocalSelIndex" , m_nWorldLocalSelIndex);
InitFloatInput();
return enabled;
}
public ParticleSystem.Particle[] ShurikenScaleParticle(ParticleSystem.Particle[] parts, int nCount, bool bScale, bool bPosUpdate)
{
float num;
if (bScale)
{
num = NcTransformTool.GetTransformScaleMeanValue(base.get_transform());
}
else
{
num = 1f / NcTransformTool.GetTransformScaleMeanValue(base.get_transform());
}
for (int i = 0; i < nCount; i++)
{
if (this.m_bWorldSpace)
{
if (bPosUpdate)
{
Vector3 vector = this.m_OldPos - base.get_transform().get_position();
if (bScale)
{
int expr_66_cp_1 = i;
parts[expr_66_cp_1].set_position(parts[expr_66_cp_1].get_position() - vector * (1f - 1f / num));
}
}
int expr_90_cp_1 = i;
parts[expr_90_cp_1].set_position(parts[expr_90_cp_1].get_position() - base.get_transform().get_position());
int expr_B2_cp_1 = i;
parts[expr_B2_cp_1].set_position(parts[expr_B2_cp_1].get_position() * num);
int expr_CA_cp_1 = i;
parts[expr_CA_cp_1].set_position(parts[expr_CA_cp_1].get_position() + base.get_transform().get_position());
}
else
{
int expr_F1_cp_1 = i;
parts[expr_F1_cp_1].set_position(parts[expr_F1_cp_1].get_position() * num);
}
int expr_109_cp_1 = i;
parts[expr_109_cp_1].set_startSize(parts[expr_109_cp_1].get_startSize() * num);
}
return(parts);
}
void RenderParticleWire(Vector3 pos, float fSize, float fRot)
{
if (System.Single.IsNaN(pos.x))
{
return;
}
fSize *= 0.5f;
// m_meshRenderer.sharedMaterial.color = m_backgroundColor;
InitLineMaterial();
m_lineMaterial.SetPass(0);
NcTransformTool.InitWorldTransform(m_CalcChildTrans);
m_CalcChildTrans.LookAt(Camera.main.transform, Camera.main.transform.up);
m_CalcChildTrans.position = pos;
GL.PushMatrix();
GL.MultMatrix(m_CalcChildTrans.localToWorldMatrix);
GL.Begin(GL.LINES);
GL.Color((m_bRoot ? FXMakerOption.inst.m_ColorRootWireframe : FXMakerOption.inst.m_ColorChildWireframe));
{
GL.Vertex(new Vector3(-fSize, -fSize, 0));
GL.Vertex(new Vector3(+fSize, -fSize, 0));
GL.Vertex(new Vector3(+fSize, -fSize, 0));
GL.Vertex(new Vector3(+fSize, +fSize, 0));
GL.Vertex(new Vector3(+fSize, +fSize, 0));
GL.Vertex(new Vector3(-fSize, +fSize, 0));
GL.Vertex(new Vector3(-fSize, +fSize, 0));
GL.Vertex(new Vector3(-fSize, -fSize, 0));
GL.Vertex(new Vector3(-fSize, -fSize, 0));
GL.Vertex(new Vector3(+fSize, +fSize, 0));
}
GL.End();
GL.PopMatrix();
}
public Particle[] LegacyScaleParticle(Particle[] parts, bool bScale, bool bPosUpdate)
{
float fScale;
if (bScale)
{
fScale = NcTransformTool.GetTransformScaleMeanValue(transform);
}
else
{
fScale = 1 / NcTransformTool.GetTransformScaleMeanValue(transform);
}
for (int n = 0; n < parts.Length; n++)
{
if (IsMeshParticleEmitter() == false)
{
if (m_bWorldSpace)
{
if (bPosUpdate)
{
Vector3 move = (m_OldPos - transform.position);
if (bScale)
{
parts[n].position -= move * (1 - 1 / fScale);
}
}
parts[n].position -= transform.position;
parts[n].position *= fScale;
parts[n].position += transform.position;
}
else
{
parts[n].position *= fScale;
}
}
parts[n].angularVelocity *= fScale;
parts[n].velocity *= fScale;
parts[n].size *= fScale;
}
return(parts);
}
public ParticleSystem.Particle[] ShurikenScaleParticle(ParticleSystem.Particle[] parts, int nCount, bool bScale, bool bPosUpdate)
{
float num;
if (bScale)
{
num = NcTransformTool.GetTransformScaleMeanValue(base.transform);
}
else
{
num = 1f / NcTransformTool.GetTransformScaleMeanValue(base.transform);
}
for (int i = 0; i < nCount; i++)
{
if (this.m_bWorldSpace)
{
if (bPosUpdate)
{
Vector3 a = this.m_OldPos - base.transform.position;
if (bScale)
{
int expr_66_cp_1 = i;
parts[expr_66_cp_1].position = parts[expr_66_cp_1].position - a * (1f - 1f / num);
}
}
int expr_90_cp_1 = i;
parts[expr_90_cp_1].position = parts[expr_90_cp_1].position - base.transform.position;
int expr_B2_cp_1 = i;
parts[expr_B2_cp_1].position = parts[expr_B2_cp_1].position * num;
int expr_CA_cp_1 = i;
parts[expr_CA_cp_1].position = parts[expr_CA_cp_1].position + base.transform.position;
}
else
{
int expr_F1_cp_1 = i;
parts[expr_F1_cp_1].position = parts[expr_F1_cp_1].position * num;
}
int expr_109_cp_1 = i;
parts[expr_109_cp_1].size = parts[expr_109_cp_1].size * num;
}
return(parts);
}
public ParticleSystem.Particle[] ShurikenScaleParticle(ParticleSystem.Particle[] parts, int nCount, bool bScale, bool bPosUpdate)
{
float fScale;
if (bScale)
{
fScale = NcTransformTool.GetTransformScaleMeanValue(transform);
}
else
{
fScale = 1 / NcTransformTool.GetTransformScaleMeanValue(transform);
}
for (int n = 0; n < nCount; n++)
{
if (m_bWorldSpace)
{
if (bPosUpdate)
{
Vector3 move = (m_OldPos - transform.position);
if (bScale)
{
parts[n].position -= move * (1 - 1 / fScale);
}
}
parts[n].position -= transform.position;
parts[n].position *= fScale;
parts[n].position += transform.position;
}
else
{
parts[n].position *= fScale;
}
// parts[n].angularVelocity *= fScale;
#pragma warning disable CS0618 // Type or member is obsolete
parts[n].size *= fScale;
#pragma warning restore CS0618 // Type or member is obsolete
// parts[n].velocity *= fScale;
}
return(parts);
}
protected void ChangeParent(Transform newParent, Transform child, bool bKeepingLocalTransform, Transform addTransform)
{
NcTransformTool tool = null;
if (bKeepingLocalTransform)
{
tool = new NcTransformTool(child.transform);
if (addTransform != null)
{
tool.AddTransform(addTransform);
}
}
child.parent = newParent;
if (bKeepingLocalTransform)
{
tool.CopyToLocalTransform(child.transform);
}
if (bKeepingLocalTransform)
{
}
}
// Property -------------------------------------------------------------------------
public override bool ShowPopupWindow(Object selObj)
{
if ((selObj is Transform))
{
m_PopupPosition = FXMakerLayout.GetGUIMousePosition();
m_SelectedTransform = selObj as Transform;
if (m_CopyTransform == null)
{
m_CopyTransform = new NcTransformTool();
}
SaveTransform();
enabled = true;
}
else
{
enabled = false;
}
m_nWorldLocalSelIndex = EditorPrefs.GetInt("FxmPopup_Transform.m_nWorldLocalSelIndex", m_nWorldLocalSelIndex);
InitFloatInput();
return(enabled);
}
void SaveTransform()
{
if (m_SaveTrans == null)
{
m_SaveTrans = new NcTransformTool();
}
int nGroup = 3;
for (int n = 0; n < nGroup; n++)
{
TRANS_TYPE nTrans = (TRANS_TYPE)n;
if (m_nWorldLocalSelIndex == 0)
{
switch (nTrans)
{
case TRANS_TYPE.POSITION: m_SaveTrans.m_vecPos = m_SelectedTransform.position; break;
case TRANS_TYPE.ROTATION: m_SaveTrans.m_vecRotHint = m_SelectedTransform.eulerAngles; break;
case TRANS_TYPE.SCALE: m_SaveTrans.m_vecScale = m_SelectedTransform.lossyScale; break;
}
}
else
{
switch (nTrans)
{
case TRANS_TYPE.POSITION: m_SaveTrans.m_vecPos = m_SelectedTransform.localPosition; break;
case TRANS_TYPE.ROTATION: m_SaveTrans.m_vecRotHint = m_SelectedTransform.localEulerAngles; break;
case TRANS_TYPE.SCALE: m_SaveTrans.m_vecScale = m_SelectedTransform.localScale; break;
}
}
}
}
public float GetScaleMaxMeshNormalVelocity()
{
return(m_fLegacyMaxMeshNormalVelocity * (m_bScaleWithTransform ? NcTransformTool.GetTransformScaleMeanValue(transform) : 1));
}
// public void UpdateAnimation(float fElapsedRate, bool bResetStartTime)
// {
// UpdateAnimation(fElapsedRate);
// if (bResetStartTime)
// m_fStartTime = GetEngineTime();
// }
public void ResetPosition()
{
m_NcTansform = new NcTransformTool(transform);
}
public void CopyToTransform(Transform dst)
{
dst.set_position(this.m_vecPos);
dst.set_rotation(this.m_vecRot);
NcTransformTool.CopyLossyToLocalScale(this.m_vecScale, dst);
}
public static void CopyLossyToLocalScale(Vector3 srcLossyScale, Transform dst)
{
dst.set_localScale(NcTransformTool.GetUnitVector());
dst.set_localScale(new Vector3((dst.get_lossyScale().x != 0f) ? (srcLossyScale.x / dst.get_lossyScale().x) : srcLossyScale.x, (dst.get_lossyScale().y != 0f) ? (srcLossyScale.y / dst.get_lossyScale().y) : srcLossyScale.y, (dst.get_lossyScale().z != 0f) ? (srcLossyScale.z / dst.get_lossyScale().z) : srcLossyScale.z));
}
public static void InitWorldScale(Transform dst)
{
dst.set_localScale(NcTransformTool.GetUnitVector());
dst.set_localScale(new Vector3((dst.get_lossyScale().x != 0f) ? (1f / dst.get_lossyScale().x) : 1f, (dst.get_lossyScale().y != 0f) ? (1f / dst.get_lossyScale().y) : 1f, (dst.get_lossyScale().z != 0f) ? (1f / dst.get_lossyScale().z) : 1f));
}
// --------------------------------------------------------------------------
public void SetTransform(NcTransformTool val)
{
m_vecPos = val.m_vecPos;
m_vecRot = val.m_vecRot;
m_vecScale = val.m_vecScale;
}
// ------------------------------------------------------------------------
void Awake()
{
m_NcTansform = new NcTransformTool(transform);
// Debug.Log("NcCurveAnimation.Awake " + transform.parent.name);
}
public void ResetPosition()
{
this.m_NcTansform = new NcTransformTool(base.transform);
}
protected void ChangeParent(Transform newParent, Transform child, bool bKeepingLocalTransform, Transform addTransform)
{
// Keeping transform
NcTransformTool trans = null;
if (bKeepingLocalTransform)
{
trans = new NcTransformTool(child.transform);
if (addTransform != null)
trans.AddTransform(addTransform);
}
child.parent = newParent;
if (bKeepingLocalTransform)
trans.CopyToLocalTransform(child.transform);
// Update component
if (bKeepingLocalTransform)
{
// NcEffectBehaviour[] coms = gameObject.GetComponentsInChildren<NcEffectBehaviour>();
// foreach (NcEffectBehaviour com in coms)
// com.SendMessage("Update", SendMessageOptions.DontRequireReceiver);
NcBillboard[] ncBills = gameObject.GetComponentsInChildren<NcBillboard>();
foreach (NcBillboard ncb in ncBills)
ncb.UpdateBillboard();
}
}
List <Vector4> GetParticlePostions(bool bPosUpdate)
{
List <Vector4> listPartis = new List <Vector4>();
if (IsLegacy() || IsShuriken())
{
CreateTempObject();
if (IsShuriken())
{
float fScale = 1.0f;
ParticleSystem.Particle[] parts = new ParticleSystem.Particle[m_BaseTrans.GetComponent <ParticleSystem>().particleCount];
m_BaseTrans.GetComponent <ParticleSystem>().GetParticles(parts);
NcTransformTool.InitWorldTransform(m_CalcBaseTrans);
if (m_bWorldParticle)
{
NcParticleSystem ncPartScale = m_BaseTrans.GetComponent <NcParticleSystem>();
if (m_bScaledParticle)
{
ncPartScale.ShurikenScaleParticle(parts, parts.Length, true, bPosUpdate);
}
}
else
{
m_CalcBaseTrans.position = m_BaseTrans.position;
m_CalcBaseTrans.rotation = m_BaseTrans.rotation;
if (m_bScaledParticle)
{
NcTransformTool.CopyLossyToLocalScale(NcTransformTool.GetTransformScaleMeanVector(m_BaseTrans), m_CalcBaseTrans);
fScale = NcTransformTool.GetTransformScaleMeanValue(m_BaseTrans);
}
}
foreach (ParticleSystem.Particle part in parts)
{
Vector3 worldPos;
float fSize = part.size * fScale;
NcTransformTool.InitLocalTransform(m_CalcChildTrans);
m_CalcChildTrans.localPosition = part.position;
worldPos = m_CalcChildTrans.position;
listPartis.Add(new Vector4(worldPos.x, worldPos.y, worldPos.z, fSize));
}
}
else
{
float fScale = 1.0f;
Particle[] parts = m_BaseTrans.GetComponent <ParticleEmitter>().particles;
NcTransformTool.InitWorldTransform(m_CalcBaseTrans);
if (m_bWorldParticle)
{
// m_bLegacyRuntimeScale
NcParticleSystem ncPartScale = m_BaseTrans.GetComponent <NcParticleSystem>();
if (m_bScaledParticle)
{
ncPartScale.LegacyScaleParticle(parts, true, bPosUpdate);
}
}
else
{
m_CalcBaseTrans.position = m_BaseTrans.position;
m_CalcBaseTrans.rotation = m_BaseTrans.rotation;
// m_bLegacyRuntimeScale
NcParticleSystem ncPartScale = m_BaseTrans.GetComponent <NcParticleSystem>();
if (m_bScaledParticle && ncPartScale.IsMeshParticleEmitter() == false)
{
NcTransformTool.CopyLossyToLocalScale(NcTransformTool.GetTransformScaleMeanVector(m_BaseTrans), m_CalcBaseTrans);
fScale = NcTransformTool.GetTransformScaleMeanValue(m_BaseTrans);
}
else
{
fScale = NcTransformTool.GetTransformScaleMeanValue(m_BaseTrans);
}
}
foreach (Particle part in parts)
{
if (System.Single.IsNaN(part.position.x))
{
continue;
}
Vector3 worldPos;
// float fSize = part.size;
float fSize = part.size * fScale; // m_bLegacyRuntimeScale
NcTransformTool.InitLocalTransform(m_CalcChildTrans);
m_CalcChildTrans.localPosition = part.position;
worldPos = m_CalcChildTrans.position;
listPartis.Add(new Vector4(worldPos.x, worldPos.y, worldPos.z, fSize));
}
}
}
return(listPartis);
}
public void BackupTransform(Transform targetTrans)
{
m_Transform = targetTrans;
m_NcTansform = new NcTransformTool(m_Transform);
}
public void CopyToTransform(Transform dst)
{
dst.position = this.m_vecPos;
dst.rotation = this.m_vecRot;
NcTransformTool.CopyLossyToLocalScale(this.m_vecScale, dst);
}
public static void CopyLossyToLocalScale(Vector3 srcLossyScale, Transform dst)
{
dst.localScale = NcTransformTool.GetUnitVector();
dst.localScale = new Vector3((dst.lossyScale.x == 0f) ? srcLossyScale.x : (srcLossyScale.x / dst.lossyScale.x), (dst.lossyScale.y == 0f) ? srcLossyScale.y : (srcLossyScale.y / dst.lossyScale.y), (dst.lossyScale.z == 0f) ? srcLossyScale.z : (srcLossyScale.z / dst.lossyScale.z));
}
public static void InitWorldScale(Transform dst)
{
dst.localScale = NcTransformTool.GetUnitVector();
dst.localScale = new Vector3((dst.lossyScale.x == 0f) ? 1f : (1f / dst.lossyScale.x), (dst.lossyScale.y == 0f) ? 1f : (1f / dst.lossyScale.y), (dst.lossyScale.z == 0f) ? 1f : (1f / dst.lossyScale.z));
}
public static void InitWorldScale(Transform dst)
{
dst.localScale = NcTransformTool.GetUnitVector();
dst.localScale = new Vector3((dst.lossyScale.x != 0f) ? (1f / dst.lossyScale.x) : 1f, (dst.lossyScale.y != 0f) ? (1f / dst.lossyScale.y) : 1f, (dst.lossyScale.z != 0f) ? (1f / dst.lossyScale.z) : 1f);
}
void Update()
{
if (m_bStartDetach == false)
{
m_bStartDetach = true;
if (transform.parent != null)
{
m_ParentGameObject = transform.parent.gameObject;
m_ncDetachObject = NcDetachObject.Create(m_ParentGameObject, transform.gameObject);
}
// Detach Parent
GameObject parentObj = GetRootInstanceEffect();
if (m_bFollowParentTransform)
{
m_OriginalPos.SetLocalTransform(transform);
ChangeParent(parentObj.transform, transform, false, null);
m_OriginalPos.CopyToLocalTransform(transform);
} else {
ChangeParent(parentObj.transform, transform, false, null);
}
if (m_bParentHideToStartDestroy == false)
StartDestroy();
}
// Live time
if (0 < m_fStartDestroyTime)
{
if (0 < m_fSmoothDestroyTime)
{
if (m_bSmoothHide)
{
float fAlphaRate = 1 - ((GetEngineTime() - m_fStartDestroyTime) / m_fSmoothDestroyTime);
if (fAlphaRate < 0)
fAlphaRate = 0;
if (m_bMeshFilterOnlySmoothHide)
{
// Recursively
MeshFilter[] meshFilters = transform.GetComponentsInChildren<MeshFilter>(true);
Color color;
for (int n = 0; n < meshFilters.Length; n++)
{
Color[] colors = meshFilters[n].mesh.colors;
if (colors.Length == 0)
{
colors = new Color[meshFilters[n].mesh.vertices.Length];
for (int c = 0; c < colors.Length; c++)
colors[c] = Color.white;
}
for (int c = 0; c < colors.Length; c++)
{
color = colors[c];
color.a = Mathf.Min(color.a, fAlphaRate);
colors[c] = color;
}
meshFilters[n].mesh.colors = colors;
}
} else {
// Recursively
Renderer[] rens = transform.GetComponentsInChildren<Renderer>(true);
for (int n = 0; n < rens.Length; n++)
{
Renderer ren = rens[n];
string colName = GetMaterialColorName(ren.sharedMaterial);
if (colName != null)
{
Color col = ren.material.GetColor(colName);
col.a = Mathf.Min(col.a, fAlphaRate);
ren.material.SetColor(colName, col);
// AddRuntimeMaterial(ren.material);
}
}
}
}
if (m_fStartDestroyTime + m_fSmoothDestroyTime < GetEngineTime())
Object.Destroy(gameObject);
}
} else {
if (m_bParentHideToStartDestroy)
if (m_ParentGameObject == null || IsActive(m_ParentGameObject) == false)
StartDestroy();
}
// follow parent transform
if (m_bFollowParentTransform && m_ParentGameObject != null && m_ParentGameObject.transform != null)
{
NcTransformTool tmp = new NcTransformTool();
tmp.SetTransform(m_OriginalPos);
tmp.AddTransform(m_ParentGameObject.transform);
tmp.CopyToLocalTransform(transform);
}
}
private void Update()
{
if (!this.m_bStartDetach)
{
this.m_bStartDetach = true;
if (base.transform.parent != null)
{
this.m_ParentGameObject = base.transform.parent.gameObject;
NcDetachObject.Create(this.m_ParentGameObject, base.transform.gameObject);
}
GameObject rootInstanceEffect = NcEffectBehaviour.GetRootInstanceEffect();
if (this.m_bFollowParentTransform)
{
this.m_OriginalPos.SetLocalTransform(base.transform);
base.ChangeParent(rootInstanceEffect.transform, base.transform, false, null);
this.m_OriginalPos.CopyToLocalTransform(base.transform);
}
else
{
base.ChangeParent(rootInstanceEffect.transform, base.transform, false, null);
}
if (!this.m_bParentHideToStartDestroy)
{
this.StartDestroy();
}
}
if (0f < this.m_fStartDestroyTime)
{
if (0f < this.m_fSmoothDestroyTime)
{
if (this.m_bSmoothHide)
{
float num = 1f - (NcEffectBehaviour.GetEngineTime() - this.m_fStartDestroyTime) / this.m_fSmoothDestroyTime;
if (num < 0f)
{
num = 0f;
}
Renderer[] componentsInChildren = base.transform.GetComponentsInChildren <Renderer>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
Renderer renderer = componentsInChildren[i];
string materialColorName = NcEffectBehaviour.GetMaterialColorName(renderer.material);
if (materialColorName != null)
{
Color color = renderer.material.GetColor(materialColorName);
color.a = Mathf.Min(num, color.a);
renderer.material.SetColor(materialColorName, color);
}
}
}
if (this.m_fStartDestroyTime + this.m_fSmoothDestroyTime < NcEffectBehaviour.GetEngineTime())
{
DelegateProxy.GameDestory(base.gameObject);
}
}
}
else if (this.m_bParentHideToStartDestroy && (this.m_ParentGameObject == null || !NcEffectBehaviour.IsActive(this.m_ParentGameObject)))
{
this.StartDestroy();
}
if (this.m_bFollowParentTransform && this.m_ParentGameObject != null && this.m_ParentGameObject.transform != null)
{
NcTransformTool ncTransformTool = new NcTransformTool();
ncTransformTool.SetTransform(this.m_OriginalPos);
ncTransformTool.AddTransform(this.m_ParentGameObject.transform);
ncTransformTool.CopyToLocalTransform(base.transform);
}
}
void SaveTransform()
{
if (m_SaveTrans == null)
m_SaveTrans = new NcTransformTool();
int nGroup = 3;
for (int n = 0; n < nGroup; n++)
{
TRANS_TYPE nTrans = (TRANS_TYPE)n;
if (m_nWorldLocalSelIndex == 0)
{
switch (nTrans)
{
case TRANS_TYPE.POSITION: m_SaveTrans.m_vecPos = m_SelectedTransform.position; break;
case TRANS_TYPE.ROTATION: m_SaveTrans.m_vecRotHint= m_SelectedTransform.eulerAngles; break;
case TRANS_TYPE.SCALE: m_SaveTrans.m_vecScale = m_SelectedTransform.lossyScale; break;
}
} else {
switch (nTrans)
{
case TRANS_TYPE.POSITION: m_SaveTrans.m_vecPos = m_SelectedTransform.localPosition; break;
case TRANS_TYPE.ROTATION: m_SaveTrans.m_vecRotHint= m_SelectedTransform.localEulerAngles; break;
case TRANS_TYPE.SCALE: m_SaveTrans.m_vecScale = m_SelectedTransform.localScale; break;
}
}
}
}
private void Update()
{
if (!this.m_bStartDetach)
{
this.m_bStartDetach = true;
if (base.transform.parent != null)
{
this.m_ParentGameObject = base.transform.parent.gameObject;
this.m_ncDetachObject = NcDetachObject.Create(this.m_ParentGameObject, base.transform.gameObject);
}
GameObject rootInstanceEffect = NcEffectBehaviour.GetRootInstanceEffect();
if (this.m_bFollowParentTransform)
{
this.m_OriginalPos.SetLocalTransform(base.transform);
base.ChangeParent(rootInstanceEffect.transform, base.transform, false, null);
this.m_OriginalPos.CopyToLocalTransform(base.transform);
}
else
{
base.ChangeParent(rootInstanceEffect.transform, base.transform, false, null);
}
if (!this.m_bParentHideToStartDestroy)
{
this.StartDestroy();
}
}
if (0f < this.m_fStartDestroyTime)
{
if (0f < this.m_fSmoothDestroyTime)
{
if (this.m_bSmoothHide)
{
float num = 1f - (NcEffectBehaviour.GetEngineTime() - this.m_fStartDestroyTime) / this.m_fSmoothDestroyTime;
if (num < 0f)
{
num = 0f;
}
if (this.m_bMeshFilterOnlySmoothHide)
{
MeshFilter[] componentsInChildren = base.transform.GetComponentsInChildren <MeshFilter>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
Color[] array = componentsInChildren[i].mesh.colors;
if (array.Length == 0)
{
array = new Color[componentsInChildren[i].mesh.vertices.Length];
for (int j = 0; j < array.Length; j++)
{
array[j] = Color.white;
}
}
for (int k = 0; k < array.Length; k++)
{
Color color = array[k];
color.a = Mathf.Min(color.a, num);
array[k] = color;
}
componentsInChildren[i].mesh.colors = array;
}
}
else
{
Renderer[] componentsInChildren2 = base.transform.GetComponentsInChildren <Renderer>(true);
for (int l = 0; l < componentsInChildren2.Length; l++)
{
Renderer renderer = componentsInChildren2[l];
string materialColorName = NcEffectBehaviour.GetMaterialColorName(renderer.sharedMaterial);
if (materialColorName != null)
{
Color color2 = renderer.material.GetColor(materialColorName);
color2.a = Mathf.Min(color2.a, num);
renderer.material.SetColor(materialColorName, color2);
}
}
}
}
if (this.m_fStartDestroyTime + this.m_fSmoothDestroyTime < NcEffectBehaviour.GetEngineTime())
{
UnityEngine.Object.Destroy(base.gameObject);
}
}
}
else if (this.m_bParentHideToStartDestroy && (this.m_ParentGameObject == null || !NcEffectBehaviour.IsActive(this.m_ParentGameObject)))
{
this.StartDestroy();
}
if (this.m_bFollowParentTransform && this.m_ParentGameObject != null && this.m_ParentGameObject.transform != null)
{
NcTransformTool ncTransformTool = new NcTransformTool();
ncTransformTool.SetTransform(this.m_OriginalPos);
ncTransformTool.AddTransform(this.m_ParentGameObject.transform);
ncTransformTool.CopyToLocalTransform(base.transform);
}
}
public static GameObject CreateGameObject(Transform parent, GameObject prefabObj, Vector3 pos, Quaternion rot)
{
GameObject newChild;
if (NcSafeTool.IsSafe() == false)
return null;
newChild = (GameObject)NcSafeTool.SafeInstantiate(prefabObj, pos, rot);
if (parent != null)
{ // 원본 transform을 유지 시켜주자
NcTransformTool trans = new NcTransformTool(newChild.transform);
newChild.transform.parent = parent;
trans.CopyToLocalTransform(newChild.transform);
}
return newChild;
}
public void SetTransform(NcTransformTool val)
{
this.m_vecPos = val.m_vecPos;
this.m_vecRot = val.m_vecRot;
this.m_vecScale = val.m_vecScale;
}
void OnRenderObject()
{
// if (Camera.main == null || m_meshRenderer == null)
if (Camera.main == null)
{
return;
}
if (m_BaseTrans == null)
{
// OnDestroy ���� ������ wire
Destroy(gameObject);
return;
}
if (IsLegacy() || IsShuriken())
{
m_LastPparticlePos = GetParticlePostions(true);
}
if (m_bWireframe == false)
{
return;
}
if (IsLegacy() || IsShuriken())
{
foreach (Vector4 pos in m_LastPparticlePos)
{
RenderParticleWire(pos, pos.w, 0);
}
}
if (m_lines != null)
{
// m_meshRenderer.sharedMaterial.color = m_backgroundColor;
InitLineMaterial();
m_lineMaterial.SetPass(0);
Matrix4x4 matrix;
// if (IsShuriken())
if (IsLegacy() || IsShuriken()) // m_bLegacyRuntimeScale
{
NcTransformTool.InitWorldTransform(m_CalcBaseTrans);
m_CalcBaseTrans.position = m_BaseTrans.position;
m_CalcBaseTrans.rotation = m_BaseTrans.rotation;
if (m_bScaledParticle)
{
NcTransformTool.CopyLossyToLocalScale(NcTransformTool.GetTransformScaleMeanVector(m_BaseTrans), m_CalcBaseTrans);
}
matrix = m_CalcBaseTrans.localToWorldMatrix;
}
else
{
// model
matrix = m_BaseTrans.localToWorldMatrix;
}
GL.PushMatrix();
GL.MultMatrix(matrix);
GL.Begin(GL.LINES);
GL.Color((m_bRoot ? FXMakerOption.inst.m_ColorRootWireframe : FXMakerOption.inst.m_ColorChildWireframe));
for (int i = 0; i < m_lines.Length / 3; i++)
{
GL.Vertex(m_lines[i * 3]);
GL.Vertex(m_lines[i * 3 + 1]);
GL.Vertex(m_lines[i * 3 + 1]);
GL.Vertex(m_lines[i * 3 + 2]);
GL.Vertex(m_lines[i * 3 + 2]);
GL.Vertex(m_lines[i * 3]);
}
GL.End();
GL.PopMatrix();
}
}
public static Vector3 GetTransformScaleMeanVector(Transform srcTrans)
{
float transformScaleMeanValue = NcTransformTool.GetTransformScaleMeanValue(srcTrans);
return(new Vector3(transformScaleMeanValue, transformScaleMeanValue, transformScaleMeanValue));
}
void LegacySetParticle()
{
ParticleEmitter pe = m_pe;
ParticleAnimator pa = m_pa;
ParticleRenderer pr = m_pr;
if (pe == null || pr == null)
{
return;
}
if (m_bLegacyRuntimeScale)
{
Vector3 vecVelScale = Vector3.one * m_fStartSpeedRate;
float fVelScale = m_fStartSpeedRate;
pe.minSize *= m_fStartSizeRate;
pe.maxSize *= m_fStartSizeRate;
pe.minEnergy *= m_fStartLifeTimeRate;
pe.maxEnergy *= m_fStartLifeTimeRate;
pe.minEmission *= m_fStartEmissionRate;
pe.maxEmission *= m_fStartEmissionRate;
pe.worldVelocity = Vector3.Scale(pe.worldVelocity, vecVelScale);
pe.localVelocity = Vector3.Scale(pe.localVelocity, vecVelScale);
pe.rndVelocity = Vector3.Scale(pe.rndVelocity, vecVelScale);
pe.angularVelocity *= fVelScale;
pe.rndAngularVelocity *= fVelScale;
pe.emitterVelocityScale *= fVelScale;
// NgAssembly.LogFieldsPropertis(pe);
if (pa != null)
{
pa.rndForce = Vector3.Scale(pa.rndForce, vecVelScale);
pa.force = Vector3.Scale(pa.force, vecVelScale);
// pa.damping *= fScale;
}
// pr.velocityScale *= fVelScale;
pr.lengthScale *= m_fRenderLengthRate;
}
else
{
Vector3 vecVelScale = (m_bScaleWithTransform ? pe.transform.lossyScale : Vector3.one) * m_fStartSpeedRate;
float fVelScale = (m_bScaleWithTransform ? NcTransformTool.GetTransformScaleMeanValue(pe.transform) : 1) * m_fStartSpeedRate;
float fScale = (m_bScaleWithTransform ? NcTransformTool.GetTransformScaleMeanValue(pe.transform) : 1) * m_fStartSizeRate;
pe.minSize *= fScale;
pe.maxSize *= fScale;
pe.minEnergy *= m_fStartLifeTimeRate;
pe.maxEnergy *= m_fStartLifeTimeRate;
pe.minEmission *= m_fStartEmissionRate;
pe.maxEmission *= m_fStartEmissionRate;
pe.worldVelocity = Vector3.Scale(pe.worldVelocity, vecVelScale);
pe.localVelocity = Vector3.Scale(pe.localVelocity, vecVelScale);
pe.rndVelocity = Vector3.Scale(pe.rndVelocity, vecVelScale);
pe.angularVelocity *= fVelScale;
pe.rndAngularVelocity *= fVelScale;
pe.emitterVelocityScale *= fVelScale;
// NgAssembly.LogFieldsPropertis(pe);
if (pa != null)
{
pa.rndForce = Vector3.Scale(pa.rndForce, vecVelScale);
pa.force = Vector3.Scale(pa.force, vecVelScale);
// pa.damping *= fScale;
}
// pr.velocityScale *= fVelScale;
pr.lengthScale *= m_fRenderLengthRate;
}
}
public static void InitLocalTransform(Transform dst)
{
dst.set_localPosition(NcTransformTool.GetZeroVector());
dst.set_localRotation(NcTransformTool.GetIdenQuaternion());
dst.set_localScale(NcTransformTool.GetUnitVector());
}
// Property -------------------------------------------------------------------------
// Loop Function --------------------------------------------------------------------
// Control Function -----------------------------------------------------------------
public void BackupTransform(Transform targetTrans)
{
m_Transform = targetTrans;
m_NcTansform = new NcTransformTool(m_Transform);
}
public static void InitWorldTransform(Transform dst)
{
dst.set_position(NcTransformTool.GetZeroVector());
dst.set_rotation(NcTransformTool.GetIdenQuaternion());
NcTransformTool.InitWorldScale(dst);
}
void Update()
{
if (m_bStartDetach == false)
{
m_bStartDetach = true;
if (transform.parent != null)
{
m_ParentGameObject = transform.parent.gameObject;
m_ncDetachObject = NcDetachObject.Create(m_ParentGameObject, transform.gameObject);
}
// Detach Parent
GameObject parentObj = GetRootInstanceEffect();
if (m_bFollowParentTransform)
{
m_OriginalPos.SetLocalTransform(transform);
ChangeParent(parentObj.transform, transform, false, null);
m_OriginalPos.CopyToLocalTransform(transform);
}
else
{
ChangeParent(parentObj.transform, transform, false, null);
}
if (m_bParentHideToStartDestroy == false)
{
StartDestroy();
}
}
// Live time
if (0 < m_fStartDestroyTime)
{
if (0 < m_fSmoothDestroyTime)
{
if (m_bSmoothHide)
{
float fAlphaRate = 1 - ((GetEngineTime() - m_fStartDestroyTime) / m_fSmoothDestroyTime);
if (fAlphaRate < 0)
{
fAlphaRate = 0;
}
if (m_bMeshFilterOnlySmoothHide)
{
// Recursively
MeshFilter[] meshFilters = transform.GetComponentsInChildren <MeshFilter>(true);
Color color;
for (int n = 0; n < meshFilters.Length; n++)
{
Color[] colors = meshFilters[n].mesh.colors;
if (colors.Length == 0)
{
colors = new Color[meshFilters[n].mesh.vertices.Length];
for (int c = 0; c < colors.Length; c++)
{
colors[c] = Color.white;
}
}
for (int c = 0; c < colors.Length; c++)
{
color = colors[c];
color.a = Mathf.Min(color.a, fAlphaRate);
colors[c] = color;
}
meshFilters[n].mesh.colors = colors;
}
}
else
{
// Recursively
Renderer[] rens = transform.GetComponentsInChildren <Renderer>(true);
for (int n = 0; n < rens.Length; n++)
{
Renderer ren = rens[n];
string colName = GetMaterialColorName(ren.sharedMaterial);
if (colName != null)
{
Color col = ren.material.GetColor(colName);
col.a = Mathf.Min(col.a, fAlphaRate);
ren.material.SetColor(colName, col);
// AddRuntimeMaterial(ren.material);
}
}
}
}
if (m_fStartDestroyTime + m_fSmoothDestroyTime < GetEngineTime())
{
Object.Destroy(gameObject);
}
}
}
else
{
if (m_bParentHideToStartDestroy)
{
if (m_ParentGameObject == null || IsActive(m_ParentGameObject) == false)
{
StartDestroy();
}
}
}
// follow parent transform
if (m_bFollowParentTransform && m_ParentGameObject != null && m_ParentGameObject.transform != null)
{
NcTransformTool tmp = new NcTransformTool();
tmp.SetTransform(m_OriginalPos);
tmp.AddTransform(m_ParentGameObject.transform);
tmp.CopyToLocalTransform(transform);
}
}
// Loop Function --------------------------------------------------------------------
void Update()
{
if (m_bStartDetach == false)
{
m_bStartDetach = true;
if (transform.parent != null)
{
m_ParentGameObject = transform.parent.gameObject;
NcDetachObject.Create(m_ParentGameObject, transform.gameObject);
}
// Detach Parent
GameObject parentObj = GetRootInstanceEffect();
if (m_bFollowParentTransform)
{
m_OriginalPos.SetLocalTransform(transform);
ChangeParent(parentObj.transform, transform, false, null);
m_OriginalPos.CopyToLocalTransform(transform);
} else {
ChangeParent(parentObj.transform, transform, false, null);
}
if (m_bParentHideToStartDestroy == false)
StartDestroy();
}
// Live time
if (0 < m_fStartDestroyTime)
{
if (0 < m_fSmoothDestroyTime)
{
if (m_bSmoothHide)
{
float fRate = 1 - ((GetEngineTime() - m_fStartDestroyTime) / m_fSmoothDestroyTime);
if (fRate < 0)
fRate = 0;
// Recursively
Renderer[] rens = transform.GetComponentsInChildren<Renderer>(true);
for (int n = 0; n < rens.Length; n++)
{
Renderer ren = rens[n];
string colName = GetMaterialColorName(ren.material);
if (colName != null)
{
Color col = ren.material.GetColor(colName);
col.a = Mathf.Min(fRate, col.a);
ren.material.SetColor(colName, col);
}
}
}
if (m_fStartDestroyTime + m_fSmoothDestroyTime < GetEngineTime())
Object.Destroy(gameObject);
}
} else {
if (m_bParentHideToStartDestroy)
if (m_ParentGameObject == null || IsActive(m_ParentGameObject) == false)
StartDestroy();
}
// follow parent transform
if (m_bFollowParentTransform && m_ParentGameObject != null && m_ParentGameObject.transform != null)
{
NcTransformTool tmp = new NcTransformTool();
tmp.SetTransform(m_OriginalPos);
tmp.AddTransform(m_ParentGameObject.transform);
tmp.CopyToLocalTransform(transform);
}
}
