public override void OnInspectorGUI(ParticleSystem s)
{
if (RendererModuleUI.s_Texts == null)
{
RendererModuleUI.s_Texts = new RendererModuleUI.Texts();
}
RendererModuleUI.RenderMode intValue = (RendererModuleUI.RenderMode) this.m_RenderMode.intValue;
RendererModuleUI.RenderMode renderMode = (RendererModuleUI.RenderMode)ModuleUI.GUIPopup(RendererModuleUI.s_Texts.renderMode, this.m_RenderMode, RendererModuleUI.s_Texts.particleTypes);
if (renderMode == RendererModuleUI.RenderMode.Mesh)
{
EditorGUI.indentLevel++;
this.DoListOfMeshesGUI();
EditorGUI.indentLevel--;
if (intValue != RendererModuleUI.RenderMode.Mesh && this.m_Meshes[0].objectReferenceInstanceIDValue == 0)
{
this.m_Meshes[0].objectReferenceValue = Resources.GetBuiltinResource(typeof(Mesh), "Cube.fbx");
}
}
else if (renderMode == RendererModuleUI.RenderMode.Stretch3D)
{
EditorGUI.indentLevel++;
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.cameraSpeedScale, this.m_CameraVelocityScale);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.speedScale, this.m_VelocityScale);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.lengthScale, this.m_LengthScale);
EditorGUI.indentLevel--;
}
if (renderMode != RendererModuleUI.RenderMode.Mesh)
{
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.normalDirection, this.m_NormalDirection);
}
if (this.m_Material != null)
{
ModuleUI.GUIObject(RendererModuleUI.s_Texts.material, this.m_Material);
}
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.sortMode, this.m_SortMode, RendererModuleUI.s_Texts.sortTypes);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.sortingFudge, this.m_SortingFudge);
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.castShadows, this.m_CastShadows, this.m_CastShadows.enumDisplayNames);
using (new EditorGUI.DisabledScope(SceneView.IsUsingDeferredRenderingPath()))
{
ModuleUI.GUIToggle(RendererModuleUI.s_Texts.receiveShadows, this.m_ReceiveShadows);
}
if (renderMode != RendererModuleUI.RenderMode.Mesh)
{
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.minParticleSize, this.m_MinParticleSize);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.maxParticleSize, this.m_MaxParticleSize);
}
EditorGUILayout.Space();
EditorGUILayout.SortingLayerField(RendererModuleUI.s_Texts.sortingLayer, this.m_SortingLayerID, ParticleSystemStyles.Get().popup, ParticleSystemStyles.Get().label);
ModuleUI.GUIInt(RendererModuleUI.s_Texts.sortingOrder, this.m_SortingOrder);
if (renderMode == RendererModuleUI.RenderMode.Billboard)
{
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.space, this.m_RenderAlignment, RendererModuleUI.s_Texts.spaces);
}
ModuleUI.GUIVector3Field(RendererModuleUI.s_Texts.pivot, this.m_Pivot);
this.m_Probes.OnGUI(null, s.GetComponent <Renderer>(), true);
}
private void DoVertexStreamsGUI(RendererModuleUI.RenderMode renderMode)
{
this.m_NumTexCoords = 0;
this.m_TexCoordChannelIndex = 0;
this.m_HasTangent = false;
this.m_HasColor = false;
this.m_VertexStreamsList.DoLayoutList();
if (!this.m_ParticleSystemUI.multiEdit)
{
string text = "";
if (this.m_Material != null)
{
Material material = this.m_Material.objectReferenceValue as Material;
int texCoordChannelCount = this.m_NumTexCoords * 4 + this.m_TexCoordChannelIndex;
bool flag = false;
bool flag2 = false;
bool flag3 = false;
bool flag4 = this.m_ParticleSystemUI.m_ParticleSystems[0].CheckVertexStreamsMatchShader(this.m_HasTangent, this.m_HasColor, texCoordChannelCount, material, ref flag, ref flag2, ref flag3);
if (flag4)
{
text += "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 (flag)
{
text += "\n- TANGENT stream does not match.";
}
if (flag2)
{
text += "\n- COLOR stream does not match.";
}
if (flag3)
{
text += "\n- TEXCOORD streams do not match.";
}
}
}
int maxTexCoordStreams = this.m_ParticleSystemUI.m_ParticleSystems[0].GetMaxTexCoordStreams();
if (this.m_NumTexCoords > maxTexCoordStreams || (this.m_NumTexCoords == maxTexCoordStreams && this.m_TexCoordChannelIndex > 0))
{
if (text != "")
{
text += "\n\n";
}
string text2 = text;
text = string.Concat(new object[]
{
text2,
"Only ",
maxTexCoordStreams,
" TEXCOORD streams are supported."
});
}
if (renderMode == RendererModuleUI.RenderMode.Mesh)
{
ParticleSystemRenderer component = this.m_ParticleSystemUI.m_ParticleSystems[0].GetComponent <ParticleSystemRenderer>();
Mesh[] array = new Mesh[4];
int meshes = component.GetMeshes(array);
for (int i = 0; i < meshes; i++)
{
if (array[i].HasChannel(Mesh.InternalShaderChannel.TexCoord2))
{
if (text != "")
{
text += "\n\n";
}
text += "Meshes may only use a maximum of 2 input UV streams.";
}
}
}
if (text != "")
{
GUIContent gUIContent = EditorGUIUtility.TextContent(text);
EditorGUILayout.HelpBox(gUIContent.text, MessageType.Error, true);
}
}
}
public override void OnInspectorGUI(InitialModuleUI initial)
{
if (RendererModuleUI.s_Texts == null)
{
RendererModuleUI.s_Texts = new RendererModuleUI.Texts();
}
EditorGUI.BeginChangeCheck();
RendererModuleUI.RenderMode renderMode = (RendererModuleUI.RenderMode)ModuleUI.GUIPopup(RendererModuleUI.s_Texts.renderMode, this.m_RenderMode, RendererModuleUI.s_Texts.particleTypes, new GUILayoutOption[0]);
bool flag = EditorGUI.EndChangeCheck();
if (!this.m_RenderMode.hasMultipleDifferentValues)
{
if (renderMode == RendererModuleUI.RenderMode.Mesh)
{
EditorGUI.indentLevel++;
this.DoListOfMeshesGUI();
EditorGUI.indentLevel--;
if (flag && this.m_Meshes[0].objectReferenceInstanceIDValue == 0 && !this.m_Meshes[0].hasMultipleDifferentValues)
{
this.m_Meshes[0].objectReferenceValue = Resources.GetBuiltinResource(typeof(Mesh), "Cube.fbx");
}
}
else if (renderMode == RendererModuleUI.RenderMode.Stretch3D)
{
EditorGUI.indentLevel++;
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.cameraSpeedScale, this.m_CameraVelocityScale, new GUILayoutOption[0]);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.speedScale, this.m_VelocityScale, new GUILayoutOption[0]);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.lengthScale, this.m_LengthScale, new GUILayoutOption[0]);
EditorGUI.indentLevel--;
}
if (renderMode != RendererModuleUI.RenderMode.None)
{
if (renderMode != RendererModuleUI.RenderMode.Mesh)
{
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.normalDirection, this.m_NormalDirection, new GUILayoutOption[0]);
}
if (this.m_Material != null)
{
ModuleUI.GUIObject(RendererModuleUI.s_Texts.material, this.m_Material, new GUILayoutOption[0]);
}
}
}
bool flag2 = this.m_ParticleSystemUI.m_ParticleSystems.FirstOrDefault((ParticleSystem o) => o.trails.enabled) != null;
if (flag2 && this.m_TrailMaterial != null)
{
ModuleUI.GUIObject(RendererModuleUI.s_Texts.trailMaterial, this.m_TrailMaterial, new GUILayoutOption[0]);
}
if (!this.m_RenderMode.hasMultipleDifferentValues)
{
if (renderMode != RendererModuleUI.RenderMode.None)
{
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.sortMode, this.m_SortMode, RendererModuleUI.s_Texts.sortTypes, new GUILayoutOption[0]);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.sortingFudge, this.m_SortingFudge, new GUILayoutOption[0]);
if (renderMode != RendererModuleUI.RenderMode.Mesh)
{
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.minParticleSize, this.m_MinParticleSize, new GUILayoutOption[0]);
ModuleUI.GUIFloat(RendererModuleUI.s_Texts.maxParticleSize, this.m_MaxParticleSize, new GUILayoutOption[0]);
}
if (renderMode == RendererModuleUI.RenderMode.Billboard)
{
bool flag3 = this.m_ParticleSystemUI.m_ParticleSystems.FirstOrDefault((ParticleSystem o) => o.shape.alignToDirection) != null;
if (flag3)
{
using (new EditorGUI.DisabledScope(true))
{
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.space, 0, new string[]
{
RendererModuleUI.s_Texts.spaces[2]
}, new GUILayoutOption[0]);
}
GUIContent gUIContent = EditorGUIUtility.TextContent("Using Align to Direction in the Shape Module forces the system to be rendered using Local Billboard Alignment.");
EditorGUILayout.HelpBox(gUIContent.text, MessageType.Info, true);
}
else
{
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.space, this.m_RenderAlignment, RendererModuleUI.s_Texts.spaces, new GUILayoutOption[0]);
}
}
ModuleUI.GUIVector3Field(RendererModuleUI.s_Texts.pivot, this.m_Pivot, new GUILayoutOption[0]);
EditorGUI.BeginChangeCheck();
RendererModuleUI.s_VisualizePivot = ModuleUI.GUIToggle(RendererModuleUI.s_Texts.visualizePivot, RendererModuleUI.s_VisualizePivot, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetBool("VisualizePivot", RendererModuleUI.s_VisualizePivot);
}
if (ModuleUI.GUIToggle(RendererModuleUI.s_Texts.useCustomVertexStreams, this.m_UseCustomVertexStreams, new GUILayoutOption[0]))
{
this.DoVertexStreamsGUI(renderMode);
}
EditorGUILayout.Space();
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.castShadows, this.m_CastShadows, this.m_CastShadows.enumDisplayNames, new GUILayoutOption[0]);
using (new EditorGUI.DisabledScope(SceneView.IsUsingDeferredRenderingPath()))
{
ModuleUI.GUIToggle(RendererModuleUI.s_Texts.receiveShadows, this.m_ReceiveShadows, new GUILayoutOption[0]);
}
ModuleUI.GUIPopup(RendererModuleUI.s_Texts.motionVectors, this.m_MotionVectors, RendererModuleUI.s_Texts.motionVectorOptions, new GUILayoutOption[0]);
EditorGUILayout.SortingLayerField(RendererModuleUI.s_Texts.sortingLayer, this.m_SortingLayerID, ParticleSystemStyles.Get().popup, ParticleSystemStyles.Get().label);
ModuleUI.GUIInt(RendererModuleUI.s_Texts.sortingOrder, this.m_SortingOrder, new GUILayoutOption[0]);
}
}
List <ParticleSystemRenderer> list = new List <ParticleSystemRenderer>();
ParticleSystem[] particleSystems = this.m_ParticleSystemUI.m_ParticleSystems;
for (int i = 0; i < particleSystems.Length; i++)
{
ParticleSystem particleSystem = particleSystems[i];
list.Add(particleSystem.GetComponent <ParticleSystemRenderer>());
}
this.m_Probes.OnGUI(list.ToArray(), list.FirstOrDefault <ParticleSystemRenderer>(), true);
}
private void DoVertexStreamsGUI(RendererModuleUI.RenderMode renderMode)
{
Rect controlRect = ModuleUI.GetControlRect(13, new GUILayoutOption[0]);
GUI.Label(controlRect, RendererModuleUI.s_Texts.streams, ParticleSystemStyles.Get().label);
int num = 0;
for (int i = 0; i < RendererModuleUI.s_Texts.vertexStreams.Length; i++)
{
if ((this.m_VertexStreamMask.intValue & 1 << i) != 0)
{
bool flag = this.m_ParticleSystemUI.m_ParticleEffectUI.m_Owner is ParticleSystemInspector;
string text = (!flag) ? "TEX" : "TEXCOORD";
Rect position = new Rect(controlRect.x + EditorGUIUtility.labelWidth, controlRect.y, controlRect.width, controlRect.height);
if (RendererModuleUI.s_Texts.vertexStreamIsTexCoord[i])
{
GUI.Label(position, string.Concat(new object[]
{
RendererModuleUI.s_Texts.vertexStreams[i],
" (",
text,
num++,
", ",
RendererModuleUI.s_Texts.vertexStreamDataTypes[i],
")"
}), ParticleSystemStyles.Get().label);
}
else
{
GUI.Label(position, RendererModuleUI.s_Texts.vertexStreams[i] + " (" + RendererModuleUI.s_Texts.vertexStreamDataTypes[i] + ")", ParticleSystemStyles.Get().label);
}
position.x = controlRect.xMax - 12f;
controlRect = ModuleUI.GetControlRect(13, new GUILayoutOption[0]);
if (i == 0)
{
if (this.m_VertexStreamMask.intValue != (1 << RendererModuleUI.s_Texts.vertexStreams.Length) - 1)
{
position.x -= 2f;
position.y -= 2f;
if (EditorGUI.ButtonMouseDown(position, GUIContent.none, FocusType.Passive, "OL Plus"))
{
List <GUIContent> list = new List <GUIContent>();
for (int j = 0; j < RendererModuleUI.s_Texts.vertexStreams.Length; j++)
{
if ((this.m_VertexStreamMask.intValue & 1 << j) == 0)
{
list.Add(new GUIContent(RendererModuleUI.s_Texts.vertexStreams[j]));
}
}
GenericMenu genericMenu = new GenericMenu();
for (int k = 0; k < list.Count; k++)
{
GenericMenu arg_292_0 = genericMenu;
GUIContent arg_292_1 = list[k];
bool arg_292_2 = false;
if (RendererModuleUI.< > f__mg$cache0 == null)
{
RendererModuleUI.< > f__mg$cache0 = new GenericMenu.MenuFunction2(RendererModuleUI.SelectVertexStreamCallback);
}
arg_292_0.AddItem(arg_292_1, arg_292_2, RendererModuleUI.< > f__mg$cache0, new RendererModuleUI.StreamCallbackData(this.m_VertexStreamMask, list[k].text));
}
genericMenu.ShowAsContext();
Event.current.Use();
}
}
}
else if (ModuleUI.MinusButton(position))
{
this.m_VertexStreamMask.intValue &= ~(1 << i);
}
}
}
string text2 = "";
if (this.m_Material != null)
{
Material material = this.m_Material.objectReferenceValue as Material;
ParticleSystemVertexStreams particleSystemVertexStreams = this.m_ParticleSystemUI.m_ParticleSystem.CheckVertexStreamsMatchShader((ParticleSystemVertexStreams)this.m_VertexStreamMask.intValue, material);
if (particleSystemVertexStreams != ParticleSystemVertexStreams.None)
{
text2 += "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 ((particleSystemVertexStreams & ParticleSystemVertexStreams.Tangent) != ParticleSystemVertexStreams.None)
{
text2 += "\n- TANGENT stream does not match.";
}
if ((particleSystemVertexStreams & ParticleSystemVertexStreams.Color) != ParticleSystemVertexStreams.None)
{
text2 += "\n- COLOR stream does not match.";
}
if ((particleSystemVertexStreams & ParticleSystemVertexStreams.UV) != ParticleSystemVertexStreams.None)
{
text2 += "\n- TEXCOORD streams do not match.";
}
}
}
int maxTexCoordStreams = this.m_ParticleSystemUI.m_ParticleSystem.GetMaxTexCoordStreams();
if (num > maxTexCoordStreams)
{
if (text2 != "")
{
text2 += "\n\n";
}
string text3 = text2;
text2 = string.Concat(new object[]
{
text3,
"Only ",
maxTexCoordStreams,
" TEXCOORD streams are supported."
});
}
if (renderMode == RendererModuleUI.RenderMode.Mesh)
{
ParticleSystemRenderer component = this.m_ParticleSystemUI.m_ParticleSystem.GetComponent <ParticleSystemRenderer>();
Mesh[] array = new Mesh[4];
int meshes = component.GetMeshes(array);
for (int l = 0; l < meshes; l++)
{
if (array[l].HasChannel(Mesh.InternalShaderChannel.TexCoord2))
{
if (text2 != "")
{
text2 += "\n\n";
}
text2 += "Meshes may only use a maximum of 2 input UV streams.";
}
}
}
if (text2 != "")
{
GUIContent gUIContent = EditorGUIUtility.TextContent(text2);
EditorGUILayout.HelpBox(gUIContent.text, MessageType.Error, true);
}
}
