public Mesh(IntPtr data, UInt64 numVertices, List <uint> indices, ulong numIndices, Material material, Shader shader, VertexMode mode) { this.vertexMode = mode; this.material = material; this.shader = shader; this.numIndices = numIndices; IntPtr ptr = IntPtr.Zero; this.vertexBuffer = new VertexBuffer(data, numVertices, mode); PrintStatus('V', vertexBuffer.GET_BUFFER_ID(), ". vertexBuffer", 3, MESSAGE_COLOR); uint[] buffer = indices.ToArray(); unsafe { fixed(uint *p = buffer) { ptr = (IntPtr)p; this.indexBuffer = new IndexBuffer(ptr, numIndices, sizeof(int)); } } PrintStatus('I', indexBuffer.GET_BUFFER_ID(), ". indexBuffer", 5, MESSAGE_COLOR); this.diffuseLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_material.diffuse"); this.specularLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_material.specular"); this.emissiveLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_material.emissive"); this.shininessLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_material.shininess"); this.diffuseMapLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_diffuse_map"); this.normalMapLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_normal_map"); this.useNormalMapLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_use_normal_map"); this.useTexturesLocation = GL.GetUniformLocation(shader.GetShaderID(), "u_use_textures"); }
bool readFirstInfo() { if (this.fs == null) { return(false); } this.br = new BinaryReader(this.fs); this.bw = new BinaryWriter(this.fs); this.sizeOfVertex = this.br.ReadUInt64(); this.numMaterials = this.br.ReadUInt64(); this.sizeMaterial = System.Runtime.InteropServices.Marshal.SizeOf(typeof(BMFMaterial)); if (this.sizeOfVertex == (ulong)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VertexTextureAndNormal))) { this.vm = VertexMode.TextureAndNormal; } else if (this.sizeOfVertex == (ulong)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VertexTextureOnly))) { this.vm = VertexMode.TextureOnly; } else if (this.sizeOfVertex == (ulong)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VertexMaterialOnly))) { this.vm = VertexMode.MaterialOnly; } else { return(false); throw new Exception("No EnumCode"); } return(true); }
private void AssignMaterialSortIDs(RawList <SortItem> sortItems, RawList <VertexDrawItem> drawItems) { VertexDrawItem[] drawData = drawItems.Data; SortItem[] sortData = sortItems.Data; int count = sortItems.Count; for (int i = 0; i < sortData.Length; i++) { if (i >= count) { break; } int drawIndex = sortData[i].DrawItemIndex; int vertexTypeIndex = drawData[drawIndex].TypeIndex; VertexMode vertexMode = drawData[drawIndex].Mode; BatchInfo material = drawData[drawIndex].Material; int matHash; unchecked { // Avoid just "cutting off" parts of the original hash, // as this is likely to lead to collisions. matHash = material.GetHashCode(); matHash = (13 * matHash + 17 * (matHash >> 9)) % (1 << 23); } // Bit significance is used to achieve sorting by multiple traits at once. // The higher a traits bit significance, the higher its priority when sorting. sortData[i].SortIndex = (((int)vertexMode & 15) << 0) | // XXXX 4 Bit Vertex Mode Offset 4 ((matHash & 8388607) << 4) | // XXXXXXXXXXXXXXXXXXXXXXXaaaa 23 Bit Material Offset 27 ((vertexTypeIndex & 15) << 27); // XXXbbbbbbbbbbbbbbbbbbbbbbbaaaa 4 Bit Vertex Type Offset 31 } }
public DrawBatch(BatchInfo material, VertexMode vertexMode, T[] vertices, int vertexCount, float zSortIndex) { if (vertices == null || vertices.Length == 0) { throw new ArgumentException("A zero-vertex DrawBatch is invalid."); } // Assign data this.vertexCount = Math.Min(vertexCount, vertices.Length); this.vertices = vertices; this.material = material; this.vertexMode = vertexMode; this.zSortIndex = zSortIndex; // Determine sorting index for non-Z-Sort materials if (!this.material.Technique.Res.NeedsZSort) { int vTypeSI = vertices[0].TypeIndex; int matHash = this.material.GetHashCode() % (1 << 23); // Bit significancy is used to achieve sorting by multiple traits at once. // The higher a traits bit significancy, the higher its priority when sorting. this.sortIndex = (((int)vertexMode & 15) << 0) | // XXXX 4 Bit Vertex Mode Offset 4 ((matHash & 8388607) << 4) | // XXXXXXXXXXXXXXXXXXXXXXXaaaa 23 Bit Material Offset 27 ((vTypeSI & 15) << 27); // XXXbbbbbbbbbbbbbbbbbbbbbbbaaaa 4 Bit Vertex Type Offset 31 // Keep an eye on this. If for example two material hash codes randomly have the same 23 lower bits, they // will be sorted as if equal, resulting in blocking batch aggregation. } }
public Vertex(float x, float y, float u, float v) { Position = new Vector4(x, y, 0f, 1f); TexturePosition = new Vector2(u, v); BezierCoordinates = default(Vector2); Mode = VertexMode.Default; }
public DrawBatch(VertexBuffer buffer, RawList <VertexDrawRange> ranges, VertexMode mode, BatchInfo material) { this.vertexBuffer = buffer; this.vertexRanges = ranges; this.vertexMode = mode; this.material = material; }
public Vertex(Math.Vector2 position) { Position = new Vector4(position.X, position.Y, 0f, 1f); TexturePosition = default(Vector2); BezierCoordinates = default(Vector2); Mode = VertexMode.Default; }
public void AddToVertexDisplacement(string value, VertexMode vertexMode) { if (string.IsNullOrEmpty(value)) { return; } if (!m_dirtyPerVertexData) { OpenPerVertexHeader(true); } switch (vertexMode) { default: case VertexMode.Relative: { m_vertexData += "\t\t\t" + Constants.VertexShaderInputStr + ".vertex.xyz += " + value + ";\n"; } break; case VertexMode.Absolute: { m_vertexData += "\t\t\t" + Constants.VertexShaderInputStr + ".vertex.xyz = " + value + ";\n"; } break; } }
public DrawBatch(VertexDeclaration type, RawList <VertexDrawRange> ranges, VertexMode mode, BatchInfo material) { this.vertexType = type; this.vertexRanges = ranges; this.vertexMode = mode; this.material = material; }
public void AddVertices <T>(BatchInfo material, VertexMode vertexMode, T[] vertexBuffer, int vertexCount) where T : struct, IVertexData { if (vertexCount == 0) { return; } if (vertexBuffer == null || vertexBuffer.Length == 0) { return; } if (vertexCount > vertexBuffer.Length) { vertexCount = vertexBuffer.Length; } if (material == null) { material = Material.Checkerboard.Res.InfoDirect; } if (this.pickingIndex != 0) { ColorRgba clr = new ColorRgba((this.pickingIndex << 8) | 0xFF); for (int i = 0; i < vertexCount; ++i) { vertexBuffer[i].Color = clr; } material = new BatchInfo(material); material.Technique = DrawTechnique.Picking; if (material.Textures == null) { material.MainTexture = Texture.White; } } else if (material.Technique == null || !material.Technique.IsAvailable) { material = new BatchInfo(material); material.Technique = DrawTechnique.Solid; } // When rendering without depth writing, use z sorting everywhere - there's no real depth buffering! bool zSort = !this.DepthWrite || material.Technique.Res.NeedsZSort; List <IDrawBatch> buffer = zSort ? this.drawBufferZSort : this.drawBuffer; float zSortIndex = zSort ? DrawBatch <T> .CalcZSortIndex(vertexBuffer, vertexCount) : 0.0f; if (buffer.Count > 0 && buffer[buffer.Count - 1].CanAppendJIT <T>( zSort ? 1.0f / this.zSortAccuracy : 0.0f, zSortIndex, material, vertexMode)) { buffer[buffer.Count - 1].AppendJIT(vertexBuffer, vertexCount); } else { buffer.Add(new DrawBatch <T>(material, vertexMode, vertexBuffer, vertexCount, zSortIndex)); } ++this.numRawBatches; }
public static bool IsBatchableMode(this VertexMode mode) { return (mode == VertexMode.Lines || mode == VertexMode.Points || mode == VertexMode.Quads || mode == VertexMode.Triangles); }
public static bool IsVertexModeAppendable(VertexMode mode) { return (mode == VertexMode.Lines || mode == VertexMode.Points || mode == VertexMode.Quads || mode == VertexMode.Triangles); }
public Element Mesh(Point[] points, Color[] colors, int[] indices, VertexMode vertexMode = VertexMode.Triangles) { points = Utils.ToImage(_viewport, points); return(new ElementMesh { Owner = this, Points = points, Colors = colors, Indices = indices, VertexMode = vertexMode, }); }
public VertexBuffer(IntPtr data, ulong numVertices, VertexMode mode) { VAO_ = GL.GenVertexArray(); GL.BindVertexArray(VAO_); int size = 0; unsafe { switch (mode) { case VertexMode.TextureAndNormal: size = sizeof(VertexTextureAndNormal); break; case VertexMode.TextureOnly: size = sizeof(VertexTextureOnly); break; case VertexMode.MaterialOnly: size = sizeof(VertexMaterialOnly); break; default: break; } } //bind all to vio **- BUFFER_ID_ = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ArrayBuffer, BUFFER_ID_); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(numVertices * (uint)size), data, BufferUsageHint.StaticDraw); GL.EnableVertexAttribArray(0); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, size, Marshal.OffsetOf(typeof(VertexMaterialOnly), "position")); GL.EnableVertexAttribArray(1); GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, false, size, Marshal.OffsetOf(typeof(VertexMaterialOnly), "normal")); if (mode == VertexMode.TextureAndNormal) { GL.EnableVertexAttribArray(2); GL.VertexAttribPointer(2, 3, VertexAttribPointerType.Float, false, size, Marshal.OffsetOf(typeof(VertexTextureAndNormal), "tangent")); GL.EnableVertexAttribArray(3); GL.VertexAttribPointer(3, 3, VertexAttribPointerType.Float, false, size, Marshal.OffsetOf(typeof(VertexTextureAndNormal), "textureCord")); } else if (mode == VertexMode.TextureOnly) { GL.EnableVertexAttribArray(2); GL.VertexAttribPointer(3, 3, VertexAttribPointerType.Float, false, size, Marshal.OffsetOf(typeof(VertexTextureOnly), "textureCord")); } //bind all to vio -** GL.BindVertexArray(0); }
void ProcessNode(Node node, Scene scene, VertexMode mode) { for (int i = 0; i < node.MeshCount; i++) { Assimp.Mesh mesh = scene.Meshes[node.MeshIndices[i]]; ProcessMesh(mesh, scene, mode); } for (int i = 0; i < node.ChildCount; i++) { ProcessNode(node.Children[i], scene, mode); } }
public void DataToVBO(Vertex[] verts, int[] indices) { vertexFlags = VertexMode.UV1; // normaalit + uv AllocVBO(verts.Length, indices.Length); GL.BindBuffer(BufferTarget.ArrayBuffer, vertexID); GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)0, (IntPtr)(verts.Length * vertexSize), verts); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexID); GL.BufferSubData(BufferTarget.ElementArrayBuffer, (IntPtr)0, (IntPtr)(indices.Length * sizeof(int)), indices); Util.CheckGLError("VBO"); }
public void DataToVBO(Vertex[] vertices, ushort[] indices, VertexMode mode) { if (numOfIndices > 0) { Dispose(); } int size; vertexFlags = mode; numOfIndices = indices.Length; Vertex.Size = BlittableValueType.StrideOf(vertices); GL.GenBuffers(1, out vertexID); GL.BindBuffer(BufferTarget.ArrayBuffer, vertexID); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * Vertex.Size), vertices, usage); GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size); if (vertices.Length * BlittableValueType.StrideOf(vertices) != size) { Log.Error("DataToVBO: Vertex data not uploaded correctly"); } GL.GenBuffers(1, out indexID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexID); GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(ushort)), indices, usage); GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size); if (indices.Length * sizeof(short) != size) { throw new ApplicationException("DataToVBO: Element data not uploaded correctly"); } Shader = GLSLShader.Load(); if (Shader != null) { if (Settings.UseGL3) { GL.GenVertexArrays(1, out vaoID); GL.BindVertexArray(vaoID); } GL.BindBuffer(BufferTarget.ArrayBuffer, vertexID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexID); Shader.SetAttributes(); if (Settings.UseGL3) { GL.BindVertexArray(0); } } GLExt.CheckGLError("DataToVBO"); }
public MeshPreview() { _previewblock = new MaterialPropertyBlock(); _meshvertex = new List <Vector3>(); _meshnormals = new List <Vector3>(); _meshuvs = new List <Vector2>(); _meshtriangles = new List <int>(); _mesh = new Mesh(); _mesh.MarkDynamic(); _mesh.UploadMeshData(false); _vertexmode = VertexMode.None; _primarylist = new List <int>(); _secondarylist = new List <int>(); _primarytset = new HashSet <int>(); _secondarytset = new HashSet <int>(); _display = new PreviewAxiDisplay(); }
private static PrimitiveType GetOpenTKVertexMode(VertexMode mode) { switch (mode) { default: case VertexMode.Points: return(PrimitiveType.Points); case VertexMode.Lines: return(PrimitiveType.Lines); case VertexMode.LineStrip: return(PrimitiveType.LineStrip); case VertexMode.LineLoop: return(PrimitiveType.LineLoop); case VertexMode.Triangles: return(PrimitiveType.Triangles); case VertexMode.TriangleStrip: return(PrimitiveType.TriangleStrip); case VertexMode.TriangleFan: return(PrimitiveType.TriangleFan); } }
public override void Enable() { _vertexmode = VertexMode.None; InitializePreviewUtility(); _previewblock.Clear(); _meshvertex.Clear(); _meshnormals.Clear(); _meshuvs.Clear(); _meshtriangles.Clear(); _mesh.Clear(); _mesh.UploadMeshData(false); _primarylist.Clear(); _secondarylist.Clear(); _primarytset.Clear(); _secondarytset.Clear(); _display.Enable(); //mark dirty for update and repaint _update_mesh = true; _render_mesh = true; _repaint_menu = true; }
public override void Disable() { _vertexmode = VertexMode.None; _previewutility.Cleanup(); _previewutility = null; _previewblock.Clear(); _meshvertex.Clear(); _meshnormals.Clear(); _meshuvs.Clear(); _meshtriangles.Clear(); _mesh.Clear(); _mesh.UploadMeshData(false); _primarylist.Clear(); _secondarylist.Clear(); _primarytset.Clear(); _secondarytset.Clear(); _display.Disable(); _update_mesh = false; _render_mesh = false; _repaint_menu = false; }
private static BeginMode GetOpenTKVertexMode(VertexMode mode) { switch (mode) { default: case VertexMode.Points: return(BeginMode.Points); case VertexMode.Lines: return(BeginMode.Lines); case VertexMode.LineStrip: return(BeginMode.LineStrip); case VertexMode.LineLoop: return(BeginMode.LineLoop); case VertexMode.Quads: case VertexMode.Triangles: return(BeginMode.Triangles); case VertexMode.TriangleStrip: return(BeginMode.TriangleStrip); case VertexMode.TriangleFan: return(BeginMode.TriangleFan); } }
public bool CanAppendJIT <U>(float invZSortAccuracy, float zSortIndex, BatchInfo material, VertexMode vertexMode) where U : struct, IVertexData { if (invZSortAccuracy > 0.0f && this.material.Technique.Res.NeedsZSort) { if (Math.Abs(zSortIndex - this.ZSortIndex) > invZSortAccuracy) { return(false); } } return (vertexMode == this.vertexMode && this is DrawBatch <U> && IsVertexModeAppendable(this.VertexMode) && material == this.material); }
/// <summary> /// Performs a preprocessing operation for incoming vertices. Does nothing by default but may be overloaded, if needed. /// </summary> /// <typeparam name="T">The incoming vertex type</typeparam> /// <param name="device"></param> /// <param name="material"><see cref="Duality.Resources.Material"/> information for the current batch.</param> /// <param name="vertexMode">The mode of incoming vertex data.</param> /// <param name="vertexBuffer">A buffer storing incoming vertex data.</param> /// <param name="vertexCount">The number of vertices to preprocess, beginning at the start of the specified buffer.</param> public virtual void PreprocessBatch <T>(IDrawDevice device, BatchInfo material, ref VertexMode vertexMode, ref T[] vertexBuffer, ref int vertexCount) { }
public void DataToVBO(Vertex[] vertices, ushort[] indices, VertexMode mode) { if (numOfIndices > 0) Dispose(); int size; vertexFlags = mode; numOfIndices = indices.Length; Vertex.Size = BlittableValueType.StrideOf(vertices); GL.GenBuffers(1, out vertexID); GL.BindBuffer(BufferTarget.ArrayBuffer, vertexID); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * Vertex.Size), vertices, usage); GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, out size); if (vertices.Length * BlittableValueType.StrideOf(vertices) != size) Log.Error("DataToVBO: Vertex data not uploaded correctly"); GL.GenBuffers(1, out indexID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexID); GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(indices.Length * sizeof(ushort)), indices, usage); GL.GetBufferParameter(BufferTarget.ElementArrayBuffer, BufferParameterName.BufferSize, out size); if (indices.Length * sizeof(short) != size) throw new ApplicationException("DataToVBO: Element data not uploaded correctly"); Shader = GLSLShader.Load(); if (Shader != null) { if (Settings.UseGL3) { GL.GenVertexArrays(1, out vaoID); GL.BindVertexArray(vaoID); } GL.BindBuffer(BufferTarget.ArrayBuffer, vertexID); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexID); Shader.SetAttributes(); if (Settings.UseGL3) GL.BindVertexArray(0); } GLExt.CheckGLError("DataToVBO"); }
/// <summary> /// Adds a parameterized set of vertices to the drawing devices rendering schedule. /// </summary> /// <typeparam name="T">The type of vertex data to add.</typeparam> /// <param name="device"></param> /// <param name="material">The <see cref="Duality.Drawing.BatchInfo"/> to use for rendering the vertices.</param> /// <param name="vertexMode">The vertices drawing mode.</param> /// <param name="vertices"> /// A vertex data buffer that stores the vertices to add. Ownership of the buffer /// remains at the callsite, while the <see cref="IDrawDevice"/> copies the required /// data into internal storage. /// </param> public static void AddVertices <T>(this IDrawDevice device, BatchInfo material, VertexMode vertexMode, params T[] vertices) where T : struct, IVertexData { device.AddVertices <T>( material, vertexMode, vertices, vertices.Length); }
public void AddVertices <T>(ContentRef <Material> material, VertexMode vertexMode, params T[] vertices) where T : struct, IVertexData { this.AddVertices <T>(material.IsAvailable ? material.Res.InfoDirect : Material.Checkerboard.Res.InfoDirect, vertexMode, vertices, vertices.Length); }
/// <summary> /// kopioi objekti vbo:hon. /// jos käytetään uvs (tai +uvs2) tai colors, normals pitää myös löytyä. /// </summary> /// <param name="vertices"></param> /// <param name="indices"></param> /// <param name="normals"></param> /// <param name="uvs"></param> public void DataToVBO(Vector3[] vertices, int[] indices, Vector3[] normals, Vector2[] uvs, Vector2[] uvs2, Vector2[] colors) { Vertex[] verts = new Vertex[vertices.Length]; if (normals != null) vertexFlags = VertexMode.Normal; if (uvs != null) vertexFlags = VertexMode.UV1; if (uvs2 != null) vertexFlags = VertexMode.UV2; if (colors != null) vertexFlags = VertexMode.Color; // koppaa vertex infot Vertexiin switch (vertexFlags) { case VertexMode.OnlyVertex: for (int q = 0; q < vertices.Length; q++) { verts[q] = new Vertex(vertices[q]); } break; case VertexMode.Normal: for (int q = 0; q < vertices.Length; q++) { verts[q] = new Vertex(vertices[q], normals[q]); } break; case VertexMode.UV1: for (int q = 0; q < vertices.Length; q++) { verts[q] = new Vertex(vertices[q], normals[q], uvs[q]); } break; case VertexMode.UV2: for (int q = 0; q < vertices.Length; q++) { verts[q] = new Vertex(vertices[q], normals[q], uvs[q], uvs2[q]); } break; case VertexMode.Color: for (int q = 0; q < vertices.Length; q++) { verts[q] = new Vertex(vertices[q], normals[q], colors[q]); } break; } AllocVBO(verts.Length, indices.Length); GL.BindBuffer(BufferTarget.ArrayBuffer, vertexID); GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)0, (IntPtr)(verts.Length * vertexSize), verts); GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexID); GL.BufferSubData(BufferTarget.ElementArrayBuffer, (IntPtr)0, (IntPtr)(indices.Length * sizeof(int)), indices); Util.CheckGLError("VBO"); }
public void AddVertices <T>(ContentRef <Material> material, VertexMode vertexMode, T[] vertexBuffer, int vertexCount) where T : struct, IVertexData { this.AddVertices <T>(material.IsAvailable ? material.Res.InfoDirect : Material.Checkerboard.Res.InfoDirect, vertexMode, vertexBuffer, vertexCount); }
public void AddVertices <T>(BatchInfo material, VertexMode vertexMode, params T[] vertices) where T : struct, IVertexData { this.AddVertices <T>(material, vertexMode, vertices, vertices.Length); }
/// <summary> /// Adds a parameterized set of vertices to the drawing devices rendering schedule. /// </summary> /// <typeparam name="T">The type of vertex data to add.</typeparam> /// <param name="device"></param> /// <param name="material">The <see cref="Duality.Resources.Material"/> to use for rendering the vertices.</param> /// <param name="vertexMode">The vertices drawing mode.</param> /// <param name="vertexBuffer"> /// A vertex data buffer that stores the vertices to add. Ownership of the buffer /// remains at the callsite, while the <see cref="IDrawDevice"/> copies the required /// data into internal storage. /// </param> /// <param name="vertexCount">The number of vertices to add, from the beginning of the buffer.</param> public static void AddVertices <T>(this IDrawDevice device, ContentRef <Material> material, VertexMode vertexMode, T[] vertexBuffer, int vertexCount) where T : struct, IVertexData { device.AddVertices <T>( material.IsAvailable ? material.Res.Info : Material.Checkerboard.Res.Info, vertexMode, vertexBuffer, vertexCount); }
//public void OnDestroy(){this.OnDisable();} //================== // Interface //================== public void OnGUI() { EditorUI.Reset(); EditorUI.SetFieldSize(-1, 175, false); var width = (Screen.width * 0.25f).Clamp(100, 250).ToInt(); var mergeStyle = EditorStyles.miniButtonLeft.FixedHeight(0); var flattenStyle = EditorStyles.miniButtonRight.FixedHeight(0); if (this.operationMode == OperationMode.Merge) { mergeStyle = mergeStyle.UseState("onNormal", "*"); } if (this.operationMode == OperationMode.Flatten) { flattenStyle = flattenStyle.UseState("onNormal", "*"); } EditorGUILayout.BeginVertical(new GUIStyle().Margin(8, 8, 15, 8)); EditorGUILayout.BeginHorizontal(new GUIStyle().Margin(0, 0, 0, 10).Center(width * 2)); if ("Merge".ToLabel().Layout(width, 20).DrawButton(mergeStyle)) { this.operationMode = OperationMode.Merge; } if ("Flatten".ToLabel().Layout(width, 20).DrawButton(flattenStyle)) { this.operationMode = OperationMode.Flatten; } EditorGUILayout.EndHorizontal(); if (this.operationMode.Has("Merge")) { EditorWindowExtensions.SetTitle(this, "Mesh"); //"Vertex".DrawLabel(EditorStyles.boldLabel); this.vertexMode = this.vertexMode.Draw("Vertex Mode").As <VertexMode>(); this.vertexDisplay = this.vertexDisplay.DrawMask("Vertex Display").As <VertexDisplay>(); this.vertexColor = this.vertexColor.Draw("Vertex Color"); this.vertexDistanceColor = this.vertexDistanceColor.Draw("Vertex Distance Color"); this.vertexOverlapColor = this.vertexOverlapColor.Draw("Vertex Overlap Color"); this.distance = this.distance.DrawSlider(0, 1f, "Vertex Overlap Distance"); this.size = this.size.DrawSlider(0, 1, "Vertex Size"); this.scaleFactor = this.scaleFactor.DrawSlider(1, 10, "Vertex Display Scale"); this.scale = (0.0625f * Mathf.Pow(2, this.scaleFactor - 1)); this.alwaysDisplay = this.alwaysDisplay.Draw("Always Display"); var lockText = this.lockSelection ? "Unlock Selection" : "Lock Selection"; GUI.enabled = this.lockSelection || this.cached.Count > 0; if (lockText.ToLabel().Layout(150, 25).DrawButton() && (this.lockSelection || this.cached.Count > 0)) { this.lockSelection = !this.lockSelection; } GUI.enabled = true; } else if (this.operationMode.Has("Flatten")) { } if (EditorUI.anyChanged) { ProxyEditor.RegisterUndo(this, "Mesh Operation Changes"); this.Repaint(); this.RefreshSceneView(); } EditorGUILayout.EndVertical(); this.visible = true; }