public static Dictionary <ParticleSystem, int> EnforceParticleSystemLimits(GameObject currentAvatar)
{
Dictionary <ParticleSystem, int> particleSystems = new Dictionary <ParticleSystem, int>();
foreach (ParticleSystem ps in currentAvatar.transform.GetComponentsInChildren <ParticleSystem>(true))
{
int realtime_max = ps_max_particles;
// always limit collision force
var collision = ps.collision;
if (collision.colliderForce > ps_max_particle_force)
{
collision.colliderForce = ps_max_particle_force;
Debug.LogError("Collision force is restricted on avatars, particle system named " + ps.gameObject.name + " collision force restricted to " + ps_max_particle_force);
}
if (ps_limiter_enabled)
{
if (particleSystems.Count > ps_max_systems)
{
Debug.LogError("Too many particle systems, #" + particleSystems.Count + " named " + ps.gameObject.name + " deleted");
ValidationUtils.RemoveComponent(ps);
continue;
}
else
{
var main = ps.main;
var emission = ps.emission;
ParticleSystemRenderer renderer = ps.GetComponent <ParticleSystemRenderer>();
if (renderer != null)
{
if (renderer.renderMode == ParticleSystemRenderMode.Mesh)
{
Mesh[] meshes = new Mesh[0];
int highestPoly = 0;
renderer.GetMeshes(meshes);
if (meshes.Length == 0 && renderer.mesh != null)
{
meshes = new Mesh[] { renderer.mesh };
}
// Debug.Log(meshes.Length + " meshes possible emmited meshes from " + ps.gameObject.name);
foreach (Mesh m in meshes)
{
if (m.isReadable)
{
if (m.triangles.Length / 3 > highestPoly)
{
highestPoly = m.triangles.Length / 3;
}
}
else
{
if (1000 > highestPoly)
{
highestPoly = int.MaxValue;
}
}
}
if (highestPoly > 0)
{
highestPoly = Mathf.Clamp(highestPoly / ps_mesh_particle_divider, 1, highestPoly);
realtime_max = Mathf.FloorToInt((float)realtime_max / highestPoly);
if (highestPoly > ps_mesh_particle_poly_limit)
{
Debug.LogError("Particle system named " + ps.gameObject.name + " breached polygon limits, it has been deleted");
ValidationUtils.RemoveComponent(ps);
continue;
}
}
}
}
ParticleSystem.MinMaxCurve rate = emission.rateOverTime;
if (rate.mode == ParticleSystemCurveMode.Constant)
{
rate.constant = Mathf.Clamp(rate.constant, 0, ps_max_emission);
}
else if (rate.mode == ParticleSystemCurveMode.TwoConstants)
{
rate.constantMax = Mathf.Clamp(rate.constantMax, 0, ps_max_emission);
}
else
{
rate.curveMultiplier = Mathf.Clamp(rate.curveMultiplier, 0, ps_max_emission);
}
emission.rateOverTime = rate;
rate = emission.rateOverDistance;
if (rate.mode == ParticleSystemCurveMode.Constant)
{
rate.constant = Mathf.Clamp(rate.constant, 0, ps_max_emission);
}
else if (rate.mode == ParticleSystemCurveMode.TwoConstants)
{
rate.constantMax = Mathf.Clamp(rate.constantMax, 0, ps_max_emission);
}
else
{
rate.curveMultiplier = Mathf.Clamp(rate.curveMultiplier, 0, ps_max_emission);
}
emission.rateOverDistance = rate;
//Disable collision with PlayerLocal layer
collision.collidesWith &= ~(1 << 10);
}
}
particleSystems.Add(ps, realtime_max);
}
EnforceRealtimeParticleSystemLimits(particleSystems, true, false);
return(particleSystems);
}
private void Start()
{
_psRenderer = GetComponent <ParticleSystemRenderer>();
_mat = _psRenderer.material;
}
void Start()
{
psr = starParticles.GetComponent <ParticleSystemRenderer>();
}
private static void AnalyzeParticleSystemRenderers(IEnumerable <ParticleSystem> particleSystems, AvatarPerformanceStats perfStats)
{
int particleSystemCount = 0;
ulong particleTotalCount = 0;
ulong particleTotalMaxMeshPolyCount = 0;
bool particleTrailsEnabled = false;
bool particleCollisionEnabled = false;
int materialSlots = 0;
Profiler.BeginSample("AnalyzeParticleSystemRenderers");
foreach (ParticleSystem particleSystem in particleSystems)
{
Profiler.BeginSample("Single Particle System");
int particleCount = particleSystem.main.maxParticles;
if (particleCount <= 0)
{
Profiler.EndSample();
continue;
}
particleSystemCount++;
particleTotalCount += (uint)particleCount;
ParticleSystemRenderer particleSystemRenderer = particleSystem.GetComponent <ParticleSystemRenderer>();
if (particleSystemRenderer == null)
{
Profiler.EndSample();
continue;
}
materialSlots++;
// mesh particles
if (particleSystemRenderer.renderMode == ParticleSystemRenderMode.Mesh && particleSystemRenderer.meshCount > 0)
{
uint highestPolyCount = 0;
Mesh[] meshes = new Mesh[particleSystemRenderer.meshCount];
int particleRendererMeshCount = particleSystemRenderer.GetMeshes(meshes);
for (int meshIndex = 0; meshIndex < particleRendererMeshCount; meshIndex++)
{
Mesh mesh = meshes[meshIndex];
if (mesh == null)
{
continue;
}
uint polyCount = MeshUtils.GetMeshTriangleCount(mesh);
if (polyCount > highestPolyCount)
{
highestPolyCount = polyCount;
}
}
ulong maxMeshParticlePolyCount = (uint)particleCount * highestPolyCount;
particleTotalMaxMeshPolyCount += maxMeshParticlePolyCount;
}
if (particleSystem.trails.enabled)
{
particleTrailsEnabled = true;
materialSlots++;
}
if (particleSystem.collision.enabled)
{
particleCollisionEnabled = true;
}
Profiler.EndSample();
}
Profiler.EndSample();
perfStats.particleSystemCount = particleSystemCount;
perfStats.particleTotalCount = particleTotalCount > int.MaxValue ? int.MaxValue : (int)particleTotalCount;
perfStats.particleMaxMeshPolyCount = particleTotalMaxMeshPolyCount > int.MaxValue ? int.MaxValue : (int)particleTotalMaxMeshPolyCount;
perfStats.particleTrailsEnabled = particleTrailsEnabled;
perfStats.particleCollisionEnabled = particleCollisionEnabled;
perfStats.materialCount = perfStats.materialCount.GetValueOrDefault() + materialSlots;
}
private void DoVertexStreamsGUI(RenderMode renderMode)
{
ParticleSystemRenderer renderer = m_ParticleSystemUI.m_ParticleSystems[0].GetComponent <ParticleSystemRenderer>();
// render list
m_NumTexCoords = 0;
m_TexCoordChannelIndex = 0;
m_NumInstancedStreams = 0;
m_HasTangent = false;
m_HasColor = false;
m_HasGPUInstancing = (renderMode == RenderMode.Mesh) ? renderer.supportsMeshInstancing : false;
m_VertexStreamsList.DoLayoutList();
if (!m_ParticleSystemUI.multiEdit)
{
// error messages
string errors = "";
// check we have the same streams as the assigned shader
if (m_Material != null)
{
Material material = m_Material.objectReferenceValue as Material;
int totalChannelCount = m_NumTexCoords * 4 + m_TexCoordChannelIndex;
bool tangentError = false, colorError = false, uvError = false;
bool anyErrors = ParticleSystem.CheckVertexStreamsMatchShader(m_HasTangent, m_HasColor, totalChannelCount, material, ref tangentError, ref colorError, ref uvError);
if (anyErrors)
{
errors += "Vertex streams do not match the shader inputs. Particle systems may not render correctly. Ensure your streams match and are used by the shader.";
if (tangentError)
{
errors += "\n- TANGENT stream does not match.";
}
if (colorError)
{
errors += "\n- COLOR stream does not match.";
}
if (uvError)
{
errors += "\n- TEXCOORD streams do not match.";
}
}
}
// check we aren't using too many texcoords
int maxTexCoords = ParticleSystem.GetMaxTexCoordStreams();
if (m_NumTexCoords > maxTexCoords || (m_NumTexCoords == maxTexCoords && m_TexCoordChannelIndex > 0))
{
if (errors != "")
{
errors += "\n\n";
}
errors += "Only " + maxTexCoords + " TEXCOORD streams are supported.";
}
// check input meshes aren't using too many UV streams
if (renderMode == RenderMode.Mesh)
{
Mesh[] meshes = new Mesh[k_MaxNumMeshes];
int numMeshes = renderer.GetMeshes(meshes);
for (int i = 0; i < numMeshes; i++)
{
if (meshes[i].HasChannel(VertexAttribute.TexCoord2))
{
if (errors != "")
{
errors += "\n\n";
}
errors += "Meshes may only use a maximum of 2 input UV streams.";
}
}
}
if (errors != "")
{
GUIContent warning = EditorGUIUtility.TextContent(errors);
EditorGUILayout.HelpBox(warning.text, MessageType.Error, true);
}
}
}
void ChangeParticleSystemMaterial(Material material)
{
ParticleSystemRenderer psr = GetComponent <ParticleSystemRenderer>();
psr.material = material;
}
private IEnumerator TimeForAction()
{
if (actionStarted)
{
yield break;
}
actionStarted = true;
string attackingElement = battleSM.performList[0].chosenAttack.attackName.ToUpper();
bool showParticles = true;
ParticleSystem elementParticles = gameObject.GetComponentInParent <ParticleSystem>();
ParticleSystemRenderer elementRender = elementParticles.GetComponent <ParticleSystemRenderer>();
ParticleSystem damageParticles = elementDamage.GetComponentInParent <ParticleSystem>();
ParticleSystemRenderer damageRender = damageParticles.GetComponent <ParticleSystemRenderer>();
switch (attackingElement)
{
case "WOOD":
elementRender.material = new Material(Resources.Load <Material>("WoodParticle"));
damageRender.material = new Material(Resources.Load <Material>("WoodParticle"));
break;
case "FIRE":
elementRender.material = new Material(Resources.Load <Material>("FireParticle"));
damageRender.material = new Material(Resources.Load <Material>("FireParticle"));
break;
case "EARTH":
elementRender.material = new Material(Resources.Load <Material>("EarthParticle"));
damageRender.material = new Material(Resources.Load <Material>("EarthParticle"));
break;
case "METAL":
elementRender.material = new Material(Resources.Load <Material>("MetalParticle"));
damageRender.material = new Material(Resources.Load <Material>("MetalParticle"));
break;
case "WATER":
elementRender.material = new Material(Resources.Load <Material>("WaterParticle"));
damageRender.material = new Material(Resources.Load <Material>("WaterParticle"));
break;
default:
showParticles = false;
break;
}
//turn on particle effect
if (showParticles)
{
elementParticles.Play();
damageParticles.Stop();
AudioClip enemyAttackAudio = (AudioClip)Resources.Load("audio/eq_hero_magic");
battleSM.GetComponent <AudioSource>().PlayOneShot(enemyAttackAudio, 0.5f);
}
//animate the enemy near the target to attack
Vector3 targetPosition = new Vector3(actionTarget.transform.position.x + 1.5f, actionTarget.transform.position.y, actionTarget.transform.position.z);
while (MoveTowardsTarget(targetPosition))
{
yield return(null);
}
if (showParticles)
{
damageParticles.Play();
}
//wait
yield return(new WaitForSeconds(0.6f));
if (showParticles)
{
damageParticles.Stop();
}
//do damage
DoDamage();
//turn off particle effect
if (showParticles)
{
elementParticles.Stop();
}
//animate back to start position
Vector3 firstPosition = startPosition;
while (MoveTowardsTarget(firstPosition))
{
yield return(null);
}
//remove this performer from the list in battleSM
battleSM.performList.RemoveAt(0);
//reset the battleSM
if (battleSM.battleState != BattleStateMachine.PerformAction.WIN && battleSM.battleState != BattleStateMachine.PerformAction.LOSE)
{
battleSM.battleState = BattleStateMachine.PerformAction.WAIT;
battleSM.UpdateTurnOrder();
//reset this state
float delayFactor = 5f - delayValue;
currCooldown = Mathf.Clamp(delayFactor, 0, 4);
currentState = TurnState.PROCESSING;
}
else
{
currentState = TurnState.WAITING;
}
//end coroutine
actionStarted = false;
}
public static void ParsePointRendering(string[] values, ParticleSystemRenderer _renderer)
{
if (values.Length != 1) {
ParseHelper.LogParserError("point_rendering", _renderer.Type, "Wrong number of parameters.");
return;
}
BillboardParticleRenderer renderer = (BillboardParticleRenderer)_renderer;
renderer.PointRenderingEnabled = StringConverter.ParseBool(values[0]);
}
// Use this for initialization
void Awake()
{
characterMovement = GetComponent <CharacterMovement>();
aura = GetComponent <ParticleSystemRenderer>();
}
public void UpdateParticleSystem()
{
ParticleSystem refSystem = referenceLine.GetComponent <ParticleSystem>();
ParticleSystem.MainModule refSetting = refSystem.main;
ParticleSystem.EmissionModule refEmission = refSystem.emission;
ParticleSystem.RotationOverLifetimeModule refRotationLifeTime = refSystem.rotationOverLifetime;
ParticleSystem.SizeOverLifetimeModule refSizeLifetime = refSystem.sizeOverLifetime;
ParticleSystemRenderer refRenderer = refSystem.GetComponent <ParticleSystemRenderer>();
ParticleSystem.Burst refBurst = refEmission.GetBurst(0);
foreach (Line line in triangleComplex.lines)
{
ParticleSystem particleSystem = line.GetComponent <ParticleSystem>();
ParticleSystem.MainModule particleSettings = particleSystem.main;
ParticleSystem.EmissionModule particleEmission = particleSystem.emission;
ParticleSystem.RotationOverLifetimeModule particleRotationLifeTime = particleSystem.rotationOverLifetime;
ParticleSystem.SizeOverLifetimeModule particleSizeLifetime = particleSystem.sizeOverLifetime;
ParticleSystemRenderer particleRenderer = particleSystem.GetComponent <ParticleSystemRenderer>();
particleSettings.customSimulationSpace = refSetting.customSimulationSpace;
particleSettings.duration = refSetting.duration;
particleSettings.emitterVelocityMode = refSetting.emitterVelocityMode;
particleSettings.flipRotation = refSetting.flipRotation;
particleSettings.gravityModifier = refSetting.gravityModifier;
particleSettings.gravityModifierMultiplier = refSetting.gravityModifierMultiplier;
particleSettings.loop = refSetting.loop;
particleSettings.maxParticles = refSetting.maxParticles;
particleSettings.playOnAwake = refSetting.playOnAwake;
particleSettings.prewarm = refSetting.prewarm;
particleSettings.scalingMode = refSetting.scalingMode;
particleSettings.simulationSpace = refSetting.simulationSpace;
particleSettings.simulationSpeed = refSetting.simulationSpeed;
particleSettings.startColor = refSetting.startColor;
particleSettings.startDelay = refSetting.startDelay;
particleSettings.startDelayMultiplier = refSetting.startDelayMultiplier;
particleSettings.startLifetime = refSetting.startLifetime;
particleSettings.startLifetimeMultiplier = refSetting.startLifetimeMultiplier;
particleSettings.startRotation = refSetting.startRotation;
particleSettings.startRotation3D = refSetting.startRotation3D;
particleSettings.startRotationMultiplier = refSetting.startRotationMultiplier;
particleSettings.startRotationX = refSetting.startRotationX;
particleSettings.startRotationXMultiplier = refSetting.startRotationXMultiplier;
particleSettings.startRotationY = refSetting.startRotationY;
particleSettings.startRotationYMultiplier = refSetting.startRotationYMultiplier;
particleSettings.startRotationZ = refSetting.startRotationZ;
particleSettings.startRotationZMultiplier = refSetting.startRotationZMultiplier;
particleSettings.startSize = refSetting.startSize;
particleSettings.startSize3D = refSetting.startSize3D;
particleSettings.startSizeMultiplier = refSetting.startSizeMultiplier;
particleSettings.startSizeX = refSetting.startSizeX;
particleSettings.startSizeXMultiplier = refSetting.startSizeXMultiplier;
particleSettings.startSizeY = refSetting.startSizeY;
particleSettings.startSizeYMultiplier = refSetting.startSizeYMultiplier;
particleSettings.startSizeZ = refSetting.startSizeZ;
particleSettings.startSizeZMultiplier = refSetting.startSizeZMultiplier;
particleSettings.startSpeed = refSetting.startSpeed;
particleSettings.startSpeedMultiplier = refSetting.startSpeedMultiplier;
particleSettings.stopAction = refSetting.stopAction;
particleSettings.useUnscaledTime = refSetting.useUnscaledTime;
particleEmission.burstCount = refEmission.burstCount;
particleEmission.enabled = refEmission.enabled;
particleEmission.rateOverDistance = refEmission.rateOverDistance;
particleEmission.rateOverDistanceMultiplier = refEmission.rateOverDistanceMultiplier;
particleEmission.rateOverTime = refEmission.rateOverTime;
particleEmission.rateOverTimeMultiplier = refEmission.rateOverTimeMultiplier;
particleRotationLifeTime.enabled = refRotationLifeTime.enabled;
particleRotationLifeTime.separateAxes = refRotationLifeTime.separateAxes;
particleRotationLifeTime.x = refRotationLifeTime.x;
particleRotationLifeTime.xMultiplier = refRotationLifeTime.xMultiplier;
particleRotationLifeTime.y = refRotationLifeTime.y;
particleRotationLifeTime.yMultiplier = refRotationLifeTime.yMultiplier;
particleRotationLifeTime.z = refRotationLifeTime.z;
particleRotationLifeTime.zMultiplier = refRotationLifeTime.zMultiplier;
particleSizeLifetime.enabled = refSizeLifetime.enabled;
particleSizeLifetime.separateAxes = refSizeLifetime.separateAxes;
particleSizeLifetime.size = refSizeLifetime.size;
particleSizeLifetime.sizeMultiplier = refSizeLifetime.sizeMultiplier;
particleSizeLifetime.x = refSizeLifetime.x;
particleSizeLifetime.xMultiplier = refSizeLifetime.xMultiplier;
particleSizeLifetime.y = refSizeLifetime.y;
particleSizeLifetime.yMultiplier = refSizeLifetime.yMultiplier;
particleSizeLifetime.z = refSizeLifetime.z;
particleSizeLifetime.zMultiplier = refSizeLifetime.zMultiplier;
particleRenderer.minParticleSize = refRenderer.minParticleSize;
particleEmission.SetBursts(new ParticleSystem.Burst[] { refBurst });
}
}
// Start is called before the first frame update
void Start()
{
light = GetComponent <Light>();
particleSystemRenderer = GetComponent <ParticleSystemRenderer>();
size = transform.localScale;
}
public void OnGUI(float width, bool fixedWidth)
{
bool isRepaintEvent = Event.current.type == EventType.Repaint;
// Name of current emitter
string selectedEmitterName = null;
if (m_ParticleSystems.Length > 1)
{
selectedEmitterName = "Multiple Particle Systems";
}
else if (m_ParticleSystems.Length > 0)
{
selectedEmitterName = m_ParticleSystems[0].gameObject.name;
}
if (fixedWidth)
{
EditorGUIUtility.labelWidth = width * 0.4f;
EditorGUILayout.BeginVertical(GUILayout.Width(width));
}
else
{
// First make sure labelWidth is at default width, then subtract
EditorGUIUtility.labelWidth = 0;
EditorGUIUtility.labelWidth = EditorGUIUtility.labelWidth - 4;
EditorGUILayout.BeginVertical();
}
{
InitialModuleUI initial = (InitialModuleUI)m_Modules[0];
for (int i = 0; i < m_Modules.Length; ++i)
{
ModuleUI module = m_Modules[i];
if (module == null)
{
continue;
}
bool initialModule = (module == m_Modules[0]);
// Skip if not visible (except initial module which should always be visible)
if (!module.visibleUI && !initialModule)
{
continue;
}
// Module header size
GUIContent headerLabel = new GUIContent();
Rect moduleHeaderRect;
if (initialModule)
{
moduleHeaderRect = GUILayoutUtility.GetRect(width, 25);
}
else
{
moduleHeaderRect = GUILayoutUtility.GetRect(width, 15);
}
// Module content here to render it below the the header
if (module.foldout)
{
using (new EditorGUI.DisabledScope(!module.enabled))
{
Rect moduleSize = EditorGUILayout.BeginVertical(ParticleSystemStyles.Get().modulePadding);
{
moduleSize.y -= 4; // pull background 'up' behind title to fill rounded corners.
moduleSize.height += 4;
GUI.Label(moduleSize, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
module.OnInspectorGUI(initial);
}
EditorGUILayout.EndVertical();
}
}
// TODO: Get Texture instead of static preview. Render Icon (below titlebar due to rounded corners)
if (initialModule)
{
// Get preview of material or mesh
ParticleSystemRenderer renderer = m_ParticleSystems[0].GetComponent <ParticleSystemRenderer>();
float iconSize = 21;
Rect iconRect = new Rect(moduleHeaderRect.x + 4, moduleHeaderRect.y + 2, iconSize, iconSize);
if (isRepaintEvent && renderer != null)
{
bool iconRendered = false;
int instanceID = 0;
if (!multiEdit)
{
if (renderer.renderMode == ParticleSystemRenderMode.Mesh)
{
if (renderer.mesh != null)
{
instanceID = renderer.mesh.GetInstanceID();
}
}
else if (renderer.sharedMaterial != null)
{
instanceID = renderer.sharedMaterial.GetInstanceID();
}
// If the asset is dirty we ensure to get a updated one by clearing cache of temporary previews
if (EditorUtility.IsDirty(instanceID))
{
AssetPreview.ClearTemporaryAssetPreviews();
}
if (instanceID != 0)
{
Texture2D icon = AssetPreview.GetAssetPreview(instanceID);
if (icon != null)
{
GUI.DrawTexture(iconRect, icon, ScaleMode.StretchToFill, true);
iconRendered = true;
}
}
}
// Fill so we do not see the background when we have no icon (eg multi-edit)
if (!iconRendered)
{
GUI.Label(iconRect, GUIContent.none, ParticleSystemStyles.Get().moduleBgStyle);
}
}
// Select gameObject when clicking on icon
if (!multiEdit && EditorGUI.DropdownButton(iconRect, GUIContent.none, FocusType.Passive, GUIStyle.none))
{
// Toggle selected particle system from selection
if (EditorGUI.actionKey)
{
List <int> newSelection = new List <int>();
int instanceID = m_ParticleSystems[0].gameObject.GetInstanceID();
newSelection.AddRange(Selection.instanceIDs);
if (!newSelection.Contains(instanceID) || newSelection.Count != 1)
{
if (newSelection.Contains(instanceID))
{
newSelection.Remove(instanceID);
}
else
{
newSelection.Add(instanceID);
}
}
Selection.instanceIDs = newSelection.ToArray();
}
else
{
Selection.instanceIDs = new int[0];
Selection.activeInstanceID = m_ParticleSystems[0].gameObject.GetInstanceID();
}
}
}
// Button logic for enabledness (see below for UI)
Rect checkMarkRect = new Rect(moduleHeaderRect.x + 2, moduleHeaderRect.y + 1, 13, 13);
if (!initialModule && GUI.Button(checkMarkRect, GUIContent.none, GUIStyle.none))
{
module.enabled = !module.enabled;
}
// Button logic for plus/minus (see below for UI)
Rect plusRect = new Rect(moduleHeaderRect.x + moduleHeaderRect.width - 10, moduleHeaderRect.y + moduleHeaderRect.height - 10, 10, 10);
Rect plusRectInteract = new Rect(plusRect.x - 4, plusRect.y - 4, plusRect.width + 4, plusRect.height + 4);
Rect infoRect = new Rect(plusRect.x - 23, plusRect.y - 8, 20, 20);
if (initialModule && EditorGUI.DropdownButton(plusRectInteract, s_Texts.addModules, FocusType.Passive, GUIStyle.none))
{
ShowAddModuleMenu();
}
// Module header (last to become top most renderered)
if (!string.IsNullOrEmpty(selectedEmitterName))
{
headerLabel.text = initialModule ? selectedEmitterName : module.displayName;
}
else
{
headerLabel.text = module.displayName;
}
headerLabel.tooltip = module.toolTip;
bool newToggleState = module.DrawHeader(moduleHeaderRect, headerLabel);
if (newToggleState != module.foldout)
{
switch (Event.current.button)
{
case 0:
bool newFoldoutState = !module.foldout;
if (Event.current.control)
{
foreach (var moduleUi in m_Modules)
{
if (moduleUi != null && moduleUi.visibleUI)
{
moduleUi.foldout = newFoldoutState;
}
}
}
else
{
module.foldout = newFoldoutState;
}
break;
case 1:
if (initialModule)
{
ShowEmitterMenu();
}
else
{
ShowModuleMenu(i);
}
break;
}
}
// Render checkmark on top (logic: see above)
if (!initialModule)
{
EditorGUI.showMixedValue = module.enabledHasMultipleDifferentValues;
GUIStyle style = EditorGUI.showMixedValue ? ParticleSystemStyles.Get().checkmarkMixed : ParticleSystemStyles.Get().checkmark;
GUI.Toggle(checkMarkRect, module.enabled, GUIContent.none, style);
EditorGUI.showMixedValue = false;
}
// Render plus/minus on top
if (isRepaintEvent && initialModule)
{
GUI.Label(plusRect, GUIContent.none, ParticleSystemStyles.Get().plus);
}
if (initialModule && !string.IsNullOrEmpty(m_SupportsCullingTextLabel))
{
var supportsCullingText = new GUIContent("", ParticleSystemStyles.Get().warningIcon, m_SupportsCullingTextLabel);
GUI.Label(infoRect, supportsCullingText);
}
GUILayout.Space(1); // dist to next module
} // foreach module
GUILayout.Space(-1);
}
EditorGUILayout.EndVertical(); // end fixed moduleWidth
// Apply the property, handle undo
ApplyProperties();
}
private static Object ReadAsset(AssetStream stream, AssetInfo assetInfo, long offset, int size)
{
Object asset;
switch (assetInfo.ClassID)
{
case ClassIDType.GameObject:
asset = new GameObject(assetInfo);
break;
case ClassIDType.Transform:
asset = new Transform(assetInfo);
break;
case ClassIDType.Camera:
asset = new Camera(assetInfo);
break;
case ClassIDType.Material:
asset = new Material(assetInfo);
break;
case ClassIDType.MeshRenderer:
asset = new MeshRenderer(assetInfo);
break;
case ClassIDType.Texture2D:
asset = new Texture2D(assetInfo);
break;
case ClassIDType.SceneSettings:
asset = new OcclusionCullingSettings(assetInfo);
break;
case ClassIDType.MeshFilter:
asset = new MeshFilter(assetInfo);
break;
case ClassIDType.OcclusionPortal:
asset = new OcclusionPortal(assetInfo);
break;
case ClassIDType.Mesh:
asset = new Mesh(assetInfo);
break;
case ClassIDType.Shader:
asset = new Shader(assetInfo);
break;
case ClassIDType.TextAsset:
asset = new TextAsset(assetInfo);
break;
case ClassIDType.Rigidbody2D:
asset = new Rigidbody2D(assetInfo);
break;
case ClassIDType.Rigidbody:
asset = new Rigidbody(assetInfo);
break;
case ClassIDType.CircleCollider2D:
asset = new CircleCollider2D(assetInfo);
break;
case ClassIDType.PolygonCollider2D:
asset = new PolygonCollider2D(assetInfo);
break;
case ClassIDType.BoxCollider2D:
asset = new BoxCollider2D(assetInfo);
break;
case ClassIDType.PhysicsMaterial2D:
asset = new PhysicsMaterial2D(assetInfo);
break;
case ClassIDType.MeshCollider:
asset = new MeshCollider(assetInfo);
break;
case ClassIDType.BoxCollider:
asset = new BoxCollider(assetInfo);
break;
case ClassIDType.SpriteCollider2D:
asset = new CompositeCollider2D(assetInfo);
break;
case ClassIDType.EdgeCollider2D:
asset = new EdgeCollider2D(assetInfo);
break;
case ClassIDType.CapsuleCollider2D:
asset = new CapsuleCollider2D(assetInfo);
break;
case ClassIDType.AnimationClip:
asset = new AnimationClip(assetInfo);
break;
case ClassIDType.AudioListener:
asset = new AudioListener(assetInfo);
break;
case ClassIDType.AudioSource:
asset = new AudioSource(assetInfo);
break;
case ClassIDType.AudioClip:
asset = new AudioClip(assetInfo);
break;
case ClassIDType.RenderTexture:
asset = new RenderTexture(assetInfo);
break;
case ClassIDType.Cubemap:
asset = new Cubemap(assetInfo);
break;
case ClassIDType.Avatar:
asset = new Avatar(assetInfo);
break;
case ClassIDType.AnimatorController:
asset = new AnimatorController(assetInfo);
break;
case ClassIDType.GUILayer:
asset = new GUILayer(assetInfo);
break;
case ClassIDType.Animator:
asset = new Animator(assetInfo);
break;
case ClassIDType.RenderSettings:
asset = new RenderSettings(assetInfo);
break;
case ClassIDType.Light:
asset = new Light(assetInfo);
break;
case ClassIDType.Animation:
asset = new Animation(assetInfo);
break;
case ClassIDType.MonoScript:
asset = new MonoScript(assetInfo);
break;
case ClassIDType.NewAnimationTrack:
asset = new NewAnimationTrack(assetInfo);
break;
case ClassIDType.FlareLayer:
asset = new FlareLayer(assetInfo);
break;
case ClassIDType.Font:
asset = new Font(assetInfo);
break;
case ClassIDType.PhysicMaterial:
asset = new PhysicMaterial(assetInfo);
break;
case ClassIDType.SphereCollider:
asset = new SphereCollider(assetInfo);
break;
case ClassIDType.CapsuleCollider:
asset = new CapsuleCollider(assetInfo);
break;
case ClassIDType.SkinnedMeshRenderer:
asset = new SkinnedMeshRenderer(assetInfo);
break;
case ClassIDType.BuildSettings:
asset = new BuildSettings(assetInfo);
break;
case ClassIDType.AssetBundle:
asset = new AssetBundle(assetInfo);
break;
case ClassIDType.WheelCollider:
asset = new WheelCollider(assetInfo);
break;
case ClassIDType.MovieTexture:
asset = new MovieTexture(assetInfo);
break;
case ClassIDType.TerrainCollider:
asset = new TerrainCollider(assetInfo);
break;
case ClassIDType.TerrainData:
asset = new TerrainData(assetInfo);
break;
case ClassIDType.LightmapSettings:
asset = new LightmapSettings(assetInfo);
break;
case ClassIDType.OcclusionArea:
asset = new OcclusionArea(assetInfo);
break;
case ClassIDType.NavMeshSettings:
asset = new NavMeshSettings(assetInfo);
break;
case ClassIDType.ParticleSystem:
asset = new ParticleSystem(assetInfo);
break;
case ClassIDType.ParticleSystemRenderer:
asset = new ParticleSystemRenderer(assetInfo);
break;
case ClassIDType.SpriteRenderer:
asset = new SpriteRenderer(assetInfo);
break;
case ClassIDType.Sprite:
asset = new Sprite(assetInfo);
break;
case ClassIDType.Terrain:
asset = new Terrain(assetInfo);
break;
case ClassIDType.AnimatorOverrideController:
asset = new AnimatorOverrideController(assetInfo);
break;
case ClassIDType.CanvasRenderer:
asset = new CanvasRenderer(assetInfo);
break;
case ClassIDType.Canvas:
asset = new Canvas(assetInfo);
break;
case ClassIDType.RectTransform:
asset = new RectTransform(assetInfo);
break;
case ClassIDType.NavMeshData:
asset = new NavMeshData(assetInfo);
break;
case ClassIDType.OcclusionCullingData:
asset = new OcclusionCullingData(assetInfo);
break;
case ClassIDType.SceneAsset:
asset = new SceneAsset(assetInfo);
break;
case ClassIDType.LightmapParameters:
asset = new LightmapParameters(assetInfo);
break;
case ClassIDType.SpriteAtlas:
asset = new SpriteAtlas(assetInfo);
break;
default:
return(null);
}
stream.BaseStream.Position = offset;
if (Config.IsGenerateGUIDByContent)
{
byte[] data = stream.ReadBytes(size);
asset.Read(data);
using (MD5 md5 = MD5.Create())
{
byte[] md5Hash = md5.ComputeHash(data);
assetInfo.GUID = new UtinyGUID(md5Hash);
}
}
else
{
stream.AlignPosition = offset;
asset.Read(stream);
long read = stream.BaseStream.Position - offset;
if (read != size)
{
throw new Exception($"Read {read} but expected {size} for object {asset.GetType().Name}");
}
}
return(asset);
}
public static void ParseAccurateFacing(string[] values, ParticleSystemRenderer _renderer)
{
if (values.Length != 1) {
ParseHelper.LogParserError("accurate_facing", _renderer.Type, "Wrong number of parameters.");
return;
}
BillboardParticleRenderer renderer = (BillboardParticleRenderer)_renderer;
renderer.UseAccurateFacing = StringConverter.ParseBool(values[0]);
}
public void Play()
{
effectState = EffectState.PLAYING;
if (audioSource != null)
{
if (randomizePitch)
{
audioSource.pitch = Random.Range(pitchMin, pitchMax);
}
else if (pitchChangeOverTime)
{
float pitchSpread = (pitchMax - pitchMin);
float smoothSpread = pitchSpread * 2 - pitchSpread;
float pitchAdjust = 0;
if (smoothSpread != 0)
{
pitchAdjust = Time.time % smoothSpread;
}
audioSource.pitch = pitchMin + pitchAdjust;
}
if (randomizeClip)
{
audioSource.clip = audioClips.PickRandom();
}
else if (audioSource.clip == null && audioClips.Count > 0)
{
audioSource.clip = audioClips[0];
}
if (audioSource != null && audioSource.clip != null)
{
lifetime = audioSource.clip.length;
audioSource.Play();
}
}
if (lightGlow != null)
{
lifetime = Mathf.Max(lifetime, lightGlow.Duration);
lightGlow.Play();
}
foreach (ParticleSystem particleSystem in particleSystems)
{
if (particleSystem != null)
{
ParticleSystemRenderer particleRenderer = particleSystem.GetComponent <ParticleSystemRenderer>();
if (particleRenderer != null)
{
particleRenderers.Add(particleRenderer);
}
float particleSystemDuration = particleSystem.main.duration;
lifetime = Mathf.Max(lifetime, particleSystemDuration);
particleSystem.Play();
}
}
if (cameraShake != null)
{
cameraShake.Shake();
}
if (color != Color.black)
{
if (useColor)
{
EffectColor = color;
}
}
if (!loop)
{
if (destroyAfterComplete)
{
gameObject.BlowUp(lifetime);
}
else
{
StartCoroutine(PlayComplete(lifetime));
}
}
else
{
if (loopCount > 0)
{
lifetime *= loopCount;
StartCoroutine(PlayComplete(lifetime));
}
if (loopTime != 0)
{
lifetime = loopTime;
StartCoroutine(PlayComplete(lifetime));
}
}
}
public static void ParseCommonUpDirection(string[] values, ParticleSystemRenderer _renderer)
{
if (values.Length != 3) {
ParseHelper.LogParserError("common_up_vector", _renderer.Type, "Wrong number of parameters.");
return;
}
BillboardParticleRenderer renderer = (BillboardParticleRenderer)_renderer;
renderer.CommonUpVector = StringConverter.ParseVector3(values);
}
void Start()
{
_particles = GetComponent <ParticleSystemRenderer> ();
_particles.sortingLayerName = LayerName;
}
/// @copydoc FactoryObj::destroyInstance
public override void DestroyInstance(ParticleSystemRenderer inst)
{
}
private IEnumerator Shoot(int index)
{
GameObject go = new GameObject {
transform = { position = transform.position + Vector3.up * 13 }
};
go.transform.LookAt(Direction);
int dmg = Random.Range(30, 40);
switch (ModSettings.difficulty)
{
case ModSettings.Difficulty.Veteran:
dmg = Random.Range(85, 105);
break;
case ModSettings.Difficulty.Elite:
dmg = Random.Range(221, 234);
break;
case ModSettings.Difficulty.Master:
dmg = Random.Range(444, 470);
break;
case ModSettings.Difficulty.Challenge1:
dmg = 4124;
break;
case ModSettings.Difficulty.Challenge2:
dmg = 15653;
break;
case ModSettings.Difficulty.Challenge3:
dmg = 72346;
break;
case ModSettings.Difficulty.Challenge4:
dmg = 85932;
break;
case ModSettings.Difficulty.Challenge5:
dmg = 124636;
break;
case ModSettings.Difficulty.Challenge6:
dmg = 164636;
break;
case ModSettings.Difficulty.Hell:
dmg = 224636;
break;
}
go.AddComponent <EnemyLaserBeam>().Initialize(dmg);
ParticleSystem ps = go.AddComponent <ParticleSystem>();
ParticleSystemRenderer rend = go.GetComponent <ParticleSystemRenderer>();
rend.renderMode = ParticleSystemRenderMode.Billboard;
rend.trailMaterial = mat1;
rend.alignment = ParticleSystemRenderSpace.View;
rend.material = mat1;
ParticleSystem.ShapeModule shape = ps.shape;
shape.enabled = false;
ParticleSystem.MainModule m = ps.main;
m.simulationSpace = ParticleSystemSimulationSpace.Local;
m.startSpeed = 100;
m.startLifetime = 0.5f;
m.startSize = 0.1f;
yield return(null);
ParticleSystem.EmissionModule e = ps.emission;
e.rateOverTime = 10f;
ParticleSystem.SizeOverLifetimeModule sol = ps.sizeOverLifetime;
sol.enabled = true;
sol.sizeMultiplier = 3;
sol.size = new ParticleSystem.MinMaxCurve(20, new AnimationCurve(new Keyframe[] { new Keyframe(0f, 0f, 11.34533f, 11.34533f), new Keyframe(0.1365601f, 1f, 0.4060947f, 0.4060947f), new Keyframe(1f, 0.2881376f, -0.8223371f, -0.8223371f) }));
yield return(null);
ParticleSystem.TrailModule trail = ps.trails;
trail.enabled = true;
trail.dieWithParticles = false;
trail.inheritParticleColor = true;
trail.ratio = 0.5f;
trail.textureMode = ParticleSystemTrailTextureMode.Stretch;
float time = 0;
while (time < 8)
{
time += Time.deltaTime;
if (index != 0)
{
float mult = index % 2 == 0 ? 1 : -1;
go.transform.Rotate(Vector3.up * Time.deltaTime * 100 * mult, Space.World);
go.transform.Rotate(go.transform.right * Time.deltaTime * 40 * Mathf.Sin(time * 6), Space.World);
}
yield return(null);
}
Destroy(go);
}
// Use this for initialization
void Start()
{
particleSys = GetComponent <ParticleSystemRenderer>();
rb = GetComponent <Rigidbody2D>();
}
// Update is called once per frame
void Update()
{
//Manage health bar.
float divider = 0.0033f;
Game.manager.GetComponent <GameManager>().BossHealthBar(health, divider);
if (health < 0)
{
health = 0;
} //You can't go negative health!
//Set proper parent.
transform.parent = Game.enemyHolder.transform;
//Flash me when I'm hit.
if (hitCounter > 0f)
{
hitCounter -= Time.deltaTime;
targetColor = Game.bulletColor;
}
else
{
targetColor = Game.frontColor;
}
float smoothness = 5f;
if (puppetToColor != null)
{
puppetToColor.GetComponent <MeshRenderer>().material.color = Color.Lerp(puppetToColor.GetComponent <MeshRenderer>().material.color, targetColor, smoothness * Time.deltaTime);
}
if (Game.manager.GetComponent <GameManager>().splashCounter <= 0 && !dead)
{
//Transition phase.
if (p == Phase.ComingIn)
{
//Keep hitbox disabled.
hitBox.enabled = false;
//Enable introPoofEffect.
introPoofEffect.SetActive(true);
//Setting animation frames.
anim.framesOffset[0] = Vector2.zero;
anim.framesOffset[1] = new Vector2(0.2f, 0f);
//Subtract the amount of time needed for the introduction scene.
introWait -= Time.deltaTime;
//Set the Form 1 and 2 puppet to be active when there are 1.9 seconds left in the intro.
bool active = (introWait <= 1.9f);
form1And2Holder.SetActive(active);
//When the intro cutscene is over, go to Phase 1!
if (introWait <= 0f)
{
PlaySound.NoLoop(giggleSnd);
p = Phase.Phase1;
}
}
else if (p == Phase.Phase1) //Phase 1!
//When to get rid of love text.
{
if (textAwayTime > 0)
{
textAwayTime -= Time.deltaTime;
}
else
{
if (!triggeredTextTween)
{
iTween.ScaleTo(textObj, iTween.Hash(
"x", 0f, "y", 0f, "z", 1f,
"time", 1f,
"easetype", iTween.EaseType.easeInOutSine,
"looptype", iTween.LoopType.none
));
triggeredTextTween = true;
}
}
//Kill the poof effect object, it is no longer needed.
if (introPoofEffect != null)
{
Destroy(introPoofEffect);
}
//Keep hitbox enabled and set it's params.
hitBox.enabled = true;
hitBox.size = new Vector2(3.5f, 1.6f);
hitBox.offset = new Vector2(0f, -0.1f);
//Setting animation frames.
anim.framesOffset[0] = Vector2.zero;
anim.framesOffset[1] = new Vector2(0.1f, 0f);
//Setting the puppet to Color when being hit.
puppetToColor = form1Puppet;
//Spawning the hearts.
heartSpawnCounter -= Time.deltaTime;
if (heartSpawnCounter <= 0)
{
PlaySound.NoLoop(smooches[Random.Range(0, smooches.Length)]);
Instantiate(attacks[0], new Vector3(transform.position.x, transform.position.y, 25), Quaternion.identity);
heartSpawnCounter = heartSpawnTime;
}
//When to go to phase 2.
if (health < 250)
{
PlaySound.NoLoop(sadSnd);
GoPhaseTwo();
}
}
else if (p == Phase.Phase2)
{
//Keep hitbox enabled and set it's params.
hitBox.enabled = true;
hitBox.size = new Vector2(3.5f, 1.6f);
hitBox.offset = new Vector2(0f, -0.1f);
//Setting animation frames.
anim.framesOffset[0] = new Vector2(0.3f, 0f);
anim.framesOffset[1] = new Vector2(0.4f, 0f);
//Lightning spawning.
lightingSpawnCounter -= Time.deltaTime;
if (lightingSpawnCounter <= 0)
{
float x = Random.Range(-32f, 32f);
Instantiate(attacks[1], new Vector3(x, 0, 0), Quaternion.identity);
lightingSpawnCounter = lightingSpawnTime;
}
//When to start transition phase.
if (health < 150)
{
health = 149;
p = Phase.Transition1;
}
}
else if (p == Phase.Transition1) //Transition to phase 3!
//Disable the hitbox when transforming, also enable form 3 puppet.
{
hitBox.enabled = false;
form3Puppet.SetActive(true);
//Waiting to open the mouth.
openMouthWait -= Time.deltaTime;
if (openMouthWait > 0)
{ //Keep mouth closed until wait time is over.
anim.framesOffset[0] = new Vector2(0.5f, 0f);
anim.framesOffset[1] = new Vector2(0.6f, 0f);
}
else
{
//Play open mouth frames.
anim.framesOffset[0] = new Vector2(0.7f, 0f);
anim.framesOffset[1] = new Vector2(0.8f, 0f);
}
//Updating scale of the form 3 puppet to come out of the mouth!
if (openMouthWait > -2)
{
puppet3TargetScale = new Vector3(0, 0, 1);
}
else
{
puppet3TargetScale = new Vector3(15, 15, 1);
}
float smuth = 3f;
form3Puppet.transform.localScale = Vector3.Lerp(form3Puppet.transform.localScale, puppet3TargetScale, smuth * Time.deltaTime);
//Animate the form3puppet a bit.
if (openMouthWait > -4f)
{
frame = Vector2.zero;
}
else if (openMouthWait < -4f && openMouthWait > -5f)
{
frame = new Vector2(0.2f, 0f);
}
else if (openMouthWait < -5f && openMouthWait > -6f)
{
frame = new Vector2(0.4f, 0f);
}
else if (openMouthWait < -6f && openMouthWait > -6.25f)
{
frame = new Vector2(0.2f, 0f);
}
else if (openMouthWait < -6.25f && openMouthWait > -6.5f)
{
frame = new Vector2(0.4f, 0f);
}
else if (openMouthWait < -6.5f && openMouthWait > -6.75f)
{
frame = new Vector2(0.2f, 0f);
}
else if (openMouthWait < -7f)
{
frame = new Vector2(0.4f, 0f);
}
form3Puppet.GetComponent <MeshRenderer>().material.mainTextureOffset = frame;
//Go to form 3!
if (openMouthWait < -8f)
{
PlaySound.NoLoop(chargeSnd);
p = Phase.Phase3;
}
}
else if (p == Phase.Phase3)
{
//Destroy the unneeded puppets.
if (form1And2Holder != null)
{
Destroy(form1And2Holder);
}
//Determine position and velocity.
pos = transform.position;
vel = rig.velocity;
//Setting hitbox properties.
hitBox.enabled = (health > 50);
hitBox.offset = Vector2.zero;
hitBox.size = new Vector2(11f, 11f);
//Setting which puppet to be colored when hit.
puppetToColor = form3Puppet;
//Enable that chomp animation.
animForm3.enabled = true;
//Manage flip of puppet.
if (vel.x < 0)
{
form3Puppet.transform.localScale = new Vector3(15, 15, 1);
}
else if (vel.x > 0)
{
form3Puppet.transform.localScale = new Vector3(-15, 15, 1);
}
//Go towards player!
if (!gotNewVel && Game.playerObj != null)
{
Vector2 pPos = new Vector2(Game.playerObj.transform.position.x, Game.playerObj.transform.position.y);
Vector2 dif = new Vector2(pos.x, pos.y) - pPos;
float speed = 20f;
newVel = dif.normalized * speed;
vel = -newVel;
gotNewVel = true;
}
//Going around randomly when offscreen!
if (pos.x > 46 || pos.x < -46 || pos.y > 31 || pos.y < -31)
{
//To phase 4!
if (health < 51)
{
arrow.SetActive(true);
iTween.ScaleTo(arrow, iTween.Hash(
"x", 2, "y", 2, "z", 2,
"time", 2f,
"delay", 4f,
"looptype", iTween.LoopType.none,
"easetype", iTween.EaseType.easeInOutSine
));
arrow.transform.parent = null;
arrow.transform.position = new Vector3(0, 0, 50);
vel = Vector2.zero;
form3Puppet.SetActive(false);
p = Phase.Phase4;
}
//1 == top, 2 == bottom, 3 == left, 4 == right.
int newSide = Random.Range(1, 4);
float z = 0f;
if (newSide == 1)
{
pos = new Vector3(Random.Range(45f, -45f), 30, z);
gotNewVel = false;
}
else if (newSide == 2)
{
pos = new Vector3(Random.Range(45f, -45f), -30, z);
gotNewVel = false;
}
else if (newSide == 3)
{
pos = new Vector3(-45f, Random.Range(-30f, 30f), z);
gotNewVel = false;
}
else if (newSide == 4)
{
pos = new Vector3(45f, Random.Range(-30f, 30f), z);
gotNewVel = false;
}
}
//Updating position and velocity.
rig.velocity = vel;
transform.position = pos;
}
else if (p == Phase.Phase4)
{
//Keeping position and velocity locked at zero.
transform.position = Vector3.zero;
rig.velocity = Vector2.zero;
//Vektor says a thing to keep the player distracted from Cotton's large appear time.
if (vektorText != null)
{
vektorText.SetActive(true);
}
//Total time it takes to do an attack.
totalMoveTime = (2f + 1f + 1.5f + 2f) + 1.1f;
//Constantly goes down, when it reaches 0, it picks a new target to attack from.
//The counter should be long enough to wait for one swipe attack to finish.
totalForm4Counter -= Time.deltaTime;
if (totalForm4Counter <= 0)
{
attackedForm4 = true;
arrow.GetComponent <LookAtScript>().enabled = true;
if (form4Attack < 3)
{
form4Attack++;
}
else
{
form4Attack = 0;
}
float z = 0;
if (form4Attack == 0)
{
startPos = new Vector3(-90, 0, z); midPos = new Vector3(-75, 0, z); targetPos = new Vector3(-24, 0, z); facePos = new Vector3(0.45f, 0f, -2f);
} //Left
else if (form4Attack == 1)
{
startPos = new Vector3(90, 0, z); midPos = new Vector3(75, 0, z); targetPos = new Vector3(24, 0, z); facePos = new Vector3(-0.45f, 0f, -2f);
} //Right
else if (form4Attack == 2)
{
startPos = new Vector3(0, 73, z); midPos = new Vector3(0, 62, z); targetPos = new Vector3(0, 37, z); facePos = new Vector3(0f, -0.47f, -2f);
} //Up
else if (form4Attack == 3)
{
startPos = new Vector3(0, -73, z); midPos = new Vector3(0, -62, z); targetPos = new Vector3(0, -37, z); facePos = new Vector3(0f, 0.47f, -2f);
} //Down
form4Face.transform.localPosition = facePos;
form4Body.transform.localPosition = startPos;
//Do the tweens!
iTween.MoveTo(form4Body, iTween.Hash("x", midPos.x, "y", midPos.y, "z", midPos.z, "time", form4ToStartTime, "looptype", iTween.LoopType.none, "easeType", iTween.EaseType.easeInOutSine));
iTween.MoveTo(form4Body, iTween.Hash("x", targetPos.x, "y", targetPos.y, "z", targetPos.z, "time", form4SwipeTime, "delay", (form4ToStartTime + 1.5f), "looptype", iTween.LoopType.none, "easeType", iTween.EaseType.easeOutBounce));
iTween.MoveTo(form4Body, iTween.Hash("x", startPos.x, "y", startPos.y, "z", startPos.z, "time", form4BackTime, "delay", (form4ToStartTime + 1.5f + form4SwipeTime), "looptype", iTween.LoopType.none, "easeType", iTween.EaseType.easeInOutSine));
//Enable the form holder and allow for box management.
form4Holder.SetActive(true);
allowForm4HitboxManagement = true;
totalForm4Counter = totalMoveTime;
}
//Manage the outer walls!
if (form4Attack == 1 || attackedForm4)
{
leftWallPos = new Vector3(0f, 0f, 10f);
}
else
{
leftWallPos = new Vector3(-20f, 0f, 10f);
}
if (form4Attack == 0 || attackedForm4)
{
rightWallPos = new Vector3(0f, 0f, 10f);
}
else
{
rightWallPos = new Vector3(20f, 0f, 10f);
}
if (form4Attack == 3 || attackedForm4)
{
upWallPos = new Vector3(0f, 0f, 10f);
}
else
{
upWallPos = new Vector3(0f, 20f, 10f);
}
if (form4Attack == 2 || attackedForm4)
{
downWallPos = new Vector3(0f, 0f, 10f);
}
else
{
downWallPos = new Vector3(0f, -20f, 10f);
}
float wallSmooth = 2f;
leftWall.transform.position = Vector3.Lerp(leftWall.transform.position, leftWallPos, wallSmooth * Time.deltaTime);
rightWall.transform.position = Vector3.Lerp(rightWall.transform.position, rightWallPos, wallSmooth * Time.deltaTime);
upWall.transform.position = Vector3.Lerp(upWall.transform.position, upWallPos, wallSmooth * Time.deltaTime);
downWall.transform.position = Vector3.Lerp(downWall.transform.position, downWallPos, wallSmooth * Time.deltaTime);
//Play laugh sound if it hasn't played already.
if (!playedLaughSnd)
{
PlaySound.NoLoop(laughSnd);
playedLaughSnd = true;
}
//Managing the hitbox for Phase 4.
hitBox.enabled = allowForm4HitboxManagement;
if (allowForm4HitboxManagement)
{
hitBox.offset = form4Body.transform.localPosition;
hitBox.size = form4Body.transform.localScale;
}
//Puppet color.
puppetToColor = form4Body;
//Color the poofies.
ParticleSystemRenderer dr = downPoof.GetComponent <ParticleSystemRenderer>();
ParticleSystemRenderer ur = upPoof.GetComponent <ParticleSystemRenderer>();
ParticleSystemRenderer lr = leftPoof.GetComponent <ParticleSystemRenderer>();
ParticleSystemRenderer rr = rightPoof.GetComponent <ParticleSystemRenderer>();
dr.material.color = puppetToColor.GetComponent <MeshRenderer>().material.color;
ur.material.color = puppetToColor.GetComponent <MeshRenderer>().material.color;
lr.material.color = puppetToColor.GetComponent <MeshRenderer>().material.color;
rr.material.color = puppetToColor.GetComponent <MeshRenderer>().material.color;
}
}
else if (p == Phase.Death)
{
if (form4Holder != null)
{
Destroy(form4Holder);
}
hitBox.enabled = false;
victoryWaitTime -= Time.deltaTime;
if (victoryWaitTime < 0f)
{
Game.manager.GetComponent <GameManager>().victory = true;
}
}
}
// Update is called once per frame
void Start()
{
PSR = gameObject.GetComponent <ParticleSystemRenderer>();
//tempRend.sortingOrder = Mathf.Abs((int)transform.position.y) * -1;
Invoke("ChangeSortingOrder", 2);
}
public override void gaxb_complete()
{
if (systemName != null)
{
GameObject particleSystemGO = GameObject.Find(systemName);
if (particleSystemGO != null)
{
particleSystem = particleSystemGO.GetComponent <ParticleSystem> ();
particleRenderer = particleSystemGO.GetComponent <ParticleSystemRenderer> ();
shim.material = new Material(particleRenderer.material);
particleSystem.simulationSpace = ParticleSystemSimulationSpace.Local;
particleRenderer.enabled = false;
designedMaxParticles = particleSystem.maxParticles;
// create the LUTs for less CPU usages during mesh generation
for (int i = 0; i < lutMax; i++)
{
colorLUT [i] = particleSystem.startColor;
sizeLUT [i] = particleSystem.startSize * 0.5f;
}
// support changing color over lifetime
if (particleSystem.colorOverLifetime.enabled)
{
for (int i = 0; i < lutMax; i++)
{
colorLUT [i] = particleSystem.colorOverLifetime.color.Evaluate(1.0f - (float)i / (float)lutMax);
}
}
// support changing size over lifetime
if (particleSystem.sizeOverLifetime.enabled)
{
for (int i = 0; i < lutMax; i++)
{
sizeLUT [i] = particleSystem.sizeOverLifetime.size.Evaluate(1.0f - (float)i / (float)lutMax) * 0.5f;
}
}
// prepare texture sheet animation
textureSheetAnimation = particleSystem.textureSheetAnimation;
textureSheetAnimationFrames = 0;
textureSheedAnimationFrameSize = Vector2.zero;
if (textureSheetAnimation.enabled)
{
textureSheetAnimationFrames = textureSheetAnimation.numTilesX * textureSheetAnimation.numTilesY;
textureSheedAnimationFrameSize = new Vector2(1f / textureSheetAnimation.numTilesX, 1f / textureSheetAnimation.numTilesY);
// support texture sheet animations changing over lifetime
for (int i = 0; i < lutMax; i++)
{
float frameProgress = (float)i / (float)lutMax;
frameProgress = Mathf.Repeat((1.0f - frameProgress) * textureSheetAnimation.cycleCount, 1);
int frame = 0;
switch (textureSheetAnimation.animation)
{
case ParticleSystemAnimationType.WholeSheet:
frame = Mathf.FloorToInt(frameProgress * textureSheetAnimationFrames);
break;
case ParticleSystemAnimationType.SingleRow:
frame = Mathf.FloorToInt(frameProgress * textureSheetAnimation.numTilesX);
int row = textureSheetAnimation.rowIndex;
frame += row * textureSheetAnimation.numTilesX;
break;
}
frame %= textureSheetAnimationFrames;
float x = (frame % textureSheetAnimation.numTilesX) * textureSheedAnimationFrameSize.x;
float y = Mathf.FloorToInt(frame / textureSheetAnimation.numTilesX) * textureSheedAnimationFrameSize.y;
float x2 = x + textureSheedAnimationFrameSize.x;
float y2 = y - textureSheedAnimationFrameSize.y;
sheetLUT [i] = new Vector4(x, y, x2, y2);
}
}
// If we have one of our custom UI emitters, then fill the positionLUT to allow quick spawning
UpdatePositionTable();
autoEvent = new AutoResetEvent(false);
workerThread = new Thread(ParticleThread);
workerThread.Name = "PUParticles";
workerThread.Start();
}
}
ScheduleForUpdate();
// If we emit particles ourselves, we need to clear any particles which the system may have already spawned
if (emitMode == PlanetUnity2.ParticleEmitMode.Edge ||
emitMode == PlanetUnity2.ParticleEmitMode.Center ||
emitMode == PlanetUnity2.ParticleEmitMode.Fill ||
emitMode == PlanetUnity2.ParticleEmitMode.Image)
{
particleSystem.enableEmission = false;
particleSystem.Clear(true);
}
}
protected bool Initialize()
{
// initialize members
if (_transform == null)
{
_transform = transform;
}
// prepare particle system
ParticleSystemRenderer renderer = GetComponent <ParticleSystemRenderer>();
bool setParticleSystemMaterial = false;
if (_particleSystem == null)
{
_particleSystem = GetComponent <ParticleSystem>();
if (_particleSystem == null)
{
return(false);
}
// get current particle texture
if (renderer == null)
{
renderer = _particleSystem.gameObject.AddComponent <ParticleSystemRenderer>();
}
Material currentMaterial = renderer.sharedMaterial;
if (currentMaterial && currentMaterial.HasProperty("_MainTex"))
{
particleTexture = currentMaterial.mainTexture;
}
// automatically set scaling
ParticleSystem.MainModule main = _particleSystem.main;
main.scalingMode = ParticleSystemScalingMode.Local;
_particles = null;
setParticleSystemMaterial = true;
}
else
{
if (Application.isPlaying)
{
setParticleSystemMaterial = (renderer.material == null);
}
#if UNITY_EDITOR
else
{
setParticleSystemMaterial = (renderer.sharedMaterial == null);
}
#endif
}
// automatically set material to UI/Particles/Hidden shader, and get previous texture
if (setParticleSystemMaterial)
{
Material material = new Material(Shader.Find("UI/Particles/Hidden"));
if (Application.isPlaying)
{
renderer.material = material;
}
#if UNITY_EDITOR
else
{
material.hideFlags = HideFlags.DontSave;
renderer.sharedMaterial = material;
}
#endif
}
// prepare particles array
if (_particles == null)
{
ParticleSystem.MainModule main = _particleSystem.main;
_particles = new ParticleSystem.Particle[main.maxParticles];
}
// prepare uvs
if (particleTexture)
{
_uv = new Vector4(0, 0, 1, 1);
}
else if (particleSprite)
{
_uv = UnityEngine.Sprites.DataUtility.GetOuterUV(particleSprite);
}
// prepare texture sheet animation
_textureSheetAnimation = _particleSystem.textureSheetAnimation;
_textureSheetAnimationFrames = 0;
_textureSheedAnimationFrameSize = Vector2.zero;
if (_textureSheetAnimation.enabled)
{
_textureSheetAnimationFrames = _textureSheetAnimation.numTilesX * _textureSheetAnimation.numTilesY;
_textureSheedAnimationFrameSize = new Vector2(1f / _textureSheetAnimation.numTilesX, 1f / _textureSheetAnimation.numTilesY);
}
return(true);
}
protected bool Initialize()
{
// initialize members
if (_transform == null)
{
_transform = transform;
}
if (pSystem == null)
{
pSystem = GetComponent <ParticleSystem>();
if (pSystem == null)
{
return(false);
}
#if UNITY_5_5_OR_NEWER
mainModule = pSystem.main;
if (pSystem.main.maxParticles > 14000)
{
mainModule.maxParticles = 14000;
}
#else
if (pSystem.maxParticles > 14000)
{
pSystem.maxParticles = 14000;
}
#endif
pRenderer = pSystem.GetComponent <ParticleSystemRenderer>();
if (pRenderer != null)
{
pRenderer.enabled = false;
}
if (material == null)
{
var foundShader = Shader.Find("UI Extensions/Particles/Additive");
if (foundShader)
{
material = new Material(foundShader);
}
}
currentMaterial = material;
if (currentMaterial && currentMaterial.HasProperty("_MainTex"))
{
currentTexture = currentMaterial.mainTexture;
if (currentTexture == null)
{
currentTexture = Texture2D.whiteTexture;
}
}
material = currentMaterial;
// automatically set scaling
#if UNITY_5_5_OR_NEWER
mainModule.scalingMode = ParticleSystemScalingMode.Hierarchy;
#else
pSystem.scalingMode = ParticleSystemScalingMode.Hierarchy;
#endif
particles = null;
}
#if UNITY_5_5_OR_NEWER
if (particles == null)
{
particles = new ParticleSystem.Particle[pSystem.main.maxParticles];
}
#else
if (particles == null)
{
particles = new ParticleSystem.Particle[pSystem.maxParticles];
}
#endif
imageUV = new Vector4(0, 0, 1, 1);
// prepare texture sheet animation
textureSheetAnimation = pSystem.textureSheetAnimation;
textureSheetAnimationFrames = 0;
textureSheetAnimationFrameSize = Vector2.zero;
if (textureSheetAnimation.enabled)
{
textureSheetAnimationFrames = textureSheetAnimation.numTilesX * textureSheetAnimation.numTilesY;
textureSheetAnimationFrameSize = new Vector2(1f / textureSheetAnimation.numTilesX, 1f / textureSheetAnimation.numTilesY);
}
return(true);
}
public void Init()
{
mCanvas = this.gameObject.GetComponent <CanvasGroup>();
mSprite = gameObject.GetComponent <SpriteRenderer>();
mMesh = this.gameObject.GetComponent <MeshRenderer>();
mTexture = this.gameObject.GetComponent <GUITexture>();
mText = this.gameObject.GetComponent <GUIText>();
mTextMesh = this.gameObject.GetComponent <TextMesh>();
mTextUI = this.gameObject.GetComponent <Text>();
mImageUI = this.gameObject.GetComponent <Image>();
mParticle = this.gameObject.GetComponent <ParticleSystemRenderer>();
if (mTexture == null && mMesh == null && mText == null && mTextMesh == null && mTextUI == null && mImageUI == null && mCanvas == null && mSprite == null)
{
throw new UnityException("Incorrect usage of SCFade. Apply it to Uni2DSprite, GUITexture, GUIText, EasyFontTextMesh, Text, Image, Canvas objects! Object name is " + gameObject.name);
}
else if (mCanvas)
{
mType = Type.Canvas;
fadeValue = mCanvas.alpha;
}
else if (mTexture)
{
mType = Type.GUITexture;
fadeValue = mTexture.color.a * 2;
}
else if (mSprite)
{
mType = Type.SpriteRenderer;
fadeValue = mSprite.color.a;
}
else if (mText)
{
mType = Type.GUIText;
fadeValue = mText.color.a;
}
else if (mTextMesh)
{
mType = Type.TextMesh;
fadeValue = mTextMesh.color.a;
}
else if (mTextUI)
{
mType = Type.Text;
fadeValue = mTextUI.color.a;
}
else if (mImageUI)
{
mType = Type.Image;
fadeValue = mImageUI.color.a;
}
else if (mMesh)
{
mType = Type.MeshRenderer;
fadeValue = mMesh.material.GetColor("_TintColor").a;
}
else if (mParticle)
{
mType = Type.Particle;
fadeValue = mParticle.material.GetColor("_TintColor").a;
}
}
IEnumerator PlayEffectFrame()
{
while (playedIndex < source.frames.Count)
{
//某帧锁定
if (pause)
{
yield return(0);
continue;
}
if (playedTime < source.frames[0].startTime && mRender.enabled)
{
mRender.enabled = false;
}
else if (playedTime >= source.frames[0].startTime && !mRender.enabled && source.Hidden == 0)
{
mRender.enabled = true;
}
while (playedTime < source.frames[0].startTime)
{
yield return(0);
}
float timeRatio2 = (playedTime - source.frames[playedIndex - 1].startTime) / (source.frames[playedIndex].startTime - source.frames[playedIndex - 1].startTime);
string vertexColor = "_TintColor";
if (source.BlendType == 2)
{
vertexColor = "_InvColor";
}
if (source.EffectType == "BOX")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.localScale = new Vector3(source.origScale.x * source.frames[playedIndex - 1].scale.x, source.origScale.y * source.frames[playedIndex - 1].scale.y, source.origScale.z * source.frames[playedIndex - 1].scale.z);
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.localScale = Vector3.Lerp(new Vector3(source.origScale.x * source.frames[playedIndex - 1].scale.x, source.origScale.y * source.frames[playedIndex - 1].scale.y, source.origScale.z * source.frames[playedIndex - 1].scale.z), new Vector3(source.origScale.x * source.frames[playedIndex].scale.x, source.origScale.y * source.frames[playedIndex].scale.y, source.origScale.z * source.frames[playedIndex].scale.z), timeRatio2);
}
}
else if (source.EffectType == "CYLINDER")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.localScale = source.frames[playedIndex - 1].scale;
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
}
//if (source.frames[playedIndex].startTime <= playedTime)
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = source.frames[playedIndex].quat;
// if (PositionFollow != null)
// transform.position = PositionFollow.position + source.frames[playedIndex].pos;
// else
// transform.position = source.frames[playedIndex].pos;
// transform.localScale = source.frames[playedIndex].scale;
// mRender.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
// mRender.material.SetColor(vertexColor, source.frames[playedIndex].colorRGB);
// playedIndex++;
//}
//else
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// else
// transform.rotation = Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// if (PositionFollow != null)
// transform.position = PositionFollow.position + Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// else
// transform.position = Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
// mRender.material.SetFloat("_Intensity", Mathf.Lerp(source.frames[playedIndex - 1].TailFlags[9], source.frames[playedIndex].TailFlags[9], timeRatio2));
// mRender.material.SetColor(vertexColor, Color.Lerp(source.frames[playedIndex - 1].colorRGB, source.frames[playedIndex].colorRGB, timeRatio2));
//}
}
else if (source.EffectType == "PLANE")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.localScale = source.frames[playedIndex - 1].scale;
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
}
//if (source.frames[playedIndex].startTime <= playedTime)
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = source.frames[playedIndex].quat;
// if (PositionFollow != null)
// transform.position = PositionFollow.position + source.frames[playedIndex].pos;
// else
// transform.position = source.frames[playedIndex].pos;
// transform.localScale = new Vector3(source.origScale.x * source.frames[playedIndex].scale.x, source.origScale.y * source.frames[playedIndex].scale.y, source.origScale.z * source.frames[playedIndex].scale.z);
// mRender.material.SetColor(vertexColor, source.frames[playedIndex].colorRGB);
// mRender.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
// playedIndex++;
//}
//else
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// else
// transform.rotation = Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// if (PositionFollow != null)
// transform.localPosition = PositionFollow.position + Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// else
// transform.position = Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// transform.localScale = Vector3.Lerp(new Vector3(source.origScale.x * source.frames[playedIndex - 1].scale.x, source.origScale.y * source.frames[playedIndex - 1].scale.y, source.origScale.z * source.frames[playedIndex - 1].scale.z), new Vector3(source.origScale.x * source.frames[playedIndex].scale.x, source.origScale.y * source.frames[playedIndex].scale.y, source.origScale.z * source.frames[playedIndex].scale.z), timeRatio2);
// mRender.material.SetFloat("_Intensity", Mathf.Lerp(source.frames[playedIndex - 1].TailFlags[9], source.frames[playedIndex].TailFlags[9], timeRatio2));
// mRender.material.SetColor(vertexColor, Color.Lerp(source.frames[playedIndex - 1].colorRGB, source.frames[playedIndex].colorRGB, timeRatio2));
//}
}
else if (source.EffectType == "SPHERE")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.localScale = source.frames[playedIndex - 1].scale;
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.localScale = Vector3.Slerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
}
//if (source.frames[playedIndex].startTime <= playedTime)
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = source.frames[playedIndex].quat;
// if (source.localSpace == 1)
// {
// if (RotateFollow != null)
// {
// Vector3 targetPos = RotateFollow.TransformPoint(source.frames[playedIndex].pos) - RotateFollow.position;
// if (PositionFollow != null)
// transform.position = PositionFollow.position + targetPos;
// else
// transform.position = targetPos;
// }
// }
// else
// {
// if (PositionFollow != null)
// transform.position = PositionFollow.position + source.frames[playedIndex].pos;
// else
// transform.position = source.frames[playedIndex].pos;
// }
// //if (PositionFollow != null)
// // transform.position = PositionFollow.position + source.frames[playedIndex].pos;
// //else
// // transform.position = source.frames[playedIndex].pos;
// transform.localScale = source.frames[playedIndex].scale;
// mRender.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
// mRender.material.SetColor(vertexColor, source.frames[playedIndex].colorRGB);
// playedIndex++;
//}
//else
//{
// //旋转用球面插值
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// else
// transform.rotation = Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// if (source.localSpace == 1)
// {
// if (RotateFollow != null)
// {
// Vector3 targetPos = RotateFollow.TransformPoint(Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2)) - RotateFollow.position;
// if (PositionFollow != null)
// transform.position = PositionFollow.position + targetPos;
// else
// transform.position = targetPos;
// }
// }
// else
// {
// if (PositionFollow != null)
// transform.position = PositionFollow.position + Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// else
// transform.position = Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// }
// ////移动用直线插值，
// //if (PositionFollow != null)
// // transform.position = PositionFollow.position + Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// //else
// // transform.localPosition = Vector3.Lerp(source.frames[playedIndex - 1].pos , source.frames[playedIndex].pos, timeRatio2);
// transform.localScale = Vector3.Slerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
// mRender.material.SetFloat("_Intensity", Mathf.Lerp(source.frames[playedIndex - 1].TailFlags[9], source.frames[playedIndex].TailFlags[9], timeRatio2));
// mRender.material.SetColor(vertexColor, Color.Lerp(source.frames[playedIndex - 1].colorRGB, source.frames[playedIndex].colorRGB, timeRatio2));
//}
}
else if (source.EffectType == "BILLBOARD")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.LookAt(Camera.main.transform);
transform.localScale = new Vector3(source.origScale.x * source.frames[playedIndex - 1].scale.x, source.origScale.y * source.frames[playedIndex - 1].scale.y, source.origScale.z * source.frames[playedIndex - 1].scale.z);
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.LookAt(Camera.main.transform);
transform.localScale = Vector3.Lerp(new Vector3(source.origScale.x * source.frames[playedIndex - 1].scale.x, source.origScale.y * source.frames[playedIndex - 1].scale.y, source.origScale.z * source.frames[playedIndex - 1].scale.z), new Vector3(source.origScale.x * source.frames[playedIndex].scale.x, source.origScale.y * source.frames[playedIndex].scale.y, source.origScale.z * source.frames[playedIndex].scale.z), timeRatio2);
}
//if (source.frames[playedIndex].startTime <= playedTime)
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = source.frames[playedIndex].quat;
// if (source.localSpace == 1)
// {
// if (RotateFollow != null)
// {
// Vector3 targetPos = RotateFollow.TransformPoint(source.frames[playedIndex].pos) - RotateFollow.position;
// if (PositionFollow != null)
// transform.position = PositionFollow.position + targetPos;
// else
// transform.position = targetPos;
// }
// else
// Debug.LogError("缺少惯性坐标系骨骼");
// }
// else
// {
// if (PositionFollow != null)
// transform.position = PositionFollow.position + source.frames[playedIndex].pos;
// else
// transform.position = source.frames[playedIndex].pos;
// }
// transform.localScale = new Vector3(source.origScale.x * source.frames[playedIndex].scale.x, source.origScale.y * source.frames[playedIndex].scale.y, source.origScale.z * source.frames[playedIndex].scale.z);
// //transform.LookAt(Camera.main.transform);
// mRender.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
// mRender.material.SetColor(vertexColor, new Color(source.frames[playedIndex].colorRGB.r, source.frames[playedIndex].colorRGB.g, source.frames[playedIndex].colorRGB.b, source.frames[playedIndex].colorRGB.a));
// playedIndex++;
// //playedTime = 0.0f;
//}
//else
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = source.frames[playedIndex].quat;
// if (source.localSpace == 1)
// {
// if (PositionFollow != null)
// {
// Vector3 targetPos = RotateFollow.TransformPoint(Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2)) - RotateFollow.position;
// if (PositionFollow != null)
// transform.position = PositionFollow.position + targetPos;
// else
// transform.position = targetPos;
// }
// else
// Debug.LogError("缺少惯性坐标骨骼");
// }
// else
// {
// if (PositionFollow != null)
// transform.position = PositionFollow.position + Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// else
// transform.position = Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// }
// transform.localScale = Vector3.Lerp(new Vector3(source.origScale.x * source.frames[playedIndex - 1].scale.x, source.origScale.y * source.frames[playedIndex - 1].scale.y, source.origScale.z * source.frames[playedIndex - 1].scale.z), new Vector3(source.origScale.x * source.frames[playedIndex].scale.x, source.origScale.y * source.frames[playedIndex].scale.y, source.origScale.z * source.frames[playedIndex].scale.z), timeRatio2);
// //transform.LookAt(Camera.main.transform);
// mRender.material.SetFloat("_Intensity", Mathf.Lerp(source.frames[playedIndex - 1].TailFlags[9], source.frames[playedIndex].TailFlags[9], timeRatio2));
// mRender.material.SetColor(vertexColor, Color.Lerp(new Color(source.frames[playedIndex - 1].colorRGB.r, source.frames[playedIndex - 1].colorRGB.g, source.frames[playedIndex - 1].colorRGB.b, source.frames[playedIndex - 1].colorRGB.a), new Color(source.frames[playedIndex].colorRGB.r, source.frames[playedIndex].colorRGB.g, source.frames[playedIndex].colorRGB.b, source.frames[playedIndex].colorRGB.a), timeRatio2));
//}
}
else if (source.EffectType == "MODEL")
{
//第一帧开始时间为-1.表示无限时播放
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.localScale = source.frames[playedIndex - 1].scale;
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.localScale = Vector3.Slerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
}
}
else if (source.EffectType == "PARTICLE")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
//transform.localScale = source.frames[playedIndex - 1].scale;
ParticleSystemRenderer render = particle.GetComponent <ParticleSystemRenderer>();
render.material.SetColor("_Color", source.frames[playedIndex - 1].colorRGB);
render.material.SetColor(vertexColor, source.frames[playedIndex - 1].colorRGB);
//粒子不要设置强度了，原版本的粒子实现和UNITY的不一样render.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
particle.Emit(1);
//particle.Simulate();
playedIndex++;
//playedTime = 0.0f;
}
else
{
OnLastFrame(timeRatio2, vertexColor);
//transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
//ParticleSystemRenderer render = particle.GetComponent<ParticleSystemRenderer>();
//render.material.SetColor("_Color", new Color(source.frames[playedIndex].colorRGB.r, source.frames[playedIndex].colorRGB.g, source.frames[playedIndex].colorRGB.b, source.frames[playedIndex].colorRGB.a));
//render.material.SetColor(vertexColor, new Color(source.frames[playedIndex].colorRGB.r, source.frames[playedIndex].colorRGB.g, source.frames[playedIndex].colorRGB.b, source.frames[playedIndex].colorRGB.a));
//particle.Emit(1);
//render.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
}
}
else if (source.EffectType == "DONUT")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.localScale = source.frames[playedIndex - 1].scale;
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
}
//if (source.frames[playedIndex].startTime <= playedTime)
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = source.frames[playedIndex].quat;
// transform.localPosition = source.frames[playedIndex].pos;
// transform.localScale = source.frames[playedIndex].scale;
// mRender.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
// mRender.material.SetColor(vertexColor, source.frames[playedIndex].colorRGB);
// playedIndex++;
// //playedTime = 0.0f;
//}
//else
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// transform.localPosition = Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
// mRender.material.SetFloat("_Intensity", Mathf.Lerp(source.frames[playedIndex - 1].TailFlags[9], source.frames[playedIndex].TailFlags[9], timeRatio2));
// mRender.material.SetColor(vertexColor, Color.Lerp(source.frames[playedIndex - 1].colorRGB, source.frames[playedIndex].colorRGB, timeRatio2));
//}
}
else if (source.EffectType == "DRAG")
{
if (source.frames[playedIndex].startTime <= playedTime)
{
OnNewFrame(vertexColor);
transform.localScale = source.frames[playedIndex - 1].scale;
}
else
{
OnLastFrame(timeRatio2, vertexColor);
transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
}
//if (source.frames[playedIndex].startTime <= playedTime)
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// transform.rotation = source.frames[playedIndex].quat;
// transform.localPosition = source.frames[playedIndex].pos;
// transform.localScale = source.frames[playedIndex].scale;
// mRender.material.SetFloat("_Intensity", source.frames[playedIndex].TailFlags[9]);
// mRender.material.SetColor(vertexColor, source.frames[playedIndex].colorRGB);
// playedIndex++;
// //playedTime = 0.0f;
//}
//else
//{
// if (RotateFollow != null)
// transform.rotation = RotateFollow.rotation * source.frames[playedIndex].quat;
// else
// RotateFollow.transform.rotation = Quaternion.Slerp(source.frames[playedIndex - 1].quat, source.frames[playedIndex].quat, timeRatio2);
// transform.localPosition = Vector3.Lerp(source.frames[playedIndex - 1].pos, source.frames[playedIndex].pos, timeRatio2);
// transform.localScale = Vector3.Lerp(source.frames[playedIndex - 1].scale, source.frames[playedIndex].scale, timeRatio2);
// mRender.material.SetFloat("_Intensity", Mathf.Lerp(source.frames[playedIndex - 1].TailFlags[9], source.frames[playedIndex].TailFlags[9], timeRatio2));
// mRender.material.SetColor(vertexColor, Color.Lerp(source.frames[playedIndex - 1].colorRGB, source.frames[playedIndex].colorRGB, timeRatio2));
//}
}
yield return(0);
}
//?是循环还是删除
//playedIndex = 0;
//yield return 0;
PlayDone = true;
if (parentSfx != null)
{
parentSfx.OnPlayDone(this);
}
else
{
Destroy(gameObject);
}
yield break;
}
protected bool Initialize()
{
// initialize members
if (_transform == null)
{
_transform = transform;
}
if (_particleSystem == null)
{
_particleSystem = GetComponent <ParticleSystem>();
if (_particleSystem == null)
{
return(false);
}
// automatically set material to UI/Particles/Hidden shader, and get previous texture
ParticleSystemRenderer renderer = _particleSystem.GetComponent <ParticleSystemRenderer>();
if (renderer == null)
{
renderer = _particleSystem.gameObject.AddComponent <ParticleSystemRenderer>();
}
Material currentMaterial = renderer.sharedMaterial;
if (currentMaterial && currentMaterial.HasProperty("_MainTex"))
{
particleTexture = currentMaterial.mainTexture;
}
Material material = new Material(Shader.Find("Particles/Alpha Blended")); // TODO - You should create this discard shader
if (Application.isPlaying)
{
renderer.material = material;
}
#if UNITY_EDITOR
else
{
material.hideFlags = HideFlags.DontSave;
renderer.sharedMaterial = material;
}
#endif
// automatically set scaling
_particleSystem.scalingMode = ParticleSystemScalingMode.Hierarchy;
_particles = null;
}
if (_particles == null)
{
_particles = new ParticleSystem.Particle[_particleSystem.maxParticles];
}
// prepare uvs
if (particleTexture)
{
_uv = new Vector4(0, 0, 1, 1);
}
else if (particleSprite)
{
_uv = UnityEngine.Sprites.DataUtility.GetOuterUV(particleSprite);
}
// prepare texture sheet animation
_textureSheetAnimation = _particleSystem.textureSheetAnimation;
_textureSheetAnimationFrames = 0;
_textureSheedAnimationFrameSize = Vector2.zero;
if (_textureSheetAnimation.enabled)
{
_textureSheetAnimationFrames = _textureSheetAnimation.numTilesX * _textureSheetAnimation.numTilesY;
_textureSheedAnimationFrameSize = new Vector2(1f / _textureSheetAnimation.numTilesX, 1f / _textureSheetAnimation.numTilesY);
}
return(true);
}
//原粒子系统是右手坐标系的，转移到左手坐标系后非常多问题，特别是父子关系以及，跟随和子物体旋转叠加
public void Init(SfxEffect effect, SFXEffectPlay parent, int index, float timePlayed = 0.0f)
{
playedTime = timePlayed;
PlayDone = false;
transform.rotation = Quaternion.identity;
effectIndex = index;
parentSfx = parent;//当找不到跟随者的时候，向父询问其他特效是否包含此名称.
name = effect.EffectName;
EffectType = effect.EffectType;
//一个是跟随移动，一个是跟随旋转
mOwner = parent.GetComponent <MeteorUnit>();
source = effect;
if (effect.EffectType == "PARTICLE")
{
particle = Instantiate(Resources.Load <GameObject>("SFXParticles"), Vector3.zero, Quaternion.identity, transform).GetComponent <ParticleSystem>();
}
if (string.IsNullOrEmpty(effect.Bone0))
{
PositionFollow = mOwner == null ? parentSfx.transform : mOwner.transform;
}
else
if (effect.Bone0 == "ROOT")
{
PositionFollow = mOwner == null ? parent.transform : mOwner.ROOTNull;
}
else if (effect.Bone0 == "Character")//根骨骼上一级，角色，就是不随着b骨骼走，但是随着d_base走
{
PositionFollow = mOwner == null ? parent.transform: mOwner.RootdBase;
}
else
{
PositionFollow = FindFollowed(effect.Bone0);
}
if (string.IsNullOrEmpty(effect.Bone1))
{
RotateFollow = mOwner == null ? parent.transform : mOwner.transform;
}
else
if (effect.Bone1 == "ROOT")
{
RotateFollow = mOwner == null ? parent.transform : mOwner.ROOTNull;
}
else if (effect.Bone1 == "Character")
{
RotateFollow = mOwner == null ? parent.transform : mOwner.RootdBase;
}
else
{
RotateFollow = FindFollowed(effect.Bone1);
}
if (PositionFollow != null)
{
transform.position = PositionFollow.transform.position;
}
mRender = gameObject.GetComponent <MeshRenderer>();
mFilter = gameObject.GetComponent <MeshFilter>();
int meshIndex = -1;
if (effect.EffectType == "DONUT")
{
//Debug.LogError("find Donut Effect");
}
//部分模型是要绕X旋转270的，这样他的缩放，和移动，都只能靠自己
if (effect.EffectType == "PLANE")
{
meshIndex = 0;
}
else if (effect.EffectType == "BOX")
{
meshIndex = 1;
}
else if (effect.EffectType == "DONUT")
{
transform.localScale = effect.frames[0].scale;
meshIndex = 2;
}
else if (effect.EffectType == "MODEL")//自行加载模型
{
transform.localScale = effect.frames[0].scale;
transform.rotation = RotateFollow.rotation * effect.frames[0].quat;
transform.position = PositionFollow.position + effect.frames[0].pos;
if (!string.IsNullOrEmpty(effect.Tails[0]))
{
string[] des = effect.Tails[0].Split(new char[] { '\\' }, System.StringSplitOptions.RemoveEmptyEntries);
if (des.Length != 0)
{
WsGlobal.ShowMeteorObject(des[des.Length - 1], transform);
}
}
//这个时候,不要用自带的meshfilter了,让他自己处理显示问题,只要告诉他在哪个地方显示
meshIndex = 100;
}
else if (effect.EffectType == "SPHERE")
{
meshIndex = 3;
}
else if (effect.EffectType == "PARTICLE")
{
if (!string.IsNullOrEmpty(effect.Tails[0]))
{
PositionFollow = FindFollowed(effect.Tails[0]);
}
if (!string.IsNullOrEmpty(effect.Tails[1]))
{
RotateFollow = FindFollowed(effect.Tails[1]);
}
if (PositionFollow != null)
{
transform.position = PositionFollow.transform.position;
}
meshIndex = 101;
}
else if (effect.EffectType == "CYLINDER")
{
//InitializeQuat = new Quaternion(0.7170f, 0, 0, -0.7170f);
//InitializeQuat = Quaternion.identity;
meshIndex = 4;
}
else if (effect.EffectType == "BILLBOARD")
{
LookAtC = true;
meshIndex = 5;
}
else if (effect.EffectType == "DRAG")
{
meshIndex = 6;
}
//决定模型
if (meshIndex != -1 && meshIndex < mesh.Length)
{
if (meshIndex == 4)
{
mFilter.mesh = SfxMeshGenerator.Instance.CreateCylinder(source.origAtt.y, source.origAtt.x, source.origScale.x);
}
else if (meshIndex == 3)
{
mFilter.mesh = SfxMeshGenerator.Instance.CreateSphere(source.SphereScale);
}
else if (meshIndex == 0)
{
mFilter.mesh = SfxMeshGenerator.Instance.CreatePlane(source.origScale.x, source.origScale.y);
}
else
{
mFilter.mesh = mesh[meshIndex];
}
}
if (effect.Texture.ToLower().EndsWith(".bmp") || effect.Texture.ToLower().EndsWith(".jpg") || effect.Texture.ToLower().EndsWith(".tga"))
{
texture = effect.Texture.Substring(0, effect.Texture.Length - 4);
tex = Resources.Load <Texture>(texture);
}
else if (effect.Texture.ToLower().EndsWith(".ifl"))
{
iflTexture = gameObject.AddComponent <IFLLoader>();
iflTexture.IFLFile = Resources.Load <TextAsset>(effect.Texture);
if (effect.EffectType == "PARTICLE")
{
iflTexture.SetTargetMeshRenderer(particle.GetComponent <ParticleSystemRenderer>());
}
iflTexture.LoadIFL();//传递false表示由特效控制每一帧的切换时间.
tex = iflTexture.GetTexture(0);
}
//else
// print("effect contains other prefix:" + effect.Texture == null ? " texture is null" : effect.Texture);
if (tex != null)
{
if (effect.EffectType == "PARTICLE")
{
ParticleSystemRenderer render = particle.GetComponent <ParticleSystemRenderer>();
if (effect.BlendType == 0)
{
render.material.shader = Shader.Find("Unlit/Texture");//普通不透明无光照
}
else
if (effect.BlendType == 1)
{
render.material.shader = Shader.Find("UnlitAdditive");//滤色 加亮 不透明
}
else
if (effect.BlendType == 2)
{
render.material.shader = Shader.Find("UnlitAdditive");//反色+透明度
}
else if (effect.BlendType == 3)
{
render.material.shader = Shader.Find("Mobile/Particles/Alpha Blended");//不滤色,支持透明
}
else if (effect.BlendType == 4)
{
render.material.shader = Shader.Find("Custom/MeteorBlend4");//滤色，透明
}
else
{
render.material.shader = Shader.Find("Unlit/Texture");//普通不透明无光照
}
render.material.SetTexture("_MainTex", tex);
render.material.SetColor("_Color", effect.frames[0].colorRGB);
render.material.SetColor("_TintColor", effect.frames[0].colorRGB);
render.material.SetFloat("_Intensity", effect.frames[0].TailFlags[9]);
//particle.Emit(1);
}
else
{
if (effect.BlendType == 0)
{
mRender.material.shader = Shader.Find("Unlit/Texture");//普通不透明无光照
}
else
if (effect.BlendType == 1)
{
mRender.material.shader = Shader.Find("UnlitAdditive");//滤色 加亮 不透明
}
else
if (effect.BlendType == 2)
{
mRender.material.shader = Shader.Find("UnlitAdditive");//反色+透明度
}
else if (effect.BlendType == 3)
{
mRender.material.shader = Shader.Find("Mobile/Particles/Alpha Blended");//不滤色,支持透明
}
else if (effect.BlendType == 4)
{
mRender.material.shader = Shader.Find("Custom/MeteorBlend4");//滤色，透明
}
else
{
mRender.material.shader = Shader.Find("Unlit/Texture");//普通不透明无光照
}
if (effect.BlendType == 2)
{
mRender.material.SetColor("_InvColor", effect.frames[0].colorRGB);
}
else
{
mRender.material.SetColor("_Color", effect.frames[0].colorRGB);
mRender.material.SetColor("_TintColor", effect.frames[0].colorRGB);
}
mRender.material.SetFloat("_Intensity", effect.frames[0].TailFlags[9]);
mRender.material.SetTexture("_MainTex", tex);
if (effect.uSpeed != 0.0f || effect.vSpeed != 0.0f)
{
tex.wrapMode = TextureWrapMode.Repeat;
}
else
{
tex.wrapMode = TextureWrapMode.Clamp;
}
mRender.material.SetFloat("_u", effect.uSpeed);
mRender.material.SetFloat("_v", effect.vSpeed);
}
}
if (effect.Hidden == 1)
{
if (particle != null)
{
ParticleSystemRenderer render = particle.GetComponent <ParticleSystemRenderer>();
if (render != null)
{
render.enabled = false;
}
}
mRender.enabled = false;
}
if (effect.EffectName.StartsWith("Attack"))
{
if (effect.EffectType == "SPHERE")
{
damageBox = gameObject.AddComponent <SphereCollider>();
}
else
{
damageBox = gameObject.AddComponent <BoxCollider>();
}
damageBox.enabled = false;
}
playCoroutine = StartCoroutine(PlayEffectFrame());
}
public override void CopyParametersTo( ParticleSystemRenderer other )
{
BillboardParticleRenderer otherBpr = (BillboardParticleRenderer)other;
Debug.Assert( otherBpr != null );
otherBpr.BillboardType = this.BillboardType;
otherBpr.CommonUpVector = this.CommonUpVector;
otherBpr.CommonDirection = this.CommonDirection;
}
private void Awake()
{
particle = GetComponent <ParticleSystem>();
pr = GetComponent <ParticleSystemRenderer>();
}
public static void ParseBillboardType(string[] values, ParticleSystemRenderer _renderer)
{
if (values.Length != 1) {
ParseHelper.LogParserError("billboard_type", _renderer.Type, "Wrong number of parameters.");
return;
}
// lookup the real enum equivalent to the script value
object val = ScriptEnumAttribute.Lookup(values[0], typeof(BillboardType));
BillboardParticleRenderer renderer = (BillboardParticleRenderer)_renderer;
// if a value was found, assign it
if (val != null)
renderer.BillboardType = (BillboardType)val;
else
ParseHelper.LogParserError("billboard_type", _renderer.Type, "Invalid enum value");
}
// Use this for initialization
void Start()
{
ps = this.GetComponent <ParticleSystem>();
render = this.GetComponent <ParticleSystemRenderer>();
}
public static void ParseDepthOffset(string[] values, ParticleSystemRenderer _renderer)
{
if (values.Length != 1) {
ParseHelper.LogParserError("depth_offset", _renderer.Type, "Wrong number of parameters.");
return;
}
BillboardParticleRenderer renderer = (BillboardParticleRenderer)_renderer;
renderer.DepthOffset = StringConverter.ParseFloat(values[0]);
}
public override void OnLoad()
{
base.OnLoad();
itemDef.name = "MysticsItems_CrystalWorld";
SetItemTierWhenAvailable(ItemTier.Tier3);
itemDef.tags = new ItemTag[]
{
ItemTag.Damage,
ItemTag.Utility,
ItemTag.AIBlacklist,
ItemTag.CannotCopy
};
itemDef.pickupModelPrefab = PrepareModel(Main.AssetBundle.LoadAsset <GameObject>("Assets/Items/Crystal World/Model.prefab"));
itemDef.pickupIconSprite = Main.AssetBundle.LoadAsset <Sprite>("Assets/Items/Crystal World/Icon.png");
itemDef.pickupModelPrefab.AddComponent <CrystalWorldContainer>();
itemDisplayPrefab = PrepareItemDisplayModel(PrefabAPI.InstantiateClone(itemDef.pickupModelPrefab, itemDef.pickupModelPrefab.name + "Display", false));
onSetupIDRS += () =>
{
AddDisplayRule("CommandoBody", "Stomach", new Vector3(-0.17426F, 0.07766F, -0.05266F), new Vector3(16.68701F, 66.665F, 36.228F), new Vector3(0.042F, 0.042F, 0.042F));
AddDisplayRule("HuntressBody", "Muzzle", new Vector3(-0.1516F, -0.0345F, -0.09869F), new Vector3(355.162F, 32.177F, 180.96F), new Vector3(0.042F, 0.042F, 0.042F));
AddDisplayRule("Bandit2Body", "Stomach", new Vector3(0.19815F, 0.04837F, 0.02337F), new Vector3(350.191F, 244.703F, 340.178F), new Vector3(0.037F, 0.037F, 0.037F));
AddDisplayRule("ToolbotBody", "Chest", new Vector3(3.83001F, 1.891F, 0.03063F), new Vector3(29.795F, 9.384F, 2.716F), new Vector3(0.489F, 0.489F, 0.489F));
AddDisplayRule("EngiBody", "Chest", new Vector3(-0.20791F, 0.30973F, 0.18735F), new Vector3(4.991F, 46.464F, 181.437F), new Vector3(0.065F, 0.065F, 0.065F));
AddDisplayRule("EngiTurretBody", "Head", new Vector3(0F, 0.56045F, 0F), new Vector3(33.04002F, 48.09F, 359.072F), new Vector3(0.168F, 0.168F, 0.168F));
AddDisplayRule("EngiWalkerTurretBody", "Head", new Vector3(0F, 0.78124F, 0.82794F), new Vector3(22.677F, 152.024F, 24.393F), new Vector3(0.134F, 0.163F, 0.131F));
AddDisplayRule("MageBody", "Chest", new Vector3(0.06498F, 0.25775F, 0.30228F), new Vector3(0.366F, 347.899F, 165.881F), new Vector3(0.0827F, 0.0827F, 0.0827F));
AddDisplayRule("MercBody", "HandR", new Vector3(0.00372F, 0.11846F, 0.0863F), new Vector3(0F, 0F, 0F), new Vector3(0.07229F, 0.07229F, 0.07217F));
AddDisplayRule("TreebotBody", "FlowerBase", new Vector3(-0.45015F, 0.77395F, -0.18053F), new Vector3(0F, 0F, 0F), new Vector3(0.29135F, 0.29135F, 0.29135F));
AddDisplayRule("LoaderBody", "MechUpperArmL", new Vector3(0.07707F, 0.07703F, -0.00595F), new Vector3(7.628F, 218.893F, 342.184F), new Vector3(0.10413F, 0.10413F, 0.10413F));
AddDisplayRule("CrocoBody", "SpineChest2", new Vector3(-1.42325F, 2.10075F, 1.05927F), new Vector3(337.83F, 226.76F, 273.311F), new Vector3(0.411F, 0.411F, 0.411F));
AddDisplayRule("CaptainBody", "MuzzleGun", new Vector3(-0.0034F, 0.03444F, -0.31976F), new Vector3(0F, 0F, 0F), new Vector3(0.04057F, 0.03674F, 0.04057F));
AddDisplayRule("BrotherBody", "UpperArmL", new Vector3(0.02255F, -0.01451F, -0.00259F), new Vector3(303.36F, 82.77999F, 101.5723F), new Vector3(0.05297F, 0.08504F, 0.08504F));
AddDisplayRule("ScavBody", "UpperArmL", new Vector3(0.32551F, 0.61566F, 1.17648F), new Vector3(0F, 0F, 0F), new Vector3(2.65712F, 2.73031F, 2.65712F));
if (SoftDependencies.SoftDependenciesCore.itemDisplaysSniper)
{
AddDisplayRule("SniperClassicBody", "Chest", new Vector3(0.1151F, 0.32048F, -0.33018F), new Vector3(10.681F, 0.007F, 0.071F), new Vector3(0.07588F, 0.07588F, 0.07588F));
}
AddDisplayRule("RailgunnerBody", "Backpack", new Vector3(0.09864F, 0.17726F, -0.08467F), new Vector3(0F, 0F, 0F), new Vector3(0.09998F, 0.09998F, 0.09998F));
AddDisplayRule("VoidSurvivorBody", "Chest", new Vector3(0.36683F, 0.1762F, 0.00002F), new Vector3(0F, 0F, 0F), new Vector3(0.16615F, 0.16615F, 0.16615F));
};
ballPrefab = PrefabAPI.InstantiateClone(itemDef.pickupModelPrefab, "MysticsItems_CrystalWorldBall", false);
// DefaultDisplayRule("Head", new Vector3(0f, 0.5f, 0f), new Vector3(0f, -90f, 180f), new Vector3(0.2f, 0.2f, 0.2f));
/*
* How the world projection works:
* When a model (aka a World Container) is spawned in, a random Crystal World is also created at very distant coords
* Each Crystal World has a Camera that renders the World to a RenderTexture, with a custom skybox
* Each active camera has a Projector child that draws the RenderTexture as billboards where the Containers are right now, and outputs it into the final Projection RenderTexture
* Active cameras also have a Container Prerender component that sets every active container's inner display texture to the texture with projections
*/
// Register all worlds using the same code block
string[] worldsToLoad =
{
"Crystallize",
"In Circles"
};
foreach (string worldName in worldsToLoad)
{
GameObject world = Main.AssetBundle.LoadAsset <GameObject>("Assets/Items/Crystal World/Worlds/" + worldName + ".prefab");
GameObject cameraObject = world.transform.Find("CameraPivot").Find("Camera").gameObject;
cameraObject.AddComponent <CrystalWorldCamera>();
RenderTexture renderTexture = null;
if (!Main.isDedicatedServer)
{
renderTexture = new RenderTexture(1028, 1028, 0, RenderTextureFormat.ARGB32)
{
name = "Crystal World \"" + worldName + "\""
}
}
;
cameraObject.GetComponent <Camera>().targetTexture = renderTexture;
foreach (Transform worldObjectTransform in world.transform)
{
GameObject worldObject = worldObjectTransform.gameObject;
Renderer renderer = worldObject.GetComponent <MeshRenderer>();
if (renderer)
{
Material material = renderer.material;
if (material.shader.name == "Standard")
{
HopooShaderToMaterial.Standard.Apply(material);
HopooShaderToMaterial.Standard.DisableEverything(material);
}
}
}
// Run specific per-world code
switch (worldName)
{
case "Crystallize":
ParticleSystemRenderer snowRenderer = world.transform.Find("Snow").gameObject.GetComponent <ParticleSystemRenderer>();
Material snowMaterial = new Material(HopooShaderToMaterial.Standard.shader);
snowRenderer.material = snowMaterial;
HopooShaderToMaterial.Standard.Emission(snowMaterial, 2f, Color.white);
break;
}
worlds.Add(new WorldInfo
{
prefab = world,
shownInContainers = new List <GameObject>(),
renderTexture = renderTexture
});
}
On.RoR2.SceneCamera.Awake += (orig, self) =>
{
orig(self);
GameObject projector = new GameObject
{
name = "Crystal World Projector"
};
projector.transform.SetParent(self.transform);
projector.transform.localPosition = Vector3.zero;
projector.transform.localRotation = Quaternion.identity;
CrystalWorldProjector component = projector.AddComponent <CrystalWorldProjector>();
CrystalWorldContainerPrerender prerenderComponent = self.gameObject.AddComponent <CrystalWorldContainerPrerender>();
prerenderComponent.renderTexture = component.projectionRenderTexture;
};
pulsePrefab = Main.AssetBundle.LoadAsset <GameObject>("Assets/Items/Crystal World/Explosion.prefab");
EffectComponent effectComponent = pulsePrefab.AddComponent <EffectComponent>();
effectComponent.applyScale = true;
effectComponent.disregardZScale = false;
effectComponent.soundName = "Play_item_proc_iceRingSpear";
VFXAttributes vfxAttributes = pulsePrefab.AddComponent <VFXAttributes>();
vfxAttributes.vfxPriority = VFXAttributes.VFXPriority.Always;
vfxAttributes.vfxIntensity = VFXAttributes.VFXIntensity.Medium;
pulsePrefab.AddComponent <DestroyOnTimer>().duration = 1f;
GameObject ppHolder = pulsePrefab.transform.Find("PP").gameObject;
SphereCollider ppSphere = ppHolder.AddComponent <SphereCollider>();
ppSphere.radius = 60f;
ppSphere.isTrigger = true;
ppHolder.layer = LayerIndex.postProcess.intVal;
PostProcessVolume pp = ppHolder.AddComponent <PostProcessVolume>();
pp.blendDistance = 30f;
pp.isGlobal = false;
pp.weight = 0.2f;
pp.priority = 10;
PostProcessProfile ppProfile = ScriptableObject.CreateInstance <PostProcessProfile>();
ppProfile.name = "ppCrystalWorldExplosion";
ColorGrading colorGrading = ppProfile.AddSettings <ColorGrading>();
Color c = Color.white;
float intensity = 3f;
c.r *= intensity; c.g *= intensity; c.b *= intensity;
colorGrading.colorFilter.value = c;
colorGrading.colorFilter.overrideState = true;
colorGrading.saturation.value = -100f;
colorGrading.saturation.overrideState = true;
colorGrading.contrast.value = -100f;
colorGrading.contrast.overrideState = true;
pp.sharedProfile = ppProfile;
PostProcessDuration postProcessDuration = ppHolder.AddComponent <PostProcessDuration>();
postProcessDuration.ppVolume = pp;
postProcessDuration.ppWeightCurve = new AnimationCurve
{
keys = new Keyframe[]
{
new Keyframe(0f, 0.35f),
new Keyframe(1f, 0f)
}
};
postProcessDuration.maxDuration = 1f;
MysticsItemsContent.Resources.effectPrefabs.Add(pulsePrefab);
On.RoR2.HoldoutZoneController.Awake += (orig, self) =>
{
orig(self);
MysticsItemsCrystalWorldTeleporterEffect component = self.GetComponent <MysticsItemsCrystalWorldTeleporterEffect>();
if (!component)
{
component = self.gameObject.AddComponent <MysticsItemsCrystalWorldTeleporterEffect>();
switch (MysticsRisky2Utils.Utils.TrimCloneFromString(self.gameObject.name))
{
case "Teleporter1":
component.displayModel = true;
component.offset = new Vector3(0f, 3f, 0f);
break;
case "LunarTeleporter Variant":
component.displayModel = true;
component.offset = new Vector3(0f, 3f, 0f);
break;
}
}
};
}
public override void CopyParametersTo(ParticleSystemRenderer other)
{
BillboardParticleRenderer otherBpr = (BillboardParticleRenderer)other;
Debug.Assert(otherBpr != null);
otherBpr.BillboardType = this.BillboardType;
otherBpr.BillboardOrigin = this.BillboardOrigin;
otherBpr.CommonUpVector = this.CommonUpVector;
otherBpr.CommonDirection = this.CommonDirection;
otherBpr.DepthOffset = this.DepthOffset;
otherBpr.UseAccurateFacing = this.UseAccurateFacing;
}
void Start()
{
particleRenderer = GetComponent <ParticleSystemRenderer>();
}
public dynamic LoadComponent(Stream stream, int index, NotLoaded comp)
{
stream.Position = comp.offset;
try
{
switch (comp.classID1)
{
case UnityClassID.AnimationClip:
{
AnimationClip animationClip = new AnimationClip(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, animationClip, comp);
animationClip.LoadFrom(stream);
return animationClip;
}
case UnityClassID.Animator:
{
Animator animator = new Animator(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, animator, comp);
animator.LoadFrom(stream);
return animator;
}
case UnityClassID.AnimatorController:
{
AnimatorController animatorController = new AnimatorController(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, animatorController, comp);
animatorController.LoadFrom(stream);
return animatorController;
}
case UnityClassID.AssetBundle:
{
AssetBundle assetBundle = new AssetBundle(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, assetBundle, comp);
assetBundle.LoadFrom(stream);
return assetBundle;
}
case UnityClassID.AudioClip:
{
if (loadingReferencials)
{
return comp;
}
AudioClip ac = new AudioClip(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, ac, comp);
ac.LoadFrom(stream);
return ac;
}
case UnityClassID.AudioListener:
{
AudioListener audioListener = new AudioListener(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, audioListener, comp);
audioListener.LoadFrom(stream);
return audioListener;
}
case UnityClassID.AudioSource:
{
AudioSource audioSrc = new AudioSource(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, audioSrc, comp);
audioSrc.LoadFrom(stream);
return audioSrc;
}
case UnityClassID.Avatar:
{
if (loadingReferencials)
{
return comp;
}
Avatar avatar = new Avatar(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, avatar, comp);
avatar.LoadFrom(stream);
return avatar;
}
case UnityClassID.BoxCollider:
{
BoxCollider boxCol = new BoxCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, boxCol, comp);
boxCol.LoadFrom(stream);
return boxCol;
}
case UnityClassID.Camera:
{
Camera camera = new Camera(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, camera, comp);
camera.LoadFrom(stream);
return camera;
}
case UnityClassID.CapsuleCollider:
{
CapsuleCollider capsuleCol = new CapsuleCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, capsuleCol, comp);
capsuleCol.LoadFrom(stream);
return capsuleCol;
}
case UnityClassID.Cubemap:
{
Cubemap cubemap = new Cubemap(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, cubemap, comp);
cubemap.LoadFrom(stream);
Parser.Textures.Add(cubemap);
return cubemap;
}
case UnityClassID.EllipsoidParticleEmitter:
{
EllipsoidParticleEmitter ellipsoid = new EllipsoidParticleEmitter(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, ellipsoid, comp);
ellipsoid.LoadFrom(stream);
return ellipsoid;
}
case UnityClassID.FlareLayer:
{
FlareLayer flareLayer = new FlareLayer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, flareLayer, comp);
flareLayer.LoadFrom(stream);
return flareLayer;
}
case UnityClassID.Light:
{
Light light = new Light(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, light, comp);
light.LoadFrom(stream);
return light;
}
case UnityClassID.LinkToGameObject:
{
LinkToGameObject link = new LinkToGameObject(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, link, comp);
link.LoadFrom(stream);
return link;
}
case UnityClassID.LinkToGameObject223:
{
LinkToGameObject223 link = new LinkToGameObject223(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, link, comp);
link.LoadFrom(stream);
return link;
}
case UnityClassID.LinkToGameObject225:
{
LinkToGameObject225 link = new LinkToGameObject225(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, link, comp);
link.LoadFrom(stream);
return link;
}
case UnityClassID.GameObject:
{
GameObject gameObj = new GameObject(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, gameObj, comp);
gameObj.LoadFrom(stream);
return gameObj;
}
case UnityClassID.Material:
{
Material mat = new Material(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, mat, comp);
mat.LoadFrom(stream);
return mat;
}
case UnityClassID.Mesh:
{
if (loadingReferencials)
{
return comp;
}
Mesh mesh = new Mesh(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, mesh, comp);
mesh.LoadFrom(stream);
return mesh;
}
case UnityClassID.MeshCollider:
{
MeshCollider meshCol = new MeshCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, meshCol, comp);
meshCol.LoadFrom(stream);
return meshCol;
}
case UnityClassID.MeshFilter:
{
MeshFilter meshFilter = new MeshFilter(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, meshFilter, comp);
meshFilter.LoadFrom(stream);
return meshFilter;
}
case UnityClassID.MeshRenderer:
{
MeshRenderer meshRenderer = new MeshRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, meshRenderer, comp);
meshRenderer.LoadFrom(stream);
return meshRenderer;
}
default:
if (comp.classID2 == UnityClassID.MonoBehaviour)
{
if (Types.Count > 0)
{
MonoBehaviour monoBehaviour = new MonoBehaviour(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, monoBehaviour, comp);
monoBehaviour.LoadFrom(stream);
return monoBehaviour;
}
else
{
string message = comp.classID2 + " unhandled because of absence of Types in Cabinet (*.assets)";
if (!reported.Contains(message))
{
Report.ReportLog(message);
reported.Add(message);
}
return comp;
}
}
else
{
string message = "Unhandled class: " + comp.classID1 + "/" + comp.classID2;
if (!reported.Contains(message))
{
Report.ReportLog(message);
reported.Add(message);
}
}
break;
case UnityClassID.MonoScript:
{
if (loadingReferencials)
{
return comp;
}
MonoScript monoScript = new MonoScript(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, monoScript, comp);
monoScript.LoadFrom(stream);
return monoScript;
}
case UnityClassID.MultiLink:
{
MultiLink multi = new MultiLink(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, multi, comp);
multi.LoadFrom(stream);
return multi;
}
case UnityClassID.ParticleAnimator:
{
ParticleAnimator particleAnimator = new ParticleAnimator(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleAnimator, comp);
particleAnimator.LoadFrom(stream);
return particleAnimator;
}
case UnityClassID.ParticleRenderer:
{
ParticleRenderer particleRenderer = new ParticleRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleRenderer, comp);
particleRenderer.LoadFrom(stream);
return particleRenderer;
}
case UnityClassID.ParticleSystem:
{
ParticleSystem particleSystem = new ParticleSystem(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleSystem, comp);
particleSystem.LoadFrom(stream);
return particleSystem;
}
case UnityClassID.ParticleSystemRenderer:
{
ParticleSystemRenderer particleSystemRenderer = new ParticleSystemRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleSystemRenderer, comp);
particleSystemRenderer.LoadFrom(stream);
return particleSystemRenderer;
}
case UnityClassID.Projector:
{
Projector projector = new Projector(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, projector, comp);
projector.LoadFrom(stream);
return projector;
}
case UnityClassID.Rigidbody:
{
RigidBody rigidBody = new RigidBody(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, rigidBody, comp);
rigidBody.LoadFrom(stream);
return rigidBody;
}
case UnityClassID.Shader:
{
Shader shader = new Shader(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, shader, comp);
shader.LoadFrom(stream);
return shader;
}
case UnityClassID.SkinnedMeshRenderer:
{
SkinnedMeshRenderer sMesh = new SkinnedMeshRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, sMesh, comp);
sMesh.LoadFrom(stream);
return sMesh;
}
case UnityClassID.SphereCollider:
{
SphereCollider sphereCol = new SphereCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, sphereCol, comp);
sphereCol.LoadFrom(stream);
return sphereCol;
}
case UnityClassID.Sprite:
{
Sprite sprite = new Sprite(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, sprite, comp);
sprite.LoadFrom(stream);
return sprite;
}
case UnityClassID.SpriteRenderer:
{
SpriteRenderer spriteRenderer = new SpriteRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, spriteRenderer, comp);
spriteRenderer.LoadFrom(stream);
return spriteRenderer;
}
case UnityClassID.TextAsset:
{
if (loadingReferencials)
{
return comp;
}
TextAsset ta = new TextAsset(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, ta, comp);
ta.LoadFrom(stream);
return ta;
}
case UnityClassID.Texture2D:
{
if (loadingReferencials)
{
return comp;
}
Texture2D tex = new Texture2D(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, tex, comp);
tex.LoadFrom(stream);
Parser.Textures.Add(tex);
return tex;
}
case UnityClassID.Transform:
{
Transform trans = new Transform(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, trans, comp);
trans.LoadFrom(stream);
return trans;
}
}
}
catch
{
Report.ReportLog("Failed to load " + comp.classID1 + "/" + comp.classID2 + " PathID=" + comp.pathID);
foreach (NotLoaded notLoaded in RemovedList)
{
if (notLoaded == comp)
{
RemovedList.Remove(notLoaded);
Components.RemoveAt(index);
notLoaded.replacement = null;
Components.Insert(index, notLoaded);
break;
}
}
}
return null;
}
/// <summary>
/// 计算这个Unit的AABB
/// </summary>
/// <returns>false:无法计算出这个Unit的AABB</returns>
protected virtual bool CaculateAABB(bool isExporting, ref Bounds aabb)
{
Renderer[] renderers = transform.GetComponentsInChildren <Renderer>();
// 用来防止Encapsulate(new Bounds())
bool initializedAABB = false;
for (int iRenderer = 0; iRenderer < renderers.Length; iRenderer++)
{
Renderer iterRenderer = renderers[iRenderer];
if (iterRenderer is ParticleSystemRenderer)
{
continue;
}
if (initializedAABB)
{
aabb.Encapsulate(iterRenderer.bounds);
}
else
{
initializedAABB = true;
aabb = iterRenderer.bounds;
}
}
ParticleSystem[] particleSystems = transform.GetComponentsInChildren <ParticleSystem>();
for (int iParticle = 0; iParticle < particleSystems.Length; iParticle++)
{
ParticleSystem iterParticle = particleSystems[iParticle];
Bounds particleAABB;
// 只有导出时才计算粒子的AABB，否则只计算粒子的坐标
if (isExporting)
{
ParticleSystemRenderer iterRenderer = iterParticle.GetComponent <ParticleSystemRenderer>();
if (iterRenderer)
{
particleAABB = iterRenderer.bounds;
}
else
{
particleAABB = new Bounds(iterParticle.transform.position, Vector3.zero);
}
}
else
{
particleAABB = new Bounds(iterParticle.transform.position, Vector3.zero);
}
if (initializedAABB)
{
aabb.Encapsulate(particleAABB);
}
else
{
initializedAABB = true;
aabb = particleAABB;
}
}
return(initializedAABB);
}
