Pilz.NET/Pilz
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

simplify Renderer.cs

Browse Source
This commit is contained in:
Pascal
2020-09-24 12:04:06 +02:00
parent e8dadc7fb6
commit 04869b2814
2 changed files with 189 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Pilz.Drawing.Drawing3D.OpenGLRenderer/Preview/ModelPreview.cs
View File

@@ -13,6 +13,7 @@ using Keyboard = OpenTK.Input.Keyboard;
using global::Pilz.Drawing.Drawing3D.OpenGLFactory.CameraN; using global::Pilz.Drawing.Drawing3D.OpenGLFactory.CameraN;
using global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN; using global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN;
using global::Pilz.S3DFileParser; using global::Pilz.S3DFileParser;
using RenderingN;
namespace Pilz.Drawing.Drawing3D.OpenGLFactory.PreviewN namespace Pilz.Drawing.Drawing3D.OpenGLFactory.PreviewN
{ {

369
Pilz.Drawing.Drawing3D.OpenGLRenderer/Rendering/Renderer.cs
View File

@@ -1,44 +1,51 @@
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Data;
using System.Diagnostics; using System.Diagnostics;
using global::System.Drawing; using global::System.Drawing;
using Bitmap = global::System.Drawing.Bitmap; using Bitmap = System.Drawing.Bitmap;
using Color = global::System.Drawing.Color; using Color = System.Drawing.Color;
using Image = global::System.Drawing.Image; using Image = System.Drawing.Image;
using System.Globalization;
using System.IO;
using System.Linq; using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;
using global::System.Threading; using global::System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using global::System.Windows.Forms; using global::System.Windows.Forms;
using System.Xml.Linq; using System.Xml.Linq;
using Microsoft.VisualBasic; using Microsoft.VisualBasic;
using Microsoft.VisualBasic.CompilerServices; using Microsoft.VisualBasic.CompilerServices;
using global::OpenTK; using OpenTK;
using global::OpenTK.Graphics.OpenGL; using OpenTK.Graphics.OpenGL;
using global::Pilz.S3DFileParser; using Pilz.S3DFileParser;
using Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN;
namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN namespace RenderingN
{ {
public class Renderer public partial class Renderer
{ {
private global::Pilz.S3DFileParser.Object3D obj3d; private Object3D obj3d;
private Dictionary<Image, int> dicTextureIDs = new global::System.Collections.Generic.Dictionary<global::System.Drawing.Image, global::System.Int32>(); private Dictionary<Image, int> dicTextureIDs = new Dictionary<Image, int>();
private global::System.Collections.Generic.Dictionary<global::System.Drawing.Color, global::System.Int32> dicColorIDs = new global::System.Collections.Generic.Dictionary<global::System.Drawing.Color, global::System.Int32>(); private Dictionary<Color, int> dicColorIDs = new Dictionary<Color, int>();
private global::System.Drawing.Bitmap emptyTexture = null; private Bitmap emptyTexture = null;
private global::System.Drawing.Bitmap lineTexture = null; private Bitmap lineTexture = null;
private global::System.Drawing.Bitmap selectedLineTexture = null; private Bitmap selectedLineTexture = null;
public float ModelScaling { get; set; } = 1.0f; public float ModelScaling { get; set; } = 1.0f;
public bool HasRendered { get; private set; } = false; public bool HasRendered { get; private set; } = false;
public global::System.Collections.Generic.List<global::System.Object> SelectedElements { get; private set; } public List<global::System.Object> SelectedElements { get; private set; }
private global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32> VertexBuffers { get; set; } = new global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32>(); private Dictionary<Mesh, int> VertexBuffers { get; set; } = new Dictionary<Mesh, int>();
private global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Collections.Generic.List<global::System.Int32>> IndicesBuffers { get; set; } = new global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Collections.Generic.List<global::System.Int32>>(); private Dictionary<Mesh, List<int>> IndicesBuffers { get; set; } = new Dictionary<Mesh, List<int>>();
private global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32> UVBuffers { get; set; } = new global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32>(); private Dictionary<Mesh, int> UVBuffers { get; set; } = new Dictionary<Mesh, int>();
private global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32> VertexColorBuffers { get; set; } = new global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32>(); private Dictionary<Mesh, int> VertexColorBuffers { get; set; } = new Dictionary<Mesh, int>();
private global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32> NormalBuffers { get; set; } = new global::System.Collections.Generic.Dictionary<global::Pilz.S3DFileParser.Mesh, global::System.Int32>(); private Dictionary<Mesh, int> NormalBuffers { get; set; } = new Dictionary<Mesh, int>();
public global::Pilz.S3DFileParser.Object3D Model public Object3D Model
{ {
get get
{ {
@@ -46,23 +53,23 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
} }
} }
public Renderer(global::Pilz.S3DFileParser.Object3D obj3d) public Renderer(Object3D obj3d)
{ {
this.obj3d = obj3d.ToOneMesh(); this.obj3d = obj3d.ToOneMesh();
// Set Texture used for faces without texture // Set Texture used for faces without texture
this.emptyTexture = (global::System.Drawing.Bitmap)this.ColorToTexture(global::System.Drawing.Color.LightGray); this.emptyTexture = (Bitmap)this.ColorToTexture(Color.LightGray);
// Set Texture used for lines // Set Texture used for lines
this.lineTexture = (global::System.Drawing.Bitmap)this.ColorToTexture(global::System.Drawing.Color.Black); this.lineTexture = (Bitmap)this.ColorToTexture(Color.Black);
// Set Texture used for lines of selected faces // Set Texture used for lines of selected faces
this.selectedLineTexture = (global::System.Drawing.Bitmap)this.ColorToTexture(global::System.Drawing.Color.Orange); this.selectedLineTexture = (Bitmap)this.ColorToTexture(Color.Orange);
} }
private global::System.Drawing.Image ColorToTexture(global::System.Drawing.Color color) private Image ColorToTexture(Color color)
{ {
var tex = new global::System.Drawing.Bitmap(1, 1); var tex = new Bitmap(1, 1);
tex.SetPixel(0, 0, color); tex.SetPixel(0, 0, color);
return tex; return tex;
} }
@@ -72,11 +79,11 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
/// </summary> /// </summary>
/// <param name="m">The Mesh where the Vertex is listed.</param> /// <param name="m">The Mesh where the Vertex is listed.</param>
/// <param name="v">The Vertex to update.</param> /// <param name="v">The Vertex to update.</param>
public void UpdateVertexData(global::Pilz.S3DFileParser.Mesh m, global::Pilz.S3DFileParser.Vertex v) public void UpdateVertexData(Mesh m, Vertex v)
{ {
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.VertexBuffers[m]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.VertexBuffers[m]);
var argdata = new global::OpenTK.Vector3((global::System.Single)v.X, (global::System.Single)v.Y, (global::System.Single)v.Z); var vector = new Vector3((float)v.X, (float)v.Y, (float)v.Z);
global::OpenTK.Graphics.OpenGL.GL.BufferSubData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((m.Vertices.IndexOf(v)) * (global::OpenTK.Vector3.SizeInBytes)), global::OpenTK.Vector3.SizeInBytes, ref argdata); GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)((m.Vertices.IndexOf(v)) * (Vector3.SizeInBytes)), Vector3.SizeInBytes, ref vector);
} }
/// <summary> /// <summary>
@@ -84,11 +91,11 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
/// </summary> /// </summary>
/// <param name="m">The Mesh where the Vertex is listed.</param> /// <param name="m">The Mesh where the Vertex is listed.</param>
/// <param name="n">The Normal to update.</param> /// <param name="n">The Normal to update.</param>
public void UpdateNormalData(global::Pilz.S3DFileParser.Mesh m, global::Pilz.S3DFileParser.Normal n) public void UpdateNormalData(Mesh m, Normal n)
{ {
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.NormalBuffers[m]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.NormalBuffers[m]);
var argdata = new global::OpenTK.Vector3(n.X, n.Y, n.Z); var vector = new Vector3((float)n.X, (float)n.Y, (float)n.Z);
global::OpenTK.Graphics.OpenGL.GL.BufferSubData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((m.Normals.IndexOf(n)) * (global::OpenTK.Vector3.SizeInBytes)), global::OpenTK.Vector3.SizeInBytes, ref argdata); GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)((m.Normals.IndexOf(n)) * (Vector3.SizeInBytes)), Vector3.SizeInBytes, ref vector);
} }
/// <summary> /// <summary>
@@ -96,11 +103,11 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
/// </summary> /// </summary>
/// <param name="m">The Mesh where the Vertex is listed.</param> /// <param name="m">The Mesh where the Vertex is listed.</param>
/// <param name="vc">The Vertex Color to update.</param> /// <param name="vc">The Vertex Color to update.</param>
public void UpdateVertexColorData(global::Pilz.S3DFileParser.Mesh m, global::Pilz.S3DFileParser.VertexColor vc) public void UpdateVertexColorData(Mesh m, VertexColor vc)
{ {
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.VertexColorBuffers[m]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.VertexColorBuffers[m]);
var argdata = new global::OpenTK.Vector4(vc.R, vc.G, vc.B, vc.A); var vector = new Vector4(vc.R, vc.G, vc.B, vc.A);
global::OpenTK.Graphics.OpenGL.GL.BufferSubData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((m.VertexColors.IndexOf(vc)) * (global::OpenTK.Vector4.SizeInBytes)), global::OpenTK.Vector4.SizeInBytes, ref argdata); GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)((m.VertexColors.IndexOf(vc)) * (Vector4.SizeInBytes)), Vector4.SizeInBytes, ref vector);
} }
/// <summary> /// <summary>
@@ -108,11 +115,11 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
/// </summary> /// </summary>
/// <param name="m">The Mesh where the Vertex is listed.</param> /// <param name="m">The Mesh where the Vertex is listed.</param>
/// <param name="uv">The UV to update.</param> /// <param name="uv">The UV to update.</param>
public void UpdateUVData(global::Pilz.S3DFileParser.Mesh m, global::Pilz.S3DFileParser.UV uv) public void UpdateUVData(Mesh m, UV uv)
{ {
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.UVBuffers[m]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.UVBuffers[m]);
var argdata = new global::OpenTK.Vector2(uv.U, uv.V); var vector = new Vector2(uv.U, uv.V);
global::OpenTK.Graphics.OpenGL.GL.BufferSubData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((m.UVs.IndexOf(uv)) * (global::OpenTK.Vector2.SizeInBytes)), global::OpenTK.Vector2.SizeInBytes, ref argdata); GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)((m.UVs.IndexOf(uv)) * (Vector2.SizeInBytes)), Vector2.SizeInBytes, ref vector);
} }
/// <summary> /// <summary>
@@ -120,13 +127,13 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
/// </summary> /// </summary>
/// <param name="m">The Mesh where the Vertex is listed.</param> /// <param name="m">The Mesh where the Vertex is listed.</param>
/// <param name="f">The Face to update.</param> /// <param name="f">The Face to update.</param>
public void UpdateFaceIndicies(global::Pilz.S3DFileParser.Mesh m, global::Pilz.S3DFileParser.Face f) public void UpdateFaceIndicies(Mesh m, Face f)
{ {
global::System.Int32 faceIndex = m.Faces.IndexOf(f); int faceIndex = m.Faces.IndexOf(f);
global::System.Byte uintlen = (global::System.Byte)global::Microsoft.VisualBasic.Strings.Len(new uint()); byte uintlen = (byte)Strings.Len(new uint());
var indicies = new global::OpenTK.Vector3((global::System.Single)m.Vertices.IndexOf(f.Points[0].Vertex), (global::System.Single)m.Vertices.IndexOf(f.Points[1].Vertex), (global::System.Single)m.Vertices.IndexOf(f.Points[2].Vertex)); var indicies = new Vector3(m.Vertices.IndexOf(f.Points[0].Vertex), m.Vertices.IndexOf(f.Points[1].Vertex), m.Vertices.IndexOf(f.Points[2].Vertex));
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.IndicesBuffers[m][faceIndex]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.IndicesBuffers[m][faceIndex]);
global::OpenTK.Graphics.OpenGL.GL.BufferSubData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((global::System.Int32)(uintlen) * (faceIndex)), (global::System.Int32)uintlen, ref indicies); GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)(uintlen * faceIndex), uintlen, ref indicies);
} }
/// <summary> /// <summary>
@@ -134,14 +141,14 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
/// </summary> /// </summary>
/// <param name="oldImage"></param> /// <param name="oldImage"></param>
/// <param name="newImage"></param> /// <param name="newImage"></param>
public void UpdateTexture(global::System.Drawing.Image oldImage, global::System.Drawing.Image newImage) public void UpdateTexture(Image oldImage, Image newImage)
{ {
if (this.dicTextureIDs.ContainsKey(oldImage)) if (this.dicTextureIDs.ContainsKey(oldImage))
{ {
global::System.Int32 id = this.dicTextureIDs[oldImage]; int id = this.dicTextureIDs[oldImage];
this.dicTextureIDs.Remove(oldImage); this.dicTextureIDs.Remove(oldImage);
this.dicTextureIDs.Add(newImage, id); this.dicTextureIDs.Add(newImage, id);
global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.ContentPipe.LoadTexture((global::System.Drawing.Bitmap)newImage, id); ContentPipe.LoadTexture((Bitmap)newImage, id);
} }
} }
@@ -149,11 +156,11 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
/// Updates an Image. /// Updates an Image.
/// </summary> /// </summary>
/// <param name="image"></param> /// <param name="image"></param>
public void UpdateTexture(global::System.Drawing.Image image) public void UpdateTexture(Image image)
{ {
if (this.dicTextureIDs.ContainsKey(image)) if (this.dicTextureIDs.ContainsKey(image))
{ {
global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.ContentPipe.LoadTexture((this.dicTextureIDs[image]).ToString()); ContentPipe.LoadTexture(this.dicTextureIDs[image].ToString());
} }
} }
@@ -163,33 +170,33 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
public void RenderModel() public void RenderModel()
{ {
this.ReleaseBuffers(); this.ReleaseBuffers();
foreach (global::Pilz.S3DFileParser.Mesh mesh in this.obj3d.Meshes) foreach (Mesh mesh in this.obj3d.Meshes)
{ {
var nibo = new global::System.Collections.Generic.List<global::System.Int32>(); var nibo = new List<int>();
global::System.Boolean enablecols = ((mesh.VertexColors.Count) > (0)); global::System.Boolean enablecols = ((mesh.VertexColors.Count) > (0));
global::System.Boolean enablenorms = (((!(enablecols))) && ((mesh.Normals.Count) > (0))); global::System.Boolean enablenorms = (((!(enablecols))) && ((mesh.Normals.Count) > (0)));
var verts = new global::System.Collections.Generic.List<global::OpenTK.Vector3>(); var verts = new List<Vector3>();
var uvs = new global::System.Collections.Generic.List<global::OpenTK.Vector2>(); var uvs = new List<Vector2>();
var cols = new global::System.Collections.Generic.List<global::OpenTK.Vector4>(); var cols = new List<Vector4>();
var norms = new global::System.Collections.Generic.List<global::OpenTK.Vector3>(); var norms = new List<Vector3>();
global::System.UInt64 curvi = 0UL; global::System.UInt64 curvi = 0UL;
this.IndicesBuffers.Add(mesh, nibo); this.IndicesBuffers.Add(mesh, nibo);
for (global::System.Int32 i = 0, loopTo = (mesh.Faces.Count) - (1); i <= loopTo; i++) for (int i = 0, loopTo = (mesh.Faces.Count) - (1); i <= loopTo; i++)
{ {
{ {
var currentFace = mesh.Faces[i]; var withBlock = mesh.Faces[i];
var indices = new List<UInt32>(); var indices = new List<global::System.UInt32>();
foreach (S3DFileParser.Point p in currentFace.Points) foreach (Pilz.S3DFileParser.Point p in withBlock.Points)
{ {
indices.Add((global::System.UInt32)curvi); indices.Add((global::System.UInt32)curvi);
curvi = (global::System.UInt64)(curvi + 1m); curvi = (global::System.UInt64)(curvi + 1m);
if (p.Vertex is object) if (p.Vertex is object)
{ {
verts.Add(new Vector3((Single)p.Vertex.X, (Single)p.Vertex.Y, (Single)p.Vertex.Z)); verts.Add(new Vector3((float)p.Vertex.X, (float)p.Vertex.Y, (float)p.Vertex.Z));
} }
else else
{ {
verts.Add(new Vector3(0f, 0f, 0f)); verts.Add(new Vector3(0, 0, 0));
} }
if (p.UV is object) if (p.UV is object)
@@ -198,7 +205,7 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
} }
else else
{ {
uvs.Add(new Vector2(0f, 0f)); uvs.Add(new Vector2(0, 0));
} }
if (((enablecols) && p.VertexColor is object)) if (((enablecols) && p.VertexColor is object))
@@ -207,272 +214,272 @@ namespace Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN
} }
else else
{ {
cols.Add(new Vector4(1f, 1f, 1f, 1f)); cols.Add(new Vector4(1, 1, 1, 1));
} }
if (((enablenorms) && p.Normal is object)) if (((enablenorms) && p.Normal is object))
{ {
norms.Add(new global::OpenTK.Vector3(p.Normal.X, p.Normal.Y, p.Normal.Z)); norms.Add(new Vector3(p.Normal.X, p.Normal.Y, p.Normal.Z));
} }
else else
{ {
norms.Add(new global::OpenTK.Vector3(1f, 1f, 1f)); norms.Add(new Vector3(1, 1, 1));
} }
} }
nibo.Add(GL.GenBuffer()); nibo.Add(GL.GenBuffer());
GL.BindBuffer(BufferTarget.ElementArrayBuffer, nibo[i]); GL.BindBuffer(BufferTarget.ElementArrayBuffer, nibo[i]);
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)((Strings.Len(new uint())) * (indices.Count)), indices.ToArray(), global::OpenTK.Graphics.OpenGL.BufferUsageHint.StaticDraw); GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)((Strings.Len(new uint())) * (indices.Count)), indices.ToArray(), BufferUsageHint.StaticDraw);
if (currentFace.Material?.Image is object) if (withBlock.Material?.Image is object)
{ {
if (!(this.dicTextureIDs.ContainsKey(currentFace.Material.Image))) if (!(this.dicTextureIDs.ContainsKey(withBlock.Material.Image)))
{ {
this.dicTextureIDs.Add(currentFace.Material.Image, global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.ContentPipe.LoadTexture((global::System.Drawing.Bitmap)currentFace.Material.Image)); this.dicTextureIDs.Add(withBlock.Material.Image, ContentPipe.LoadTexture((Bitmap)withBlock.Material.Image));
} }
} }
else if (currentFace.Material?.Color is object) else if (withBlock.Material?.Color is object)
{ {
if (!(this.dicColorIDs.ContainsKey((global::System.Drawing.Color)currentFace.Material.Color))) if (!(this.dicColorIDs.ContainsKey((Color)withBlock.Material.Color)))
{ {
this.dicColorIDs.Add((global::System.Drawing.Color)currentFace.Material.Color, global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.ContentPipe.LoadTexture((global::System.Drawing.Bitmap)this.ColorToTexture((global::System.Drawing.Color)currentFace.Material.Color))); this.dicColorIDs.Add((Color)withBlock.Material.Color, ContentPipe.LoadTexture((Bitmap)ColorToTexture((Color)withBlock.Material.Color)));
} }
} }
else if (!(this.dicTextureIDs.ContainsKey(this.emptyTexture))) else if (!(this.dicTextureIDs.ContainsKey(this.emptyTexture)))
{ {
this.dicTextureIDs.Add(this.emptyTexture, global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.ContentPipe.LoadTexture(this.emptyTexture)); this.dicTextureIDs.Add(this.emptyTexture, ContentPipe.LoadTexture(this.emptyTexture));
} }
} }
} }
global::System.Int32 nvbo = global::OpenTK.Graphics.OpenGL.GL.GenBuffer(); int nvbo = GL.GenBuffer();
this.VertexBuffers.Add(mesh, nvbo); this.VertexBuffers.Add(mesh, nvbo);
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, nvbo); GL.BindBuffer(BufferTarget.ArrayBuffer, nvbo);
global::OpenTK.Graphics.OpenGL.GL.BufferData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((global::OpenTK.Vector3.SizeInBytes) * (verts.Count)), verts.ToArray(), global::OpenTK.Graphics.OpenGL.BufferUsageHint.StaticDraw); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)((Vector3.SizeInBytes) * (verts.Count)), verts.ToArray(), BufferUsageHint.StaticDraw);
global::System.Int32 ntbo = global::OpenTK.Graphics.OpenGL.GL.GenBuffer(); int ntbo = GL.GenBuffer();
this.UVBuffers.Add(mesh, ntbo); this.UVBuffers.Add(mesh, ntbo);
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, ntbo); GL.BindBuffer(BufferTarget.ArrayBuffer, ntbo);
global::OpenTK.Graphics.OpenGL.GL.BufferData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((global::OpenTK.Vector2.SizeInBytes) * (uvs.Count)), uvs.ToArray(), global::OpenTK.Graphics.OpenGL.BufferUsageHint.StaticDraw); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)((Vector2.SizeInBytes) * (uvs.Count)), uvs.ToArray(), BufferUsageHint.StaticDraw);
if (enablecols) if (enablecols)
{ {
global::System.Int32 ncbo = global::OpenTK.Graphics.OpenGL.GL.GenBuffer(); int ncbo = GL.GenBuffer();
this.VertexColorBuffers.Add(mesh, ncbo); this.VertexColorBuffers.Add(mesh, ncbo);
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, ncbo); GL.BindBuffer(BufferTarget.ArrayBuffer, ncbo);
global::OpenTK.Graphics.OpenGL.GL.BufferData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((global::OpenTK.Vector4.SizeInBytes) * (cols.Count)), cols.ToArray(), global::OpenTK.Graphics.OpenGL.BufferUsageHint.StaticDraw); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)((Vector4.SizeInBytes) * (cols.Count)), cols.ToArray(), BufferUsageHint.StaticDraw);
} }
if (enablenorms) if (enablenorms)
{ {
global::System.Int32 nnbo = global::OpenTK.Graphics.OpenGL.GL.GenBuffer(); int nnbo = GL.GenBuffer();
this.NormalBuffers.Add(mesh, nnbo); this.NormalBuffers.Add(mesh, nnbo);
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, nnbo); GL.BindBuffer(BufferTarget.ArrayBuffer, nnbo);
global::OpenTK.Graphics.OpenGL.GL.BufferData(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, (global::System.IntPtr)((global::OpenTK.Vector3.SizeInBytes) * (norms.Count)), norms.ToArray(), global::OpenTK.Graphics.OpenGL.BufferUsageHint.StaticDraw); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)((Vector3.SizeInBytes) * (norms.Count)), norms.ToArray(), BufferUsageHint.StaticDraw);
} }
} }
if (!(this.dicTextureIDs.ContainsKey(this.lineTexture))) if (!(this.dicTextureIDs.ContainsKey(this.lineTexture)))
{ {
this.dicTextureIDs.Add(this.lineTexture, global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.ContentPipe.LoadTexture(this.lineTexture)); this.dicTextureIDs.Add(this.lineTexture, ContentPipe.LoadTexture(this.lineTexture));
} }
this.HasRendered = true; this.HasRendered = true;
} }
public void DrawModel(global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode mode) public void DrawModel(RenderMode mode)
{ {
this.DrawModel(mode, global::OpenTK.Vector3.Zero, global::OpenTK.Quaternion.Identity, new global::OpenTK.Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling)); DrawModel(mode, Vector3.Zero, Quaternion.Identity, new Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling));
} }
public void DrawModel(global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode mode, global::OpenTK.Vector3 pos, global::OpenTK.Quaternion rot) public void DrawModel(RenderMode mode, Vector3 pos, Quaternion rot)
{ {
this.DrawModel(mode, pos, rot, new global::OpenTK.Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling)); DrawModel(mode, pos, rot, new Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling));
} }
public void DrawModel(global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode mode, global::OpenTK.Vector3 pos, global::OpenTK.Quaternion rot, global::OpenTK.Vector3 scale) public void DrawModel(RenderMode mode, Vector3 pos, Quaternion rot, Vector3 scale)
{ {
if ((mode == global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode.None)) if (((mode) == (RenderMode.None)))
return; return;
if (!(this.HasRendered)) if (!(this.HasRendered))
return; return;
global::OpenTK.Graphics.OpenGL.GL.PushMatrix(); GL.PushMatrix();
global::OpenTK.Graphics.OpenGL.GL.Translate(pos.X, pos.Y, pos.Z); GL.Translate(pos.X, pos.Y, pos.Z);
global::OpenTK.Graphics.OpenGL.GL.Rotate(rot.X, 1f, 0f, 0f); GL.Rotate(rot.X, 1, 0, 0);
global::OpenTK.Graphics.OpenGL.GL.Rotate(rot.Y, 0f, 1f, 0f); GL.Rotate(rot.Y, 0, 1, 0);
global::OpenTK.Graphics.OpenGL.GL.Rotate(rot.Z, 0f, 0f, 1f); GL.Rotate(rot.Z, 0, 0, 1);
global::OpenTK.Graphics.OpenGL.GL.Scale(scale); // GL.Scale(scale.X, scale.Y, scale.Z) GL.Scale(scale); // GL.Scale(scale.X, scale.Y, scale.Z)
global::OpenTK.Graphics.OpenGL.GL.EnableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.VertexArray); GL.EnableClientState(ArrayCap.VertexArray);
global::OpenTK.Graphics.OpenGL.GL.EnableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.TextureCoordArray); GL.EnableClientState(ArrayCap.TextureCoordArray);
foreach (global::Pilz.S3DFileParser.Mesh mesh in this.obj3d.Meshes) foreach (Mesh mesh in this.obj3d.Meshes)
{ {
if (this.VertexColorBuffers.ContainsKey(mesh)) if (this.VertexColorBuffers.ContainsKey(mesh))
{ {
global::OpenTK.Graphics.OpenGL.GL.EnableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.ColorArray); GL.EnableClientState(ArrayCap.ColorArray);
} }
else if (this.NormalBuffers.ContainsKey(mesh)) else if (this.NormalBuffers.ContainsKey(mesh))
{ {
global::OpenTK.Graphics.OpenGL.GL.EnableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.NormalArray); GL.EnableClientState(ArrayCap.NormalArray);
} }
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.VertexBuffers[mesh]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.VertexBuffers[mesh]);
global::OpenTK.Graphics.OpenGL.GL.VertexPointer(3, global::OpenTK.Graphics.OpenGL.VertexPointerType.Float, 0, global::System.IntPtr.Zero); GL.VertexPointer(3, VertexPointerType.Float, 0, IntPtr.Zero);
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.UVBuffers[mesh]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.UVBuffers[mesh]);
global::OpenTK.Graphics.OpenGL.GL.TexCoordPointer(2, global::OpenTK.Graphics.OpenGL.TexCoordPointerType.Float, 0, global::System.IntPtr.Zero); GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, IntPtr.Zero);
if (this.VertexColorBuffers.ContainsKey(mesh)) if (this.VertexColorBuffers.ContainsKey(mesh))
{ {
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.VertexColorBuffers[mesh]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.VertexColorBuffers[mesh]);
global::OpenTK.Graphics.OpenGL.GL.ColorPointer(4, global::OpenTK.Graphics.OpenGL.ColorPointerType.Float, 0, global::System.IntPtr.Zero); GL.ColorPointer(4, ColorPointerType.Float, 0, IntPtr.Zero);
} }
else if (this.NormalBuffers.ContainsKey(mesh)) else if (this.NormalBuffers.ContainsKey(mesh))
{ {
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.NormalBuffers[mesh]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.NormalBuffers[mesh]);
global::OpenTK.Graphics.OpenGL.GL.NormalPointer(global::OpenTK.Graphics.OpenGL.NormalPointerType.Float, 0, global::System.IntPtr.Zero); GL.NormalPointer(NormalPointerType.Float, 0, IntPtr.Zero);
} }
for (global::System.Int32 i = 0, loopTo = (mesh.Faces.Count) - (1); i <= loopTo; i++) for (int i = 0, loopTo = (mesh.Faces.Count) - (1); i <= loopTo; i++)
{ {
var l = mesh.Faces[i]; Face l = mesh.Faces[i];
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ElementArrayBuffer, this.IndicesBuffers[mesh][i]); GL.BindBuffer(BufferTarget.ElementArrayBuffer, this.IndicesBuffers[mesh][i]);
global::System.Boolean isEmptyTexture = l.Material?.Image is null; global::System.Boolean isEmptyTexture = l.Material?.Image is null;
global::System.Boolean isEmptyColor = l.Material?.Color is null; global::System.Boolean isEmptyColor = l.Material?.Color is null;
void setMaterialTextureOrColor() void setMaterialTextureOrColor()
{ {
global::System.Int32 texID; int texID;
if (!(isEmptyTexture)) if (!(isEmptyTexture))
{ {
texID = this.dicTextureIDs[l.Material.Image]; texID = this.dicTextureIDs[l.Material.Image];
} }
else if (!(isEmptyColor)) else if (!(isEmptyColor))
{ {
texID = this.dicColorIDs[(global::System.Drawing.Color)l.Material.Color]; texID = this.dicColorIDs[(Color)l.Material.Color];
} }
else else
{ {
texID = this.dicTextureIDs[this.emptyTexture]; texID = this.dicTextureIDs[this.emptyTexture];
} }
global::OpenTK.Graphics.OpenGL.GL.BindTexture(global::OpenTK.Graphics.OpenGL.TextureTarget.Texture2D, texID); GL.BindTexture(TextureTarget.Texture2D, texID);
}; };
if ((((mode & global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode.Fill)) == global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode.Fill)) if ((((((mode) & (RenderMode.Fill)))) == (RenderMode.Fill)))
{ {
setMaterialTextureOrColor(); setMaterialTextureOrColor();
if (!(isEmptyTexture)) if (!(isEmptyTexture))
{ {
global::OpenTK.Graphics.OpenGL.GL.TexParameter(global::OpenTK.Graphics.OpenGL.TextureTarget.Texture2D, global::OpenTK.Graphics.OpenGL.TextureParameterName.TextureWrapT, l.Material.Wrap.X); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, l.Material.Wrap.X);
global::OpenTK.Graphics.OpenGL.GL.TexParameter(global::OpenTK.Graphics.OpenGL.TextureTarget.Texture2D, global::OpenTK.Graphics.OpenGL.TextureParameterName.TextureWrapS, l.Material.Wrap.Y); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, l.Material.Wrap.Y);
} }
global::OpenTK.Graphics.OpenGL.GL.PolygonMode(global::OpenTK.Graphics.OpenGL.MaterialFace.FrontAndBack, global::OpenTK.Graphics.OpenGL.PolygonMode.Fill); GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
global::OpenTK.Graphics.OpenGL.GL.DrawElements(global::OpenTK.Graphics.OpenGL.PrimitiveType.Triangles, l.Points.Count, global::OpenTK.Graphics.OpenGL.DrawElementsType.UnsignedInt, global::System.IntPtr.Zero); GL.DrawElements(PrimitiveType.Triangles, l.Points.Count, DrawElementsType.UnsignedInt, IntPtr.Zero);
} }
if ((((mode & global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode.Outline)) == global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode.Outline)) if ((((((mode) & (RenderMode.Outline)))) == (RenderMode.Outline)))
{ {
if ((((mode & global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode.Fill)) == global::Pilz.Drawing.Drawing3D.OpenGLFactory.RenderingN.RenderMode.Fill)) if ((((((mode) & (RenderMode.Fill)))) == (RenderMode.Fill)))
{ {
global::OpenTK.Graphics.OpenGL.GL.BindTexture(global::OpenTK.Graphics.OpenGL.TextureTarget.Texture2D, this.dicTextureIDs[this.lineTexture]); GL.BindTexture(TextureTarget.Texture2D, this.dicTextureIDs[this.lineTexture]);
} }
else else
{ {
setMaterialTextureOrColor(); setMaterialTextureOrColor();
if (!(isEmptyTexture)) if (!(isEmptyTexture))
{ {
global::OpenTK.Graphics.OpenGL.GL.TexParameter(global::OpenTK.Graphics.OpenGL.TextureTarget.Texture2D, global::OpenTK.Graphics.OpenGL.TextureParameterName.TextureWrapT, l.Material.Wrap.X); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, l.Material.Wrap.X);
global::OpenTK.Graphics.OpenGL.GL.TexParameter(global::OpenTK.Graphics.OpenGL.TextureTarget.Texture2D, global::OpenTK.Graphics.OpenGL.TextureParameterName.TextureWrapS, l.Material.Wrap.Y); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, l.Material.Wrap.Y);
} }
} }
global::OpenTK.Graphics.OpenGL.GL.PolygonMode(global::OpenTK.Graphics.OpenGL.MaterialFace.FrontAndBack, global::OpenTK.Graphics.OpenGL.PolygonMode.Line); GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
global::OpenTK.Graphics.OpenGL.GL.DrawElements(global::OpenTK.Graphics.OpenGL.PrimitiveType.Triangles, l.Points.Count, global::OpenTK.Graphics.OpenGL.DrawElementsType.UnsignedInt, global::System.IntPtr.Zero); GL.DrawElements(PrimitiveType.Triangles, l.Points.Count, DrawElementsType.UnsignedInt, IntPtr.Zero);
} }
} }
global::OpenTK.Graphics.OpenGL.GL.PolygonMode(global::OpenTK.Graphics.OpenGL.MaterialFace.FrontAndBack, global::OpenTK.Graphics.OpenGL.PolygonMode.Fill); // Reset for RenderEngineOld GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill); // Reset for RenderEngineOld
if (this.VertexColorBuffers.ContainsKey(mesh)) if (this.VertexColorBuffers.ContainsKey(mesh))
{ {
global::OpenTK.Graphics.OpenGL.GL.DisableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.ColorArray); GL.DisableClientState(ArrayCap.ColorArray);
} }
else if (this.NormalBuffers.ContainsKey(mesh)) else if (this.NormalBuffers.ContainsKey(mesh))
{ {
global::OpenTK.Graphics.OpenGL.GL.DisableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.NormalArray); GL.DisableClientState(ArrayCap.NormalArray);
} }
} }
global::OpenTK.Graphics.OpenGL.GL.DisableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.VertexArray); GL.DisableClientState(ArrayCap.VertexArray);
global::OpenTK.Graphics.OpenGL.GL.DisableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.TextureCoordArray); GL.DisableClientState(ArrayCap.TextureCoordArray);
global::OpenTK.Graphics.OpenGL.GL.PopMatrix(); GL.PopMatrix();
} }
public void DrawFacePicking() public void DrawFacePicking()
{ {
this.DrawFacePicking(global::OpenTK.Vector3.Zero, global::OpenTK.Quaternion.Identity, new global::OpenTK.Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling)); DrawFacePicking(Vector3.Zero, Quaternion.Identity, new Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling));
} }
public void DrawFacePicking(global::OpenTK.Vector3 pos, global::OpenTK.Quaternion rot) public void DrawFacePicking(Vector3 pos, Quaternion rot)
{ {
this.DrawFacePicking(pos, rot, new global::OpenTK.Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling)); DrawFacePicking(pos, rot, new Vector3(this.ModelScaling, this.ModelScaling, this.ModelScaling));
} }
public void DrawFacePicking(global::OpenTK.Vector3 pos, global::OpenTK.Quaternion rot, global::OpenTK.Vector3 scale) public void DrawFacePicking(Vector3 pos, Quaternion rot, Vector3 scale)
{ {
if (!(this.HasRendered)) if (!(this.HasRendered))
return; return;
global::OpenTK.Graphics.OpenGL.GL.PushMatrix(); GL.PushMatrix();
global::OpenTK.Graphics.OpenGL.GL.Translate(pos.X, pos.Y, pos.Z); GL.Translate(pos.X, pos.Y, pos.Z);
global::OpenTK.Graphics.OpenGL.GL.Rotate(rot.X, 1f, 0f, 0f); GL.Rotate(rot.X, 1, 0, 0);
global::OpenTK.Graphics.OpenGL.GL.Rotate(rot.Y, 0f, 1f, 0f); GL.Rotate(rot.Y, 0, 1, 0);
global::OpenTK.Graphics.OpenGL.GL.Rotate(rot.Z, 0f, 0f, 1f); GL.Rotate(rot.Z, 0, 0, 1);
global::OpenTK.Graphics.OpenGL.GL.Scale(scale); GL.Scale(scale);
global::OpenTK.Graphics.OpenGL.GL.EnableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.VertexArray); GL.EnableClientState(ArrayCap.VertexArray);
for (global::System.Int32 iMesh = 0, loopTo = (this.obj3d.Meshes.Count) - (1); iMesh <= loopTo; iMesh++) for (int iMesh = 0, loopTo = (this.obj3d.Meshes.Count) - (1); iMesh <= loopTo; iMesh++)
{ {
var mesh = this.obj3d.Meshes[iMesh]; Mesh mesh = this.obj3d.Meshes[iMesh];
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ArrayBuffer, this.VertexBuffers[mesh]); GL.BindBuffer(BufferTarget.ArrayBuffer, this.VertexBuffers[mesh]);
global::OpenTK.Graphics.OpenGL.GL.VertexPointer(3, global::OpenTK.Graphics.OpenGL.VertexPointerType.Float, 0, global::System.IntPtr.Zero); GL.VertexPointer(3, VertexPointerType.Float, 0, IntPtr.Zero);
for (global::System.Int32 iFace = 0, loopTo1 = (mesh.Faces.Count) - (1); iFace <= loopTo1; iFace++) for (int iFace = 0, loopTo1 = (mesh.Faces.Count) - (1); iFace <= loopTo1; iFace++)
{ {
var l = mesh.Faces[iFace]; Face l = mesh.Faces[iFace];
global::OpenTK.Graphics.OpenGL.GL.BindBuffer(global::OpenTK.Graphics.OpenGL.BufferTarget.ElementArrayBuffer, this.IndicesBuffers[mesh][iFace]); GL.BindBuffer(BufferTarget.ElementArrayBuffer, this.IndicesBuffers[mesh][iFace]);
global::System.Int32 colorCode = (((0x20000000) + ((((iMesh) << (16))))) + (iFace)); int colorCode = (((0x20000000) + ((((iMesh) << (16))))) + (iFace));
global::OpenTK.Graphics.OpenGL.GL.Color4(global::System.Drawing.Color.FromArgb(colorCode)); // Color: "2f ff xx xx" -> where 'f' = mesh index and where 'x' is face index GL.Color4(Color.FromArgb(colorCode)); // Color: "2f ff xx xx" -> where 'f' = mesh index and where 'x' is face index
global::OpenTK.Graphics.OpenGL.GL.PolygonMode(global::OpenTK.Graphics.OpenGL.MaterialFace.FrontAndBack, global::OpenTK.Graphics.OpenGL.PolygonMode.Fill); GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
global::OpenTK.Graphics.OpenGL.GL.DrawElements(global::OpenTK.Graphics.OpenGL.PrimitiveType.Triangles, l.Points.Count, global::OpenTK.Graphics.OpenGL.DrawElementsType.UnsignedInt, global::System.IntPtr.Zero); GL.DrawElements(PrimitiveType.Triangles, l.Points.Count, DrawElementsType.UnsignedInt, IntPtr.Zero);
} }
global::OpenTK.Graphics.OpenGL.GL.PolygonMode(global::OpenTK.Graphics.OpenGL.MaterialFace.FrontAndBack, global::OpenTK.Graphics.OpenGL.PolygonMode.Fill); GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
} }
global::OpenTK.Graphics.OpenGL.GL.DisableClientState(global::OpenTK.Graphics.OpenGL.ArrayCap.VertexArray); GL.DisableClientState(ArrayCap.VertexArray);
global::OpenTK.Graphics.OpenGL.GL.PopMatrix(); GL.PopMatrix();
} }
public void ReleaseBuffers() public void ReleaseBuffers()
{ {
if (!(this.HasRendered)) if (!(this.HasRendered))
return; return;
foreach (global::System.Collections.Generic.KeyValuePair<global::Pilz.S3DFileParser.Mesh, global::System.Int32> kvp in this.VertexBuffers) foreach (KeyValuePair<Mesh, int> kvp in this.VertexBuffers)
global::OpenTK.Graphics.OpenGL.GL.DeleteBuffer(kvp.Value); GL.DeleteBuffer(kvp.Value);
this.VertexBuffers.Clear(); this.VertexBuffers.Clear();
foreach (global::System.Collections.Generic.KeyValuePair<global::Pilz.S3DFileParser.Mesh, global::System.Int32> kvp in this.UVBuffers) foreach (KeyValuePair<Mesh, int> kvp in this.UVBuffers)
global::OpenTK.Graphics.OpenGL.GL.DeleteBuffer(kvp.Value); GL.DeleteBuffer(kvp.Value);
this.UVBuffers.Clear(); this.UVBuffers.Clear();
foreach (global::System.Collections.Generic.KeyValuePair<global::Pilz.S3DFileParser.Mesh, global::System.Int32> kvp in this.VertexColorBuffers) foreach (KeyValuePair<Mesh, int> kvp in this.VertexColorBuffers)
global::OpenTK.Graphics.OpenGL.GL.DeleteBuffer(kvp.Value); GL.DeleteBuffer(kvp.Value);
this.VertexColorBuffers.Clear(); this.VertexColorBuffers.Clear();
foreach (global::System.Collections.Generic.KeyValuePair<global::Pilz.S3DFileParser.Mesh, global::System.Int32> kvp in this.NormalBuffers) foreach (KeyValuePair<Mesh, int> kvp in this.NormalBuffers)
global::OpenTK.Graphics.OpenGL.GL.DeleteBuffer(kvp.Value); GL.DeleteBuffer(kvp.Value);
this.NormalBuffers.Clear(); this.NormalBuffers.Clear();
foreach (global::System.Collections.Generic.KeyValuePair<global::Pilz.S3DFileParser.Mesh, global::System.Collections.Generic.List<global::System.Int32>> kvp in this.IndicesBuffers) foreach (KeyValuePair<Mesh, List<int>> kvp in this.IndicesBuffers)
{ {
foreach (global::System.Int32 i in kvp.Value) foreach (int i in kvp.Value)
global::OpenTK.Graphics.OpenGL.GL.DeleteBuffer(i); GL.DeleteBuffer(i);
kvp.Value.Clear(); kvp.Value.Clear();
} }
this.IndicesBuffers.Clear(); this.IndicesBuffers.Clear();
foreach (global::System.Collections.Generic.KeyValuePair<global::System.Drawing.Image, global::System.Int32> kvp in this.dicTextureIDs) foreach (KeyValuePair<Image, int> kvp in this.dicTextureIDs)
global::OpenTK.Graphics.OpenGL.GL.DeleteBuffer(kvp.Value); GL.DeleteBuffer(kvp.Value);
this.dicTextureIDs.Clear(); this.dicTextureIDs.Clear();
foreach (global::System.Collections.Generic.KeyValuePair<global::System.Drawing.Color, global::System.Int32> kvp in this.dicColorIDs) foreach (KeyValuePair<Color, int> kvp in this.dicColorIDs)
global::OpenTK.Graphics.OpenGL.GL.DeleteBuffer(kvp.Value); GL.DeleteBuffer(kvp.Value);
this.dicColorIDs.Clear(); this.dicColorIDs.Clear();
this.HasRendered = false; this.HasRendered = false;
} }