/// <summary>
/// Handles the OpenGLDraw event of the openGLControl control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RenderEventArgs"/> instance containing the event data.</param>
public void openGLControl_OpenGLDraw(object sender, RenderEventArgs e)
{
// Get the OpenGL object.
gl = openGLControl.OpenGL;
// Clear the color and depth buffer.
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
// Load the identity matrix.
gl.LoadIdentity();
// Rotate around the Y axis.
//gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);
cord = ComInput.Coordinates.Instance;
this.ModelRotater(gl);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
// Draw a coloured parallelepiped.
gl.Begin(OpenGL.GL_QUADS);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, -1.0f);
//-------------------------------------
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, 1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, 1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, -1.0f);
//-------------------------------------
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, 1.0f);
//-------------------------------------
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, 1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, 1.0f);
//-------------------------------------
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(-2.0f, 0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(2.0f, 0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(2.0f, 0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(-2.0f, 0.25f, 1.0f);
//--------------------------------------
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(-2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(2.0f, -0.25f, 1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(-2.0f, -0.25f, 1.0f);
gl.End();
//-------------------Angle indicator prototype is here----------------------------------------------
gl.LoadIdentity();
gl.Rotate(cord.getX(), 1.0f, 0.0f, 0.0f);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Vertex(0.0f, 2.75f, 0.0f);
gl.Vertex(0.25f, 3.25f, 0.0f);
gl.Vertex(-0.25f, 3.25f, 0.0f);
gl.End();
gl.LoadIdentity();
gl.Rotate(cord.getZ(), 0.0f, 1.0f, 0.0f);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Vertex(0.0f, 0.0f, 2.75f);
gl.Vertex(0.0f, 0.25f, 3.25f);
gl.Vertex(0.0f, -0.25f, 3.25f);
gl.End();
gl.LoadIdentity();
gl.Rotate(cord.getY(), 0.0f, 0.0f, 1.0f);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Vertex(2.75f, 0.0f, 0.0f);
gl.Vertex(3.25f, 0.0f, 0.25f);
gl.Vertex(3.25f, 0.0f, -0.25f);
gl.End();
//------------------Circles of planes is here-----------------------------------------------
gl.LoadIdentity();
gl.Begin(OpenGL.GL_LINE_LOOP);
for(int i = 0; i < 200; i++)
{
float theta = 2.0f * 3.1415926f * (float)i / 200f;//get the current angle
float x = 3f * (float)System.Math.Cos(theta);//calculate the x component
float y = 3f * (float)System.Math.Sin(theta);//calculate the y component
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(0f, y + 0.0f, x + 0.0f);//output vertex
}
gl.End();
gl.Begin(OpenGL.GL_LINE_LOOP);
for (int i = 0; i < 200; i++)
{
float theta = 2.0f * 3.1415926f * (float)i / 200f;//get the current angle
float x = 3f * (float)System.Math.Cos(theta);//calculate the x component
float y = 3f * (float)System.Math.Sin(theta);//calculate the y component
gl.Vertex(x + 0.0f, 0.0f, y + 0.0f);//output vertex
}
gl.End();
gl.Begin(OpenGL.GL_LINE_LOOP);
for (int i = 0; i < 200; i++)
{
float theta = 2.0f * 3.1415926f * (float)i / 200f;//get the current angle
float x = 3f * (float)System.Math.Cos(theta);//calculate the x component
float y = 3f * (float)System.Math.Sin(theta);//calculate the y component
gl.Vertex(x + 0.0f, y + 0.0f, 0.0f);//output vertex
}
gl.End();
/* //--------------Coordinate axis's is here--------------------------------------------
gl.LoadIdentity();
gl.Begin(OpenGL.GL_LINE_STRIP);
gl.Color(1.0f, 1.0f, 1.0f);
gl.Vertex(-4.0f, 0.5f, 1.5f);
gl.Vertex(2.5f, 0.5f, 1.5f);
gl.Vertex(2.5f, 0.5f, -4.5f);
gl.Vertex(2.5f, 0.5f, 1.5f);
gl.Vertex(2.5f, 4.0f, 1.5f);
gl.End();
*/ //------------Shpere is here-----------------------------
gl.LoadIdentity();
gl.Color(0.85f, 0.85f, 0.85f, 0.5f);
gl.Begin(OpenGL.GL_QUADS);
for (int i = 0; i < 1; i++)
{
this.draw_sphere(gl, 3);
}
gl.End();
//---------------3D Text prototype is here-------------------
gl.LoadIdentity();
gl.Translate(0.0f, 3.5f, -3.0f);
gl.Color(0.0f, 1.0f, 0.65f);
gl.Rotate(270.0f, 0.0f, 1.0f, 0.0f);
gl.DrawText3D("a", 0.2f,
1.0f, 0.1f, "osX: 0");
// Nudge the rotation.
rotation += 2.0f;
}
private void SetupLigtening()
{
// enable lighting
float[] lightPos = new float[4] {
1000, 2000, 2000, 0
};
float[] lightAmbient = new float[4] {
0.1f, 0.1f, 0.15f, 1
};
float[] specIntens = new float[4] {
0.4f, 0.4f, 0.4f, 0
};
float[] black = new float[4] {
0, 0, 0, 0
};
float[] white = new float[4] {
1, 1, 1, 0
};
gl.Enable(OpenGL.GL_COLOR_MATERIAL);
gl.Enable(OpenGL.GL_LIGHT0);
gl.Enable(OpenGL.GL_NORMALIZE);
// light parameters
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_POSITION, lightPos);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_DIFFUSE, white);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_AMBIENT, lightAmbient);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPECULAR, white);
// material parameters
gl.Material(OpenGL.GL_FRONT, OpenGL.GL_DIFFUSE, white);
gl.Material(OpenGL.GL_FRONT, OpenGL.GL_AMBIENT, white);
gl.Material(OpenGL.GL_FRONT, OpenGL.GL_SPECULAR, specIntens);
gl.Material(OpenGL.GL_FRONT, OpenGL.GL_SHININESS, 5);
}
private void openGLControl1_OpenGLInitialized(object sender, EventArgs e)
{
gl = this.openGLControl1.OpenGL;
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.ShadeModel(OpenGL.GL_SMOOTH);
gl.Hint(OpenGL.GL_PERSPECTIVE_CORRECTION_HINT, OpenGL.GL_NICEST);
gl.Enable(OpenGL.GL_TEXTURE_2D);
}
/// <summary>
/// Initialises the supplied OpenGL instance for high quality rendering.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
public static void InitialiseHighQuality(OpenGL gl)
{
// Set parameters that give us some high quality settings.
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(OpenGL.GL_NORMALIZE);
gl.Enable(OpenGL.GL_LIGHTING);
gl.Enable(OpenGL.GL_TEXTURE_2D);
gl.ShadeModel(OpenGL.GL_SMOOTH);
gl.LightModel(OpenGL.GL_LIGHT_MODEL_TWO_SIDE, OpenGL.GL_TRUE);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
}
private void openGLControl1_OpenGLInitialized(object sender, EventArgs e)
{
OpenGL gl = this.openGLControl1.OpenGL; //Сохраним контекст для отрисовки
Camera.Init(); //Проинициализируем камеру стандартными настройками
Sun.Init(); //Проинициализируем Солнце стандартными настройками
hMap = new HeightMap("Map.png"); //Получим карту высот из файла, сожержащего шум Перлина
/*
* Настроим свет
* */
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_AMBIENT, Sun.Ambient);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_DIFFUSE, Sun.Diffuse);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPECULAR, Sun.Specular);
gl.LightModel(OpenGL.GL_LIGHT_MODEL_TWO_SIDE, OpenGL.GL_TRUE);
gl.Enable(OpenGL.GL_LIGHTING);
gl.Enable(OpenGL.GL_LIGHT0);
gl.ShadeModel(OpenGL.GL_SMOOTH);
gl.ClearColor(
1.0f * Color.SkyBlue.R / 255,
1.0f * Color.SkyBlue.G / 255,
1.0f * Color.SkyBlue.B / 255,
0
);
gl.Enable(OpenGL.GL_DEPTH_TEST);
/*
* Включим обработку текстур
* */
gl.Enable(OpenGL.GL_TEXTURE_2D);
texture.Create(gl, new Bitmap("Rock.jpg")); //зададим текстуру (по стандарту - камень)
gl.MatrixMode(OpenGL.GL_PROJECTION); //установим матрицу проекции
// Единичная матрица для последующих преобразований
gl.LoadIdentity();
// Преобразование
gl.Perspective(
60.0f,
(double)Width / (double)Height,
0.01,
Math.Max(hMap.Map.GetLength(0), hMap.Map.GetLength(1)) * STEP);
// Зададим модель отображения
gl.MatrixMode(OpenGL.GL_MODELVIEW);
texture.Bind(gl);
}
void drawTree(SharpGL.OpenGL gl, double dx, double dy, double dz, int index)//树的函数
{
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
gl.Enable(OpenGL.GL_ALPHA_TEST);
gl.Enable(OpenGL.GL_TEXTURE_2D);
gl.PushMatrix(); //强制刷新
gl.Translate(dx, dy, mydem.high[Convert.ToInt32(mydem.m - (dy + 50) / 0.5 - 1), Convert.ToInt32((dx + 50) / 0.5)]);
texture[treeId[index]].Bind(gl);
gl.Color(1f, 1f, 1f, 1f);
gl.Begin(OpenGL.GL_QUADS);
{
gl.TexCoord(0, 1);
gl.Vertex(-0.5f, 0f, 0f);
gl.TexCoord(1, 1);
gl.Vertex(0.5f, 0f, 0f);
gl.TexCoord(1, 0);
gl.Vertex(0.5f, 0f, 3.0f);
gl.TexCoord(0, 0);
gl.Vertex(-0.5f, 0.0f, 3.0f);
}
gl.End();
gl.Rotate(0f, 0f, 90);
gl.Begin(OpenGL.GL_QUADS);
{
gl.TexCoord(0, 1);
gl.Vertex(-0.5f, 0f, 0f);
gl.TexCoord(1, 1);
gl.Vertex(0.5f, 0f, 0f);
gl.TexCoord(1, 0);
gl.Vertex(0.5f, 0f, 3.0f);
gl.TexCoord(0, 0);
gl.Vertex(-0.5f, 0.0f, 3.0f);
}
gl.End();
gl.PopMatrix();
gl.Disable(OpenGL.GL_TEXTURE_2D);
gl.Disable(OpenGL.GL_BLEND);
gl.Disable(OpenGL.GL_ALPHA);
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushAttrib(AttributeMask.All);
gl.PushMatrix();
if (texture != null)
{
gl.Enable(OpenGL.GL_TEXTURE_2D);
texture.Push(gl);
}
gl.Begin(BeginMode.Quads);
{
gl.Color(color.GetInArrWithAlpha());
gl.Normal(0, 1, 0);
gl.TexCoord(0, 0);
gl.Vertex(position.x - lenByX / 2, position.y, position.z + lenByZ / 2);
gl.TexCoord(lenByX, 0);
gl.Vertex(position.x + lenByX / 2, position.y, position.z + lenByZ / 2);
gl.TexCoord(lenByX, lenByZ);
gl.Vertex(position.x + lenByX / 2, position.y, position.z - lenByZ / 2);
gl.TexCoord(0, lenByZ);
gl.Vertex(position.x - lenByX / 2, position.y, position.z - lenByZ / 2);
}
gl.End();
if (texture != null)
{
texture.Pop(gl);
}
gl.PopMatrix();
gl.PopAttrib();
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Create the evaluator.
gl.Map1(OpenGL.GL_MAP1_VERTEX_3, // Use and produce 3D points.
0, // Low order value of 'u'.
1, // High order value of 'u'.
3, // Size (bytes) of a control point.
ControlPoints.Width, // Order (i.e degree plus one).
ControlPoints.ToFloatArray()); // The control points.
// Enable the type of evaluator we wish to use.
gl.Enable(OpenGL.GL_MAP1_VERTEX_3);
// Beging drawing a line strip.
gl.Begin(OpenGL.GL_LINE_STRIP);
// Now draw it.
for (int i = 0; i <= segments; i++)
{
gl.EvalCoord1((float)i / segments);
}
gl.End();
// Draw the control points.
ControlPoints.Draw(gl, DrawControlPoints, DrawControlGrid);
}
void IRenderable.Render(OpenGL gl, RenderMode renderMode)
{
if (positionBuffer != null && colorBuffer != null && radiusBuffer != null)
{
if (this.shaderProgram == null)
{
this.shaderProgram = InitShader(gl, renderMode);
}
if (this.vertexArrayObject == null)
{
CreateVertexArrayObject(gl, renderMode);
}
BeforeRendering(gl, renderMode);
if (this.RenderGrid && this.vertexArrayObject != null)
{
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(this.vertexArrayObject[0]);
gl.DrawArrays(OpenGL.GL_POINTS, 0, count);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
}
AfterRendering(gl, renderMode);
}
}
public FormSharpGLTexturesSample()
{
InitializeComponent();
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
// A bit of extra initialisation here, we have to enable textures.
gl.Enable(OpenGL.GL_TEXTURE_2D);
// Create our texture object from a file. This creates the texture for OpenGL.
texture.Create(gl, "Crate.bmp");
// Create a light.
/*
* Light light = new Light()
* {
* On = true,
* Position = new Vertex(0, 0, 0),
* GLCode = OpenGL.GL_LIGHT0
* };
*/
//Camera numbers set up
float fov = 70.0f,
aspect = (float)openGLControl1.Width / (float)openGLControl1.Height,
zNear = 0.1f,
zFar = 100.0f;
Vertex eyeVertex = new Vertex(2.0f, 2.0f, 2.0f);
Vertex centerVertex = new Vertex(0.0f, 0.0f, 0.0f);
Vertex upVertex = new Vertex(0.0f, 1.0f, 0.0f);
cam = new Camera(gl, fov, aspect, zNear, zFar, eyeVertex, centerVertex, upVertex);
}
public FormExample2()
{
InitializeComponent();
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
// We need to load the texture from file.
textureImage = new Bitmap("Crate.bmp");
// A bit of extra initialisation here, we have to enable textures.
gl.Enable(OpenGL.TEXTURE_2D);
// Get one texture id, and stick it into the textures array.
gl.GenTextures(1, textures);
// Bind the texture.
gl.BindTexture(OpenGL.TEXTURE_2D, textures[0]);
// Tell OpenGL where the texture data is.
gl.TexImage2D(OpenGL.TEXTURE_2D, 0, 3, textureImage.Width, textureImage.Height, 0, OpenGL.RGB, OpenGL.UNSIGNED_BYTE,
textureImage.LockBits(new Rectangle(0, 0, textureImage.Width, textureImage.Height),
ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb).Scan0);
gl.TexParameter(OpenGL.TEXTURE_2D, OpenGL.TEXTURE_MIN_FILTER, OpenGL.LINEAR); // Linear Filtering
gl.TexParameter(OpenGL.TEXTURE_2D, OpenGL.TEXTURE_MAG_FILTER, OpenGL.LINEAR); // Linear Filtering
}
private void openGLControl1_OpenGLDraw(object sender, SharpGL.RenderEventArgs args)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.LoadIdentity();
gl.LookAt(0, 20, 30, 0, 0, 0, 0, 1, 0);
//desenha o piso
gl.Enable(OpenGL.GL_TEXTURE_2D);
grass.Bind(gl);
gl.Begin(OpenGL.GL_QUADS);
gl.Color(0.0f, 1.0f, 0.0f);
gl.TexCoord(0.0f, 0.0f); gl.Vertex(-100.0f, 0.0f, -100.0f);
gl.TexCoord(100.0f, 0.0f); gl.Vertex(100.0f, 0.0f, -100.0f);
gl.TexCoord(100.0f, 100.0f); gl.Vertex(100.0f, 0.0f, 100.0f);
gl.TexCoord(0.0f, 100.0f); gl.Vertex(-100.0f, 0.0f, 100.0f);
gl.End();
gl.Disable(OpenGL.GL_TEXTURE_2D);
foreach (Polygon polygon in polygons)
{
polygon.PushObjectSpace(gl);
polygon.Render(gl, SharpGL.SceneGraph.Core.RenderMode.Render);
polygon.PopObjectSpace(gl);
}
gl.Flush();
}
private void openGLControl1_OpenGLInitialized(object sender, EventArgs e)
{
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
// We need to load the texture from file.
textureImage = new Bitmap("Crate.bmp");
// A bit of extra initialisation here, we have to enable textures.
gl.Enable(OpenGL.GL_TEXTURE_2D);
// Get one texture id, and stick it into the textures array.
gl.GenTextures(1, textures);
// Bind the texture.
gl.BindTexture(OpenGL.GL_TEXTURE_2D, textures[0]);
// Tell OpenGL where the texture data is.
gl.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, 3, textureImage.Width, textureImage.Height, 0, OpenGL.GL_BGR, OpenGL.GL_UNSIGNED_BYTE,
textureImage.LockBits(new Rectangle(0, 0, textureImage.Width, textureImage.Height),
ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb).Scan0);
// Specify linear filtering.
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_LINEAR);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_LINEAR);
}
public void Render(SharpGL.OpenGL gl, SharpGL.SceneGraph.Core.RenderMode renderMode)
{
// update matrix and bind shader program
mat4 projectionMatrix = camera.GetProjectionMat4();
mat4 viewMatrix = camera.GetViewMat4();
mat4 modelMatrix = glm.scale(mat4.identity(), new vec3(1, 1, this.ZAxisScale));
shaderProgram.Bind(gl);
shaderProgram.SetUniformMatrix4(gl, strprojectionMatrix, projectionMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, strviewMatrix, viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, strmodelMatrix, modelMatrix.to_array());
gl.BindVertexArray(vao[0]);
// 启用Primitive restart
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);// 截断图元（四边形带、三角形带等）的索引值。
//GL.DrawArrays(primitiveMode, 0, vertexCount);
gl.DrawElements((uint)primitiveMode, vertexCount + (this.pipe.Count - 1) * 2, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
// unbind shader program
shaderProgram.Unbind(gl);
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
gl.PushAttrib(AttributeMask.All);
gl.PushClientAttrib(OpenGL.GL_CLIENT_ALL_ATTRIB_BITS);
gl.VertexPointer(3, 0, vertexs);
gl.NormalPointer(OpenGL.GL_FLOAT, 0, normals);
gl.TexCoordPointer(2, OpenGL.GL_FLOAT, 0, texCoord);
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
//gl.EnableClientState(OpenGL.GL_COLOR_ARRAY);
gl.EnableClientState(OpenGL.GL_NORMAL_ARRAY);
gl.EnableClientState(OpenGL.GL_TEXTURE_COORD_ARRAY);
gl.Translate(position.x, position.y + sizeY / 2, position.z);
gl.Color(color.GetInArrWithAlpha());
if (texture != null)
{
gl.Enable(OpenGL.GL_TEXTURE_2D);
texture.Bind(gl);
}
else
{
gl.Disable(OpenGL.GL_TEXTURE_2D);
}
gl.DrawArrays(OpenGL.GL_QUADS, 0, 24);
gl.PopClientAttrib();
gl.PopAttrib();
gl.PopMatrix();
}
public void RenderWithStruct(SharpGL.OpenGL gl, SharpGL.SceneGraph.Core.RenderMode renderMode)
{
//if (!this.IsRenderable())
//return;
ShaderProgram shader = this.shader; //GetShader(gl, renderMode);
shader.Bind(gl);
// 用VAO+EBO进行渲染。
// Bind the out vertex array.
//gl.BindVertexArray(vao[0]);
gl.BindVertexArray(vertexArrayObject);
// Draw the square.
//gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, ebo[0]);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.triangleBufferObject);
// 启用Primitive restart
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);// 截断图元（四边形带、三角形带等）的索引值。
gl.DrawElements(this.primitiveMode, this.triangleIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
// Unbind our vertex array and shader.
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
shader.Unbind(gl);
}
public TileSetEditor()
{
InitializeComponent();
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl1 = this.openGLControl1.OpenGL;
SharpGL.OpenGL gl2 = this.openGLControl2.OpenGL;
// A bit of extra initialisation here, we have to enable textures.
gl1.Enable(OpenGL.GL_TEXTURE_2D);
gl2.Enable(OpenGL.GL_TEXTURE_2D);
//transparancy crap needs to work at somepoint
//gl1.Enable(OpenGL.GL_BLEND);
//gl1.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
//gl1.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, OpenGL.GL_RGBA, imgWidth, imgHeight, 0, OpenGL.GL_RGBA, OpenGL.GL_UNSIGNED_BYTE,);
openGLControl1.MouseClick += HandleMouseClick1;
openGLControl2.MouseClick += HandleMouseClick2;
//openGLControl2.MouseDown += HandleMouseDown; Deal with this crap later
//openGLControl2.MouseUp += HandleMouseUp;
tileSet.ChangeTileSetSize(100);
hScrollBar1.Visible = false;
vScrollBar1.Visible = false;
hScrollBar2.Visible = false;
vScrollBar2.Visible = false;
}
private void openGLControl1_OpenGLDraw(object sender, RenderEventArgs e)
{
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.Color(1.0f, 1.0f, 1.0f);
gl.MatrixMode(OpenGL.GL_PROJECTION);
gl.LoadIdentity();
cam.Look();
gl.Disable(OpenGL.GL_TEXTURE_2D);
PlaneSurfaceRenderer psr = new PlaneSurfaceRenderer(16);
psr.render(gl);
texture.Bind(gl);
gl.Enable(OpenGL.GL_TEXTURE_2D);
foreach (ShapeRenderer shape in listShape)
{
shape.render(gl);
}
}
//设置抗锯齿开关（实验性）
//开启后在画圆时会出问题
public void setSmooth(bool value)
{
if (value == true)
{
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
gl.Enable(OpenGL.GL_POINT_SMOOTH);
gl.Enable(OpenGL.GL_LINE_SMOOTH);
gl.Enable(OpenGL.GL_POLYGON_SMOOTH);
}
else
{
gl.Disable(OpenGL.GL_BLEND);
gl.Disable(OpenGL.GL_POINT_SMOOTH);
gl.Disable(OpenGL.GL_LINE_SMOOTH);
gl.Disable(OpenGL.GL_POLYGON_SMOOTH);
}
}
public Form1()
{
InitializeComponent();
SharpGL.OpenGL gl = this.openGLControl.OpenGL;
gl.Enable(OpenGL.GL_TEXTURE_2D);
//gl.LoadIdentity();
string a = "Crate.bmp";
texture.Create(gl, a);
}
public override void OnLoad(OpenGL gl)
{
gl.Enable(OpenGL.GL_CULL_FACE);
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(BlendingSourceFactor.SourceAlpha, BlendingDestinationFactor.OneMinusSourceAlpha);
_camera = new OrthographicCamera();
_camera.View *= Mat4.RotateY(Angle.FromDegrees(15));
_shader = new BasicShader(gl);
_modelUniform = gl.GetUniformLocation(_shader.Handle, "Model");
_viewUniform = gl.GetUniformLocation(_shader.Handle, "View");
_projectionUniform = gl.GetUniformLocation(_shader.Handle, "Projection");
_graph = new OpenGLSceneGraph();
_graph.Nodes.Add(new CoordinateSystemLeaf(gl, _shader, _model.Features.OfType<CoordinateSystem>()));
_graph.Nodes.Add(new DatumPlaneLeaf(gl, _shader, _model.Features.OfType<DatumPlane>()));
_graph.Nodes.Add(new GeometryLeaf(gl, _shader));
}
private void cbLightEnabled_CheckedChanged(object sender, EventArgs e)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
if (cbLightEnabled.Checked)
{
gl.Enable(OpenGL.GL_LIGHT0);
}
else
{
gl.Disable(OpenGL.GL_LIGHT0);
}
}
public void Initialize(OpenGL gl)
{
this.gl = gl;
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.DepthFunc(DepthFunction.LessThanOrEqual);
gl.ClearDepth(1.0);
gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.Hint(HintTarget.PerspectiveCorrection, HintMode.Nicest);
gl.Hint(HintTarget.LineSmooth, HintMode.Nicest);
gl.Hint(HintTarget.PointSmooth, HintMode.Nicest);
gl.Hint(HintTarget.PolygonSmooth, HintMode.Nicest);
gl.Enable(OpenGL.GL_SMOOTH);
gl.Enable(OpenGL.GL_LINE_SMOOTH);
gl.Enable(OpenGL.GL_POINT_SMOOTH);
gl.Enable(OpenGL.GL_MULTISAMPLE);
gl.MinSampleShading(4.0f);
}
private void openGLControl1_OpenGLInitialized(object sender, EventArgs e)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.ClearDepth(1.0f);
// Setup lightning
gl.Enable(OpenGL.GL_LIGHTING);
gl.Enable(OpenGL.GL_LIGHT0);
gl.Enable(OpenGL.GL_LIGHT1);
gl.Enable(OpenGL.GL_COLOR_MATERIAL);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_AMBIENT, new float[] { 0.8f, 0.8f, 0.8f });
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_DIFFUSE, new float[] { 1f, 1f, 1f });
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_POSITION, lightPos0);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPOT_CUTOFF, 45);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPOT_EXPONENT, 15);
gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPOT_DIRECTION, new float[] { 1f, 1f, 1f });
gl.Material(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_DIFFUSE, new float[] { 1, 1, 1, 1 });
gl.Material(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_AMBIENT, new float[] { 1, 1, 1, 1 });
textureImage = new Bitmap("texture.bmp");
gl.Enable(OpenGL.GL_TEXTURE_2D);
// Get one texture id, and stick it into the textures array.
gl.GenTextures(1, textures);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, textures[0]);
// Set texture data.
gl.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, 3, textureImage.Width, textureImage.Height, 0, OpenGL.GL_BGR, OpenGL.GL_UNSIGNED_BYTE,
textureImage.LockBits(new Rectangle(0, 0, textureImage.Width, textureImage.Height),
ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb).Scan0);
// Specify linear filtering.
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_LINEAR);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_LINEAR);
}
public mainForm()
{
InitializeComponent();
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
// A bit of extra initialisation here, we have to enable textures.
gl.Enable(OpenGL.GL_TEXTURE_2D);
// Create our texture object from a file. This creates the texture for OpenGL.
Trace.WriteLine(System.IO.Directory.GetCurrentDirectory());
texture.Create(gl, "Crate.bmp");
}
public FormSharpGLTexturesSample()
{
InitializeComponent();
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
// A bit of extra initialisation here, we have to enable textures.
gl.Enable(OpenGL.GL_TEXTURE_2D);
// Create our texture object from a file. This creates the texture for OpenGL.
texture.Create(gl, "Crate.bmp");
}
/// <summary>
/// This function sets all of the lights parameters into OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
public virtual void Bind(OpenGL gl)
{
if (on)
{
// Enable this light.
gl.Enable(OpenGL.GL_LIGHTING);
gl.Enable(glCode);
// The light is on, so set it's properties.
gl.Light(glCode, OpenGL.GL_AMBIENT, ambient);
gl.Light(glCode, OpenGL.GL_DIFFUSE, diffuse);
gl.Light(glCode, OpenGL.GL_SPECULAR, specular);
gl.Light(glCode, OpenGL.GL_POSITION, new float[] { position.X, position.Y, position.Z, 1.0f });
// 180 degree cutoff gives an omnidirectional light.
gl.Light(GLCode, OpenGL.GL_SPOT_CUTOFF, 180.0f);
}
else
{
gl.Disable(glCode);
}
}
private void openGLControl1_OpenGLInitialized(object sender, EventArgs e)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
textureImage = new Bitmap("MyPicture/Texture.bmp");
gl.Enable(OpenGL.GL_TEXTURE_2D);
gl.GenTextures(1, textures);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, textures[0]);
gl.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, 3, textureImage.Width, textureImage.Height, 0, OpenGL.GL_BGR, OpenGL.GL_UNSIGNED_BYTE,
textureImage.LockBits(new Rectangle(0, 0, textureImage.Width, textureImage.Height),
ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb).Scan0);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_LINEAR);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_LINEAR);
}
public void Initialise(OpenGL gl)
{
// Create the per pixel shader.
shaderPerPixel = new ShaderProgram();
shaderPerPixel.Create(gl,
ManifestResourceLoader.LoadTextFile(@"Shaders\PerPixel.vert"),
ManifestResourceLoader.LoadTextFile(@"Shaders\PerPixel.frag"), null);
shaderPerPixel.BindAttributeLocation(gl, VertexAttributes.Position, "Position");
shaderPerPixel.BindAttributeLocation(gl, VertexAttributes.Normal, "Normal");
gl.ClearColor(0f,0f, 0f, 1f);
// Immediate mode only features!
gl.Enable(OpenGL.GL_TEXTURE_2D);
}
public void Render(SharpGL.OpenGL gl, RenderMode renderMode)
{
if (this._colorVertexes.Size <= 0)
{
return;
}
unsafe
{
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(0X8861);
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.EnableClientState(OpenGL.GL_COLOR_ARRAY);
gl.VertexPointer(3, OpenGL.GL_FLOAT, 0, (IntPtr)this._colorVertexes.Centers);
gl.ColorPointer(3, OpenGL.GL_BYTE, 0, (IntPtr)this._colorVertexes.Colors);
gl.DrawArrays(OpenGL.GL_POINTS, 0, this._colorVertexes.Size);
gl.DisableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.DisableClientState(OpenGL.GL_COLOR_ARRAY);
}
}
/// <summary>
/// Render to the provided instance of OpenGL.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="renderMode">The render mode.</param>
public override void Render(OpenGL gl, RenderMode renderMode)
{
// Create the evaluator.
gl.Map2(OpenGL.GL_MAP2_VERTEX_3, // Use and produce 3D points.
0, // Low order value of 'u'.
1, // High order value of 'u'.
3, // Size (bytes) of a control point.
ControlPoints.Width, // Order (i.e degree plus one).
0, // Low order value of 'v'.
1, // High order value of 'v'
ControlPoints.Width * 3, // Size in bytes of a 'row' of points.
ControlPoints.Height, // Order (i.e degree plus one).
ControlPoints.ToFloatArray()); // The control points.
gl.Enable(OpenGL.GL_MAP2_VERTEX_3);
gl.Enable(OpenGL.GL_AUTO_NORMAL);
gl.MapGrid2(20, 0, 1, 20, 0, 1);
// Now draw it.
gl.EvalMesh2(OpenGL.GL_FILL, 0, 20, 0, 20);
// Draw the control points.
ControlPoints.Draw(gl, DrawControlPoints, DrawControlGrid);
}
public Form1()
{
InitializeComponent();
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = AnT.OpenGL;
// A bit of extra initialisation here, we have to enable textures.
gl.Enable(OpenGL.GL_TEXTURE_2D);
// Create our texture object from a file. This creates the texture for OpenGL.
//texture.Create(gl, "earthmap1k.jpg");
//texture.Create(gl, "realistic_earth.jpg");
//texture.Create(gl, "earth.jpg");
texture.Create(gl, "earth_flip.jpg");
//texture.Create(gl, "earth.bmp");
//texture.Create(gl, "crate.bmp");
}
private void openGLControl1_OpenGLDraw(object sender, SharpGL.RenderEventArgs args)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.Enable(OpenGL.GL_TEXTURE_2D);
if (playerLives != 0)
{
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.LoadIdentity();
gl.Translate(0.0f, 0.0f, -20.0f);
main.Create(gl, "..\\..\\main.png");
gl.PushMatrix();
gl.Begin(OpenGL.GL_QUADS);
gl.TexCoord(1, 1); gl.Vertex(-1, -1);
gl.TexCoord(0, 1); gl.Vertex(1, -1);
gl.TexCoord(0, 0); gl.Vertex(1, 1);
gl.TexCoord(1, 0); gl.Vertex(-1, 1);
gl.End();
gl.PopMatrix();
currentFrame = currentFrame + 1;
if (currentFrame % 28 == 0)
{
createEnemy();
currentFrame = 0;
}
moveEnemy();
if (enemyList != null)
{
for (int i = 0; i < enemyList.Count; i++)
{
enemyList[i].drawEnemy(gl);
}
}
gl.Flush();
}
else
{
label2.Text = "Game over";
}
}
public FormSharpGLTexturesSample()
{
InitializeComponent();
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
// A bit of extra initialisation here, we have to enable textures.
gl.Enable(OpenGL.GL_TEXTURE_2D);
// Create our texture object from a file. This creates the texture for OpenGL.
texture.Create(gl, "Crate.bmp");
// Create a light.
Light light = new Light()
{
On = true,
Position = new Vertex(3, 10, 3),
GLCode = OpenGL.GL_LIGHT0
};
}
/// <summary>
/// This is called when a face is interactable, so highlight it.
/// </summary>
void IInteractable.DrawPick(OpenGL gl)
{
// Save all the attributes.
gl.PushAttrib(OpenGL.ALL_ATTRIB_BITS);
// Disable lighting, set colour to red etc.
gl.Disable(OpenGL.LIGHTING);
gl.DepthFunc(OpenGL.LEQUAL);
// Now draw it with a faint red.
gl.Enable(OpenGL.BLEND);
gl.BlendFunc(OpenGL.SRC_ALPHA, OpenGL.ONE_MINUS_SRC_ALPHA);
gl.Color(1, 0, 0, 0.2f);
// Draw the face.
gl.Begin(OpenGL.POLYGON);
foreach (Index index in indices)
{
gl.Vertex(parentpoly.Vertices[index.Vertex]);
}
gl.End();
gl.Disable(OpenGL.BLEND);
// Draw the face.
gl.Begin(OpenGL.LINE_LOOP);
for (int i = 0; i < indices.Count - 1; i++)
{
gl.Vertex(parentpoly.Vertices[indices[i].Vertex]);
}
gl.End();
gl.PopAttrib();
}
void IRenderable.Render(OpenGL gl, RenderMode renderMode)
{
if (positionBuffer == null || colorBuffer == null) { return; }
if (this.shaderProgram == null)
{
this.shaderProgram = InitShader(gl, renderMode);
}
if (this.vertexArrayObject == null)
{
CreateVertexArrayObject(gl, renderMode);
}
BeforeRendering(gl, renderMode);
if (this.RenderGridWireframe && this.vertexArrayObject != null)
{
//if (wireframeIndexBuffer != null)
if (positionBuffer != null && colorBuffer != null && indexBuffer != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 1.0f);// shader一律上白色。
gl.Disable(OpenGL.GL_LINE_STIPPLE);
gl.Disable(OpenGL.GL_POLYGON_STIPPLE);
gl.Enable(OpenGL.GL_LINE_SMOOTH);
gl.Enable(OpenGL.GL_POLYGON_SMOOTH);
gl.ShadeModel(SharpGL.Enumerations.ShadeModel.Smooth);
gl.Hint(SharpGL.Enumerations.HintTarget.LineSmooth, SharpGL.Enumerations.HintMode.Nicest);
gl.Hint(SharpGL.Enumerations.HintTarget.PolygonSmooth, SharpGL.Enumerations.HintMode.Nicest);
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Lines);
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(this.vertexArrayObject[0]);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, indexBuffer[0]);
gl.DrawElements(OpenGL.GL_QUAD_STRIP, this.indexBufferLength, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Filled);
gl.Disable(OpenGL.GL_POLYGON_SMOOTH);
}
}
if (this.RenderGrid && this.vertexArrayObject != null)
{
if (positionBuffer != null && colorBuffer != null && indexBuffer != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 0.0f);// shader根据uv buffer来上色。
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(this.vertexArrayObject[0]);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, indexBuffer[0]);
gl.DrawElements(OpenGL.GL_QUAD_STRIP, this.indexBufferLength, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
}
}
AfterRendering(gl, renderMode);
}
protected void BeforeRendering(OpenGL gl, RenderMode renderMode)
{
IScientificCamera camera = this.camera;
if (camera != null)
{
if (camera.CameraType == CameraTypes.Perspecitive)
{
IPerspectiveViewCamera perspective = camera;
this.projectionMatrix = perspective.GetProjectionMat4();
this.viewMatrix = perspective.GetViewMat4();
}
else if (camera.CameraType == CameraTypes.Ortho)
{
IOrthoViewCamera ortho = camera;
this.projectionMatrix = ortho.GetProjectionMat4();
this.viewMatrix = ortho.GetViewMat4();
}
else
{ throw new NotImplementedException(); }
}
gl.Enable(OpenGL.GL_TEXTURE_2D);
this.texture.Bind(gl);
modelMatrix = glm.scale(mat4.identity(), new vec3(1, 1, this.ZAxisScale));
ShaderProgram shaderProgram = this.shaderProgram;
// Bind the shader, set the matrices.
shaderProgram.Bind(gl);
shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", projectionMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "viewMatrix", viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "modelMatrix", modelMatrix.to_array());
shaderProgram.SetUniform1(gl, "tex", this.texture.TextureName);
shaderProgram.SetUniform1(gl, "brightness", this.Brightness);
shaderProgram.SetUniform1(gl, "opacity", this.Opacity);
gl.Enable(OpenGL.GL_POLYGON_SMOOTH);
gl.Hint(OpenGL.GL_POLYGON_SMOOTH_HINT, OpenGL.GL_NICEST);
}
/// <summary>
/// 渲染基质
/// </summary>
/// <param name="gl"></param>
/// <param name="renderMode"></param>
private void DoRenderMatrix(OpenGL gl, RenderMode renderMode)
{
if (this.positionBuffer == null || this.colorBuffer == null) { return; }
if (this.RenderGrid && this.matrixVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 0.0f);
shaderProgram.SetUniform1(gl, "opacity", this.Opacity);
gl.Enable(OpenGL.GL_POLYGON_OFFSET_FILL);
gl.PolygonOffset(1.0f, 1.0f);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(matrixVertexArrayObject[0]);
switch (this.MatrixType)
{
case MatrixFormat.Triangle:
gl.DrawArrays(this.matrixRenderMode, 0, this.MatrixVertexOrIndexCount);
break;
case MatrixFormat.Tetrahedron:
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
case MatrixFormat.TriangularPrism:
// 先渲染三棱柱的上下三角形
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.MatrixVertexOrIndexCount);
// 再渲染三棱柱的三个侧面
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
default:
break;
}
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
gl.Disable(OpenGL.GL_POLYGON_OFFSET_FILL);
}
if (this.RenderGridWireframe && this.matrixVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 1.0f);
shaderProgram.SetUniform1(gl, "opacity", this.Opacity);
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Lines);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(SharpGL.Enumerations.BlendingSourceFactor.SourceAlpha, SharpGL.Enumerations.BlendingDestinationFactor.OneMinusSourceAlpha);
gl.BindVertexArray(matrixVertexArrayObject[0]);
switch (this.MatrixType)
{
case MatrixFormat.Triangle:
gl.DrawArrays(this.matrixRenderMode, 0, this.MatrixVertexOrIndexCount);
break;
case MatrixFormat.Tetrahedron:
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
case MatrixFormat.TriangularPrism:
// 先渲染三棱柱的上下三角形
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.MatrixVertexOrIndexCount / 9 * 6);
// 再渲染三棱柱的三个侧面
gl.Enable(OpenGL.GL_PRIMITIVE_RESTART);
gl.PrimitiveRestartIndex(uint.MaxValue);
gl.BindBuffer(OpenGL.GL_ELEMENT_ARRAY_BUFFER, this.matrixIndexBuffer[0]);
gl.DrawElements(this.matrixRenderMode, this.MatrixVertexOrIndexCount, OpenGL.GL_UNSIGNED_INT, IntPtr.Zero);
gl.Disable(OpenGL.GL_PRIMITIVE_RESTART);
break;
default:
break;
}
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Filled);
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_BLEND);
}
}
public void CreateBasicLighting(OpenGL _context, Vector4 _position)
{
//ThrowIfNull(_context);
_context.Enable(OpenGL.GL_DEPTH_TEST);
float[] global_ambient = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
float[] light0ambient = new float[] { 0.2f, 0.2f, 0.2f, 1.0f };
float[] light0diffuse = new float[] { 0.3f, 0.3f, 0.3f, 1.0f };
float[] light0specular = new float[] { 0.8f, 0.8f, 0.8f, 1.0f };
float[] lmodel_ambient = new float[] { 0.2f, 0.2f, 0.2f, 1.0f };
_context.LightModel(OpenGL.GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
_context.LightModel(OpenGL.GL_LIGHT_MODEL_AMBIENT, global_ambient);
_context.Light(OpenGL.GL_LIGHT0, OpenGL.GL_POSITION, _position.ToFloatArray());
_context.Light(OpenGL.GL_LIGHT0, OpenGL.GL_AMBIENT, light0ambient);
_context.Light(OpenGL.GL_LIGHT0, OpenGL.GL_DIFFUSE, light0diffuse);
_context.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPECULAR, light0specular);
_context.Enable(OpenGL.GL_LIGHTING);
_context.Enable(OpenGL.GL_LIGHT0);
_context.ShadeModel(OpenGL.GL_SMOOTH);
}
/// <summary>
/// This is called when a face is interactable, so highlight it.
/// </summary>
void IInteractable.DrawPick(OpenGL gl)
{
// Save all the attributes.
gl.PushAttrib(OpenGL.ALL_ATTRIB_BITS);
// Disable lighting, set colour to red etc.
gl.Disable(OpenGL.LIGHTING);
gl.DepthFunc(OpenGL.LEQUAL);
// Now draw it with a faint red.
gl.Enable(OpenGL.BLEND);
gl.BlendFunc(OpenGL.SRC_ALPHA, OpenGL.ONE_MINUS_SRC_ALPHA);
gl.Color(1, 0, 0, 0.2f);
// Draw the face.
gl.Begin(OpenGL.POLYGON);
foreach(Index index in indices)
gl.Vertex(parentpoly.Vertices[index.Vertex]);
gl.End();
gl.Disable(OpenGL.BLEND);
// Draw the face.
gl.Begin(OpenGL.LINE_LOOP);
for(int i = 0; i < indices.Count - 1; i++)
gl.Vertex(parentpoly.Vertices[indices[i].Vertex]);
gl.End();
gl.PopAttrib();
}
public void InitTexture(OpenGL renderer)
{
if (String.IsNullOrEmpty(Texture))
{
return;
}
// We need to load the texture from file.
var textureImage = new Bitmap(Texture);
renderer.Enable(OpenGL.GL_TEXTURE_2D);
// Get one texture id, and stick it into the textures array.
renderer.GenTextures(1, _textures);
// Bind the texture.
renderer.BindTexture(OpenGL.GL_TEXTURE_2D, _textures[0]);
// Tell OpenGL where the texture data is.
renderer.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, 3, textureImage.Width, textureImage.Height, 0, OpenGL.GL_BGR, OpenGL.GL_UNSIGNED_BYTE,
textureImage.LockBits(new Rectangle(0, 0, textureImage.Width, textureImage.Height),
ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb).Scan0);
// Specify linear filtering.
renderer.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_LINEAR);
}
private void RecursiveRender(Assimp.Scene scene, Node node, ref OpenGL gl)
{
Matrix4 m = FromMatrix(node.Transform);
m.Transpose();
gl.PushMatrix();
gl.MultMatrix(FloatFromMatrix(m));
if (node.HasMeshes)
{
foreach (int index in node.MeshIndices)
{
Mesh mesh = scene.Meshes[index];
ApplyMaterial(m_model.Materials[mesh.MaterialIndex], ref gl);
if (mesh.HasNormals)
{
gl.Enable(OpenGL.GL_LIGHTING);
}
else
{
gl.Disable(OpenGL.GL_LIGHTING);
}
bool hasColors = mesh.HasVertexColors(0);
if (hasColors)
{
gl.Enable(OpenGL.GL_COLOR_MATERIAL);
}
else
{
gl.Disable(OpenGL.GL_COLOR_MATERIAL);
}
bool hasTexCoords = mesh.HasTextureCoords(0);
foreach (Assimp.Face face in mesh.Faces)
{
BeginMode faceMode;
switch (face.IndexCount)
{
case 1:
faceMode = BeginMode.Points;
break;
case 2:
faceMode = BeginMode.Lines;
break;
case 3:
faceMode = BeginMode.Triangles;
break;
default:
faceMode = BeginMode.Polygon;
break;
}
gl.Begin(faceMode);
for (int i = 0; i < face.IndexCount; i++)
{
int indice = face.Indices[i];
if (hasColors)
{
Color4 vertColor = FromColor(mesh.VertexColorChannels[0][indice]);
if (mesh.HasNormals)
{
Vector3 normal = FromVector(mesh.Normals[indice]);
gl.Normal(normal.X, normal.Y, normal.Z);
}
if (hasTexCoords)
{
Vector3 uvw = FromVector(mesh.TextureCoordinateChannels[0][indice]);
gl.TexCoord(uvw.X, 1 - uvw.Y);
}
Vector3 pos = FromVector(mesh.Vertices[indice]);
gl.Vertex(pos.X, pos.Y, pos.Z);
}
gl.End();
}
}
}
for (int i = 0; i < node.ChildCount; i++)
{
RecursiveRender(m_model, node.Children[i], ref gl);
}
}
}
/// <summary>
/// Source: http://www.opengl-tutorial.org/miscellaneous/clicking-on-objects/picking-with-an-opengl-hack/
/// It's recommended to read the source before using this algorithm.
/// </summary>
/// <param name="scene">The OpenGLScene.</param>
/// <param name="point">The 2D point.</param>
/// <param name="models">The drawn models.</param>
/// <param name="performanceScaleValue">A factor that affects performance by scaling the size of the temperory viewport.</param>
/// <returns>The model on this location or null.</returns>
public static int GetModelAtPointHack(Point point, IEnumerable<ElementAndTransformation> models,
int[] viewport, ModelView modelview, Projection projection, Normal normal, float performanceScaleValue = 1)
{
return -1; // TODO
int id = -1;
int width = (int)(viewport[2] * performanceScaleValue);
int height = (int)(viewport[3] * performanceScaleValue);
int x = (int)(point.X * performanceScaleValue);
int y = height - (int)(point.Y * performanceScaleValue);
#region create a temperory gl to prevent flickering
OpenGL gl = new OpenGL();
// Create OpenGL.
var openGLVersion = OpenGLVersion.OpenGL2_1;
var renderContextType = RenderContextType.FBO;
gl.Create(openGLVersion, renderContextType, 1, 1, 32, null);
// Set the dimensions and viewport.
gl.SetDimensions(width, height);
gl.Viewport(0, 0, width, height);
// Make GL current.
gl.MakeCurrent();
gl.Enable(OpenGL.GL_DEPTH_TEST);
//gl.Clear(OpenGL.GL_DEPTH_CLEAR_VALUE);
#endregion create a temperory gl to prevent flickering
// Initialize the shader for our new GL.
//var esp = Shaders.LoadSimpleShader(gl);
//var idxModelTransformation = new List<Tuple<int, int>>(); // Item1 = idx in models; Item2 = idx of model.Transformations
//var buffersToBeRemoved = new List<uint>();
//esp.UseProgram(gl, () =>
//{
// // Set the matrices.
// esp.ApplyMVPNMatrices(gl, modelview, projection, normal);
// var curModelId = 0;
// // render models, using a temperory color
// for (int i = 0; i < models.Count(); )
// {
// var model = models.ElementAt(i);
// // Extract the color. Since we don't need the i in this loop anymore, we can use it to set the color.
// i++; // We don't want to use 0 for the color, so we increment it already. ( = black)
// var col = new ColorF(Convert.ToUInt32(i*20));
// esp.ApplyMaterial(gl, new Material() { Ambient = col });
// // Use the transformation in the model, else use the identity matrix (I do this to override previous transformations)
// if (model.Transformation != null)
// esp.ApplyTransformationMatrix(gl, model.Transformation.ResultMatrix);
// else
// esp.ApplyTransformationMatrix(gl, mat4.identity());
// var createdBuffers = OGLVisualSceneElementBase.GenerateAndDrawOnce(gl, (OGLVisualSceneElementBase)model.SceneElement); // model.Render(gl, RenderMode.HitTest);
// buffersToBeRemoved.AddRange(createdBuffers);
// }
//});
//esp.Dispose();
//// Wait for GPU to finish.
//gl.Flush();
//gl.Finish();
//gl.PixelStore(OpenGL.GL_UNPACK_ALIGNMENT, 1);
//uint format = OpenGL.GL_RGBA;
//uint type = OpenGL.GL_UNSIGNED_BYTE;
//byte[] data = new byte[40];
//gl.ReadPixels(x, y, 1, 1, format, type, data);
//// Delete the created buffers.
//gl.DeleteBuffers(buffersToBeRemoved.Count, buffersToBeRemoved.ToArray());
//// Remove the temperory gl from memory.
//gl.RenderContextProvider.Dispose();
//// Get color id from pixel data.
//id = data[0] + data[1] * 255 + data[2] * 65025; // id = r + g * 255 + b * 255².
//// if the pixel is black, then there was nothing selected.
//if (id == 0)
//{
// return -1;
//}
//// Return the index of the model and the used transformation.
//return id - 1;
}
protected void BeforeRendering(OpenGL gl, RenderMode renderMode)
{
IScientificCamera camera = this.camera;
if (camera != null)
{
if (camera.CameraType == CameraTypes.Perspecitive)
{
IPerspectiveViewCamera perspective = camera;
this.projectionMatrix = perspective.GetProjectionMat4();
this.viewMatrix = perspective.GetViewMat4();
}
else if (camera.CameraType == CameraTypes.Ortho)
{
IOrthoViewCamera ortho = camera;
this.projectionMatrix = ortho.GetProjectionMat4();
this.viewMatrix = ortho.GetViewMat4();
}
else
{ throw new NotImplementedException(); }
}
modelMatrix = glm.scale(mat4.identity(), new vec3(1, 1, this.ZAxisScale));
gl.Enable(OpenGL.GL_VERTEX_PROGRAM_POINT_SIZE);
gl.Enable(OpenGL.GL_POINT_SPRITE_ARB);
gl.TexEnv(OpenGL.GL_POINT_SPRITE_ARB, OpenGL.GL_COORD_REPLACE_ARB, OpenGL.GL_TRUE);
gl.Enable(OpenGL.GL_POINT_SMOOTH);
gl.Hint(OpenGL.GL_POINT_SMOOTH_HINT, OpenGL.GL_NICEST);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendEquation(OpenGL.GL_FUNC_ADD_EXT);
gl.BlendFuncSeparate(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA, OpenGL.GL_ONE, OpenGL.GL_ONE);
ShaderProgram shaderProgram = this.shaderProgram;
int[] viewport = new int[4];
gl.GetInteger(OpenGL.GL_VIEWPORT, viewport);
shaderProgram.Bind(gl);
shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", projectionMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "viewMatrix", viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(gl, "modelMatrix", modelMatrix.to_array());
shaderProgram.SetUniform1(gl, "canvasWidth", viewport[2] + 0.0f);
shaderProgram.SetUniform1(gl, "canvasHeight", viewport[3] + 0.0f);
shaderProgram.SetUniform1(gl, "opacity", this.Opacity);
this.texture.Bind(gl);
shaderProgram.SetUniform1(gl, "tex", this.texture.TextureName);
shaderProgram.SetUniform1(gl, "brightness", this.Brightness);
}
/// <summary>
/// Create device and renderbuffer, initialize NV_DX_interop and start rendering.
/// </summary>
private void StartRendering()
{
_gl = new OpenGL();
_hwnd = new HwndSource(0, 0, 0, 0, 0, "test", IntPtr.Zero).Handle;
_gl.Create(SharpGL.Version.OpenGLVersion.OpenGL2_1, RenderContextType.HiddenWindow, 1, 1, 32, _hwnd);
// Set the most basic OpenGL styles.
_gl.ShadeModel(OpenGL.GL_SMOOTH);
_gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
_gl.ClearDepth(1.0f);
_gl.Enable(OpenGL.GL_BLEND);
_gl.Disable(OpenGL.GL_DEPTH_TEST);
_gl.Enable(OpenGL.GL_TEXTURE_2D);
_gl.TexEnv(OpenGL.GL_TEXTURE_ENV, OpenGL.GL_TEXTURE_ENV_MODE, OpenGL.GL_REPLACE);
_gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
//_gl.Enable(OpenGL.GL_MULTISAMPLE);
//_gl.Enable(OpenGL.GL_MULTISAMPLE_ARB);
_gl.Hint(0x8534, OpenGL.GL_FASTEST);
ResizeRendering();
// leverage the Rendering event of WPF's composition target to
// update the custom D3D scene
CompositionTarget.Rendering += OnRenderOpenGL;
if (GLInitialize != null)
GLInitialize(this, new EventArgs());
}
public void InitEngine(OpenGL gl)
{
try
{
DebugTools.LogToConsole("Prepareing GL");
//setup open gl and activate modes
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_WRAP_S, OpenGL.GL_REPEAT);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_WRAP_T, OpenGL.GL_REPEAT);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_NEAREST);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_NEAREST);
gl.Enable(OpenGL.GL_BLEND);
gl.Enable(OpenGL.GL_TEXTURE_2D);
gl.Enable(OpenGL.GL_DEPTH_TEST);
//fffgl.Enable(OpenGL.GL_LIGHTING);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
gl.ShadeModel(OpenGL.GL_SMOOTH);
//Darw the first frame with a load test
Draw(gl);
DebugTools.LogToConsole("Loading Resources");
//Loading the resources and bind to gl
resourceManager = new ResourceManager();
DebugTools.LogToConsole("Applying Textures");
resourceManager.InitTextures(gl);
DebugTools.LogToConsole("Loading Level");
//Loading level
//_level = new MasterMindGame.MasterMind();
//_level.Build(this);
_level = new MasterMindGame.MasterMind();
_level.Build(this);
GameObjects.Sort(
delegate(GameObject p1, GameObject p2)
{
return p1.Z_Index.CompareTo(p2.Z_Index);
}
);
//Startup is complete
StartupComplete = true;
}
catch (Exception error)
{
DebugTools.LogError(error);
}
}
public override void OnLoad(OpenGL gl)
{
gl.Enable(OpenGL.GL_CULL_FACE);
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(BlendingSourceFactor.SourceAlpha, BlendingDestinationFactor.OneMinusSourceAlpha);
_camera = new OrthographicCamera();
_camera.View *= Mat4.RotateY(Angle.FromDegrees(15));
_shader = new BasicShader(gl);
_modelUniform = gl.GetUniformLocation(_shader.Handle, "Model");
_viewUniform = gl.GetUniformLocation(_shader.Handle, "View");
_projectionUniform = gl.GetUniformLocation(_shader.Handle, "Projection");
_graph = new SceneGraph();
_graph.Nodes.Add(new CoordinateSystemLeaf(gl, _shader, _model.Features.OfType<CoordinateSystem>()));
_graph.Nodes.Add(new DatumPlaneLeaf(gl, _shader, _model.Features.OfType<DatumPlane>()));
const double s = 5.0;
var v0 = new Vertex("v0", new Vect3(0, 0, 0));
var v1 = new Vertex("v1", new Vect3(0, 0, s));
var v2 = new Vertex("v2", new Vect3(s, 0, s));
var v3 = new Vertex("v3", new Vect3(s, 0, 0));
var v4 = new Vertex("v4", new Vect3(0, s, 0));
var v5 = new Vertex("v5", new Vect3(0, s, s));
var v6 = new Vertex("v6", new Vect3(s, s, s));
var v7 = new Vertex("v7", new Vect3(s, s, 0));
var f0 = new Face("f0");
var f1 = new Face("f1");
var f2 = new Face("f2");
var f3 = new Face("f3");
var f4 = new Face("f4");
var f5 = new Face("f5");
LineHalfEdge e0a = null;
LineHalfEdge e0b = null;
LineHalfEdge e1a = null;
LineHalfEdge e1b = null;
LineHalfEdge e2a = null;
LineHalfEdge e2b = null;
LineHalfEdge e3a = null;
LineHalfEdge e3b = null;
LineHalfEdge e4a = null;
LineHalfEdge e4b = null;
LineHalfEdge e5a = null;
LineHalfEdge e5b = null;
LineHalfEdge e6a = null;
LineHalfEdge e6b = null;
LineHalfEdge e7a = null;
LineHalfEdge e7b = null;
LineHalfEdge e8a = null;
LineHalfEdge e8b = null;
LineHalfEdge e9a = null;
LineHalfEdge e9b = null;
LineHalfEdge e10a = null;
LineHalfEdge e10b = null;
LineHalfEdge e11a = null;
LineHalfEdge e11b = null;
e0a = new LineHalfEdge("e0a", v1, new Lazy<IHalfEdge>(() => e0b), f0);
e1a = new LineHalfEdge("e1a", v2, new Lazy<IHalfEdge>(() => e1b), f0);
e2a = new LineHalfEdge("e2a", v3, new Lazy<IHalfEdge>(() => e2b), f0);
e3a = new LineHalfEdge("e3a", v0, new Lazy<IHalfEdge>(() => e3b), f0);
f0.Loops.Add(new EdgeLoop(e0a, e1a, e2a, e3a));
e0b = new LineHalfEdge("e0b", v0, new Lazy<IHalfEdge>(() => e0a), f1);
e7a = new LineHalfEdge("e7a", v4, new Lazy<IHalfEdge>(() => e7b), f1);
e8a = new LineHalfEdge("e8a", v5, new Lazy<IHalfEdge>(() => e8b), f1);
e4a = new LineHalfEdge("e4a", v1, new Lazy<IHalfEdge>(() => e4b), f1);
f1.Loops.Add(new EdgeLoop(e0b, e7a, e8a, e4a));
e1b = new LineHalfEdge("e1b", v1, new Lazy<IHalfEdge>(() => e1a), f2);
e4b = new LineHalfEdge("e4b", v5, new Lazy<IHalfEdge>(() => e4a), f2);
e9a = new LineHalfEdge("e9a", v6, new Lazy<IHalfEdge>(() => e9b), f2);
e5a = new LineHalfEdge("e5a", v2, new Lazy<IHalfEdge>(() => e5b), f2);
f2.Loops.Add(new EdgeLoop(e1b, e4b, e9a, e5a));
e2b = new LineHalfEdge("e2b", v2, new Lazy<IHalfEdge>(() => e2a), f3);
e5b = new LineHalfEdge("e5b", v6, new Lazy<IHalfEdge>(() => e5a), f3);
e10a = new LineHalfEdge("e10a", v7, new Lazy<IHalfEdge>(() => e10b), f3);
e6a = new LineHalfEdge("e6a", v3, new Lazy<IHalfEdge>(() => e6b), f3);
f3.Loops.Add(new EdgeLoop(e2b, e5b, e10a, e6a));
e3b = new LineHalfEdge("e3b", v3, new Lazy<IHalfEdge>(() => e3a), f4);
e6b = new LineHalfEdge("e6b", v7, new Lazy<IHalfEdge>(() => e6a), f4);
e11a = new LineHalfEdge("e11a", v4, new Lazy<IHalfEdge>(() => e11b), f4);
e7b = new LineHalfEdge("e7b", v0, new Lazy<IHalfEdge>(() => e7a), f4);
f4.Loops.Add(new EdgeLoop(e3b, e6b, e11a, e7b));
e8b = new LineHalfEdge("e8b", v4, new Lazy<IHalfEdge>(() => e8a), f5);
e11b = new LineHalfEdge("e11b", v7, new Lazy<IHalfEdge>(() => e11a), f5);
e10b = new LineHalfEdge("e10b", v6, new Lazy<IHalfEdge>(() => e10a), f5);
e9b = new LineHalfEdge("e9b", v5, new Lazy<IHalfEdge>(() => e9b), f5);
f5.Loops.Add(new EdgeLoop(e8b, e11b, e10b, e9b));
var shell = new Shell(f0,f1,f2,f3,f4,f5);
var data = new List<Vert>();
foreach (var face in shell.Faces)
{
foreach (var loop in face.Loops)
{
foreach (var edge in loop.Edges)
{
data.Add(new Vert(edge.Start, Vect3.Zero, Color.Gold.ToVector4()));
data.Add(new Vert(edge.End, Vect3.Zero, Color.Gold.ToVector4()));
}
}
}
_points = new PointRenderer(gl,_shader,data);
// gl.PolygonMode(FaceMode.FrontAndBack, PolygonMode.Lines);
}
public override void Draw(ref OpenGL gl)
{
if (!TexturesInitialised)
{
InitializeTexture(ref gl);
}
// Clear the color and depth buffer.
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
// Load the identity matrix.
gl.LoadIdentity();
gl.Enable(OpenGL.GL_TEXTURE_2D);
gl.Enable(OpenGL.GL_LIGHTING);
gl.Enable(OpenGL.GL_LIGHT0);
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(OpenGL.GL_NORMALIZE);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, gtexture[0]);
gl.Color(1.0f, 1.0f, 1.0f, 0.1f);
gl.Begin(OpenGL.GL_QUADS);
gl.FrontFace(OpenGL.GL_FRONT_FACE);
gl.TexCoord(1.0f, 1.0f);
gl.Vertex(gImage1.Width, gImage1.Height, 1.0f);
gl.TexCoord(0.0f, 1.0f);
gl.Vertex(0.0f, gImage1.Height, 1.0f);
gl.TexCoord(0.0f, 0.0f);
gl.Vertex(0.0f, 0.0f, 1.0f);
gl.TexCoord(1.0f, 0.0f);
gl.Vertex(gImage1.Width, 0.0f, 1.0f);
gl.End();
gl.Disable(OpenGL.GL_TEXTURE_2D);
gl.MatrixMode(OpenGL.GL_PROJECTION);
gl.LoadIdentity();
gl.Ortho(0.0, (double)gImage1.Width, (double)gImage1.Height, 0.0, -1.0, 1.0);
gl.MatrixMode(OpenGL.GL_MODELVIEW);
gl.Disable(OpenGL.GL_DEPTH_TEST);
}
private void DoRenderFraction(OpenGL gl, RenderMode renderMode)
{
if (this.fractionPositionBuffer == null || this.fractionUVBuffer == null) { return; }
if (this.RenderFraction && this.fractionVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 0.0f);
gl.Enable(OpenGL.GL_POLYGON_OFFSET_FILL);
gl.PolygonOffset(1.0f, 1.0f);
gl.BindVertexArray(fractionVertexArrayObject[0]);
switch (this.FractionType)
{
case FractureFormat.Line:
float[] originalWidth = new float[1];
gl.GetFloat(SharpGL.Enumerations.GetTarget.LineWidth, originalWidth);
gl.LineWidth(this.FractionLineWidth);
gl.DrawArrays(OpenGL.GL_LINES, 0, this.FractionVertexCount);
gl.LineWidth(originalWidth[0]);
break;
case FractureFormat.Triange:
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.FractionVertexCount);
break;
case FractureFormat.Quad:
gl.DrawArrays(OpenGL.GL_QUADS, 0, this.FractionVertexCount);
break;
default:
throw new NotImplementedException();
//break;
}
gl.BindVertexArray(0);
gl.Disable(OpenGL.GL_POLYGON_OFFSET_FILL);
}
if (this.renderFractionWireframe && this.fractionVertexArrayObject != null)
{
shaderProgram.SetUniform1(gl, "renderingWireframe", 1.0f);
gl.BindVertexArray(fractionVertexArrayObject[0]);
{
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Lines);
switch (this.FractionType)
{
case FractureFormat.Line:
gl.DrawArrays(OpenGL.GL_LINES, 0, this.FractionVertexCount);
break;
case FractureFormat.Triange:
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, this.FractionVertexCount);
break;
case FractureFormat.Quad:
gl.DrawArrays(OpenGL.GL_QUADS, 0, this.FractionVertexCount);
break;
default:
break;
}
gl.PolygonMode(SharpGL.Enumerations.FaceMode.FrontAndBack, SharpGL.Enumerations.PolygonMode.Filled);
}
gl.BindVertexArray(0);
}
}
public override void OnRender(OpenGL gl)
{
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.ClearColor(0.137f, 0.121f, 0.125f, 0f);
_graph.Render();
gl.Disable(OpenGL.GL_DEPTH_TEST);
using (new Bind(_shader))
{
gl.UniformMatrix4(_modelUniform, 1, false, Mat4.Identity.ToColumnMajorArray());
gl.PointSize(10f);
gl.Begin(BeginMode.Points);
gl.Vertex(6, 0);
gl.End();
}
gl.PointSize(5f);
_points.Render();
gl.Enable(OpenGL.GL_DEPTH_TEST);
}
/// <summary>
/// Draw a mesh.
/// </summary>
/// <param name="gl">OpenGL handler.</param>
/// <param name="buildingObj">The mesh.</param>BuildingObjectLib3DS _object,
private void DrawMesh(OpenGL gl, Lib3dsMesh thisMesh, Hashtable textures, List<Lib3dsMaterial> matrials, DrawType type)
{
if (thisMesh == null || thisMesh.nfaces == 0)
return;
// Draw all the faces in this mesh.
for (int j = 0; j < thisMesh.faces.Count; j++)
{
Lib3dsFace thisFace = thisMesh.faces[j];
float transparency = matrials[thisFace.material].transparency;
//float[] fogColor = new float[4] { 0.5f, 0.5f, 0.5f, 1.0f };
//float[] LightAmbient = new float[4] { 0.5f, 0.5f, 0.5f, 1.0f };
//float[] LightDiffuse = new float[4] { 1.0f, 1.0f, 1.0f, 1.0f };
//float[] LightPosition = new float[4] { 0.0f, 0.0f, 2.0f, 1.0f };
switch (type)
{
case DrawType.WireFrame:
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_LINE);
IsDrawTexture = false;
gl.Color(0.5f, 0.5f, 0.5f, 0.5f);
gl.LineWidth(1.5f);
break;
case DrawType.Full:
IsDrawTexture = BindTexture(gl, textures, matrials[thisFace.material].name);
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
break;
case DrawType.Face:
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
IsDrawTexture = false;
break;
case DrawType.Translucent:
IsDrawTexture = BindTexture(gl, textures, matrials[thisFace.material].name);
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA,OpenGL.GL_ONE_MINUS_SRC_ALPHA);
//gl.Enable(OpenGL.GL_TEXTURE_2D); // Enable Texture Mapping
//gl.ShadeModel(OpenGL.GL_SMOOTH); // Enable Smooth Shading
//gl.ClearColor(0.5f,0.5f,0.5f,1.0f); // We'll Clear To The Color Of The Fog
//gl.ClearDepth(1.0f); // Depth Buffer Setup
//gl.Enable(OpenGL.GL_DEPTH_TEST); // Enables Depth Testing
//gl.DepthFunc(OpenGL.GL_LEQUAL); // The Type Of Depth Testing To Do
//gl.Hint(OpenGL.GL_PERSPECTIVE_CORRECTION_HINT, OpenGL.GL_NICEST); // Really Nice Perspective Calculations
//gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_AMBIENT, LightAmbient); // Setup The Ambient Light
//gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_DIFFUSE, LightDiffuse); // Setup The Diffuse Light
//gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_POSITION,LightPosition); // Position The Light
//gl.Enable(OpenGL.GL_LIGHT1);
//gl.Fog(OpenGL.GL_FOG_COLOR, fogColor);//设置雾颜色，f是一个指定颜色的数组float f[4]
//gl.Fog(OpenGL.GL_FOG_DENSITY, 0.85f); // 设置雾的密度
//gl.Hint(OpenGL.GL_FOG_HINT, OpenGL.GL_DONT_CARE); // 设置系统如何计算雾气
//gl.Fog(OpenGL.GL_FOG_START, 0.01f);//设置雾从多远开始
//gl.Fog(OpenGL.GL_FOG_END, 100.0f);//设置雾从多远结束
//gl.Fog(OpenGL.GL_FOG_MODE, OpenGL.GL_LINEAR);//设置使用哪种雾，共有三中雾化模式
//gl.Enable(OpenGL.GL_FOG);//打开雾效果
transparency = 0.2f;
break;
default:
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
IsDrawTexture = false;
break;
}
if (type != DrawType.WireFrame)
{
gl.Color(matrials[thisFace.material].diffuse[0], matrials[thisFace.material].diffuse[1],
matrials[thisFace.material].diffuse[2], matrials[thisFace.material].transparency);
}
gl.Begin(OpenGL.GL_TRIANGLES);
for (int k = 0; k != 3; ++k)
{
int index = thisFace.index[k];
if (IsDrawTexture)
gl.TexCoord(thisMesh.texcos[index].s, thisMesh.texcos[index].t);
gl.Vertex(thisMesh.vertices[index].x / 20, thisMesh.vertices[index].z / 20, -thisMesh.vertices[index].y / 20);
}
gl.End();
if(type == DrawType.Translucent)
gl.Disable(OpenGL.GL_BLEND);
}
}
