public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
gl.Translate(position.x, position.y + Z * scaleKoef, position.z);
gl.Scale(scaleKoef, scaleKoef, scaleKoef);
int i;
gl.Color(color.GetInArrWithAlpha());
//float[] specular1 = { 1, 1, 1, 1 };
//gl.Material(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_SPECULAR, specular1);
//gl.Material(OpenGL.GL_FRONT, OpenGL.GL_SHININESS, 128);
gl.Begin(BeginMode.Triangles);
for (i = 0; i < 20; i++)
{
gl.Normal(vdata[tindices[i][0]]);
gl.Vertex(vdata[tindices[i][0]]);
gl.Normal(vdata[tindices[i][1]]);
gl.Vertex(vdata[tindices[i][1]]);
gl.Normal(vdata[tindices[i][2]]);
gl.Vertex(vdata[tindices[i][2]]);
}
gl.End();
gl.PopMatrix();
}
public _3DViewModel()
{
openGL = new SharpGL.OpenGL();
RenderModes = new ObservableCollection <string> {
"Retained Mode", "Immediate Mode"
};
}
/// <summary>
/// Draw quad (Must be inside GL_TRIANGLES or GL_LINES for wireframe)
/// </summary>
/// <param name="gl">OpenGL isntance</param>
/// <param name="map">Shared map data</param>
/// <param name="plane">Plane this quad belongs to</param>
/// <param name="planeNormal">Normal vector of the plane</param>
/// <param name="wireframe">Draw as wireframe</param>
public void Draw(SharpGL.OpenGL gl, Powerslave.Map map, Powerslave.Plane plane, Vector3D planeNormal, bool wireframe)
{
List <Powerslave.Vertex> quad = this.Indices.Select(index => map.Vertices[index + plane.VertexStart]).ToList();
if (Vector3D.DotProduct(planeNormal, Quad.GetQuadNormal(quad)) < 0.0f)
{
// Quad is rotated incorrectly, reverse it (might be used as a texture flip)
quad.Reverse();
}
foreach (Powerslave.Vertex point in wireframe ? quad.SelectMany((vertex, index) => new List <Powerslave.Vertex> {
vertex, quad[(index + 1) % quad.Count]
}) : Powerslave.GetTrianglesFromQuad(quad))
{
if (wireframe)
{
gl.Color(1.0f, 1.0f, 1.0f);
}
else
{
Powerslave.SetVertexColor(gl, plane.Flags, point.Lightlevel);
}
gl.Vertex(point.X / 10.0f, point.Z / 10.0f, point.Y / 10.0f);
}
}
public override void Draw(SharpGL.OpenGL gl)
{
if (_pawnColor != PawnColor.None)
{
base.Draw(gl);
}
}
/// <summary>
/// Set vertex color
/// </summary>
/// <param name="gl">OpenGL isntance</param>
/// <param name="planeflags">Plane flag</param>
/// <param name="lightLevel">Vertex light level</param>
private static void SetVertexColor(SharpGL.OpenGL gl, Powerslave.PLaneFlags planeflags, byte lightLevel)
{
float brightness = Math.Min(lightLevel, (byte)16) / 16.0f;
if (planeflags.HasFlag(Powerslave.PLaneFlags.Water))
{
gl.Color(brightness * 0.2f, brightness * 0.4f, brightness * 1.0f, 0.5f);
}
else if (planeflags.HasFlag(Powerslave.PLaneFlags.Lava))
{
gl.Color(0.7f, 0.2f, 0.2f);
}
else if (planeflags.HasFlag(Powerslave.PLaneFlags.Sky))
{
gl.Color(0.0f, 0.3f, 1.0f);
}
else if (planeflags.HasFlag(Powerslave.PLaneFlags.Breakable))
{
gl.Color(brightness * 1.0f, brightness * 1.0f, brightness * 0.2f);
}
else
{
gl.Color(brightness, brightness, brightness);
}
}
public override void DateChangee(SharpGL.OpenGL gl, Temps maintenant)
{
Bitmap bmp = new Bitmap(10, 10);
Graphics g = Graphics.FromImage(bmp);
_taille = g.MeasureString(_texte, _fonte);
}
/// <summary>
/// Draw plane (Must be inside GL_TRIANGLES or GL_LINES for wireframe)
/// </summary>
/// <param name="gl">OpenGL isntance</param>
/// <param name="map">Shared map data</param>
/// <param name="ignoreTiled">Do not draw tiled quads in planes</param>
/// <param name="wireframe">Draw as wireframe</param>
public void Draw(SharpGL.OpenGL gl, Powerslave.Map map, bool ignoreTiled, bool wireframe)
{
if (this.PolyStart != -1 && this.PolyEnd != -1 && !ignoreTiled)
{
Vector3D planeNormal = new Vector3D(this.Normal.X / (double)short.MaxValue, this.Normal.Z / (double)short.MaxValue, this.Normal.Y / (double)short.MaxValue);
int start = Math.Min(this.PolyStart, this.PolyEnd);
int end = Math.Max(this.PolyStart, this.PolyEnd);
for (int polygon = start; polygon <= end; polygon++)
{
map.Quads[polygon].Draw(gl, map, this, planeNormal, wireframe);
}
}
else
{
List <Powerslave.Vertex> vertices = this.PolyVert.Select(index => map.Vertices[index]).ToList();
foreach (Powerslave.Vertex point in wireframe ? vertices.SelectMany((vertex, index) => new List <Powerslave.Vertex> {
vertex, vertices[(index + 1) % vertices.Count]
}) : Powerslave.GetTrianglesFromQuad(vertices))
{
if (wireframe)
{
gl.Color(1.0f, 1.0f, 1.0f);
}
else
{
Powerslave.SetVertexColor(gl, this.Flags, point.Lightlevel);
}
gl.Vertex(point.X / 10.0f, point.Z / 10.0f, point.Y / 10.0f);
}
}
}
public void RenderRetainedMode(SharpGL.OpenGL openGL)
{
var axies = new Axies();
axies.Render(openGL, RenderMode.Design);
if (DrawAll == true)
{
foreach (var mesh in Meshes)
{
mesh.Draw(openGL);
}
if (SelectedMesh != null)
{
EditMesh();
}
}
else
{
if (SelectedMesh != null)
{
SelectedMesh.Draw(openGL);
EditMesh();
}
}
}
public void RenderRetainedMode(SharpGL.OpenGL openGL)
{
var axies = new Axies();
axies.Render(openGL, RenderMode.Design);
if (DrawAll == true)
{
foreach (var mesh in MainWindowViewModel.Meshes)
{
mesh.Draw(openGL);
}
}
else
{
if (MainWindowViewModel.SelectedMesh != null)
{
MainWindowViewModel.SelectedMesh.Draw(openGL);
MainWindowViewModel.SelectedMesh.Transformation.TranslateX = TranslateX;
MainWindowViewModel.SelectedMesh.Transformation.TranslateY = TranslateY;
MainWindowViewModel.SelectedMesh.Transformation.TranslateZ = TranslateZ;
MainWindowViewModel.SelectedMesh.Transformation.RotateX = RotateX;
MainWindowViewModel.SelectedMesh.Transformation.RotateY = RotateY;
MainWindowViewModel.SelectedMesh.Transformation.RotateZ = RotateZ;
MainWindowViewModel.SelectedMesh.Transformation.Depth = Depth;
}
}
}
public void RenderImmediateMode(SharpGL.OpenGL openGL)
{
openGL.PushAttrib(SharpGL.OpenGL.GL_POLYGON_BIT);
openGL.PolygonMode(FaceMode.FrontAndBack, PolygonMode.Lines);
RenderRetainedMode(openGL);
openGL.PopAttrib();
}
private void glView1_OpenGLDraw(object sender, SharpGL.RenderEventArgs args)
{
SharpGL.OpenGL gl = this.glView1.OpenGL;
gl.Clear(SharpGL.OpenGL.GL_COLOR_BUFFER_BIT | SharpGL.OpenGL.GL_DEPTH_BUFFER_BIT);
//gl.ClearColor(1f, 1f, 1f, 1f);
gl.LoadIdentity();
gl.Translate(0.0f, 0.0f, -12.0f);
GLHelper.DrawBackground(gl);
float transX = movedX / 20;
float transY = movedY / 20;
gl.Translate(transX, transY, 0.0f);
gl.Rotate(axisRotateX, 1.0f, 0.0f, 0.0f);
gl.Rotate(axisRotateY, 0.0f, 1.0f, 0.0f);
gl.Rotate(axisRotateZ, 0.0f, 0.0f, 1.0f);
gl.Scale(scaleFactor, scaleFactor, scaleFactor);
if (doDrawDefault)
{
//GLHelper.DrawNet(gl, 100, 5);
}
if (doDrawAxis)
{
GLHelper.DrawAxis3D(gl, 0, 0, 0,
-3, 10,
-3, 10,
-3, 10,
3, 1);
}
if (doDrawSolids)
{
//...
GLHelper.DrawBox(gl, 10, 4, 4, Color.Orange, Color.OrangeRed);
gl.Translate(5.0f, 3.0f, 0.0f);
GLHelper.DrawPiram(gl, 10, 3, 4, System.Drawing.Color.DarkGreen, System.Drawing.Color.LightGreen);
gl.Translate(-2.5f, 4.0f, 0.0f);
GLHelper.DrawCylinder(gl, 5, 5, 7, Color.PaleVioletRed, Color.MediumVioletRed);
gl.Translate(0.0f, 8.0f, 0.0f);
GLHelper.DrawCylinder(gl, 5, 1, 4, Color.Chocolate, Color.Red);
gl.Translate(0.0f, 5.0f, 0.0f);
GLHelper.DrawSphere(gl, 3, Color.LightBlue, Color.Blue);
}
gl.LoadIdentity();
}
public void Initialize(SharpGL.OpenGL openGL)
{
this.InitTexture(openGL, this.content, this.fontSize, this.maxRowWidth, this.fontResource);
this.InitShaderProgram(openGL, out this.shaderProgram);
this.InitVAO(openGL, out this.primitiveMode, out this.vao, out this.primitiveCount);
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
gl.Translate(position.x, position.y, position.z);
gl.Rotate(-90, 1, 0, 0);
int iPivot = 1;
float x, y;
//gl.Begin(BeginMode.TriangleFan);
{
//gl.Vertex(0f, 0f, size);
Point3D top = new Point3D(0f, 0f, size);
Point3D prevPoint = null;
for (float angle = 0; angle <= (2f * Math.PI) + (((float)Math.PI / doubledFaceNumber) / 2); angle += ((float)Math.PI / doubledFaceNumber))
{
y = size * (float)Math.Sin(angle);
x = size * (float)Math.Cos(angle);
if ((iPivot++ % 2) == 0)
{
gl.Color(0f, 1f, 0f);
}
else
{
gl.Color(1f, 0f, 0f);
}
//gl.Vertex(x, y);
if (prevPoint != null)
{
DrawPrimitive.Triangle(gl, top, prevPoint, new Point3D(x, y), false);
}
prevPoint = new Point3D(x, y);
}
}
//gl.End();
//основание
gl.Begin(BeginMode.TriangleFan);
{
gl.Normal(0, 0, -1f);
gl.Vertex(0f, 0f, 0f);
for (float angle = 0; angle <= (2f * Math.PI) + (((float)Math.PI / doubledFaceNumber) / 2); angle += ((float)Math.PI / doubledFaceNumber))
{
x = size * (float)Math.Sin(angle);
y = size * (float)Math.Cos(angle);
if ((iPivot++ % 2) == 0)
{
gl.Color(0f, 1f, 0f);
}
else
{
gl.Color(1f, 0f, 0f);
}
gl.Vertex(x, y);
}
}
gl.End();
gl.PopMatrix();
}
public void BindBuffer(SharpGL.OpenGL gl, Action executeWhileBinded)
{
gl.BindVertexArray(BufferId.Value);
executeWhileBinded.Invoke();
gl.BindVertexArray(0); // Unbind.
}
public override void DateChangee(SharpGL.OpenGL gl, Temps maintenant)
#endif
{
Bitmap bmp = new Bitmap(10, 10);
Graphics g = Graphics.FromImage(bmp);
_date = maintenant._temps.ToLongDateString();
_taille = g.MeasureString(_date, _fonte);
}
public static void DrawNet(SharpGL.OpenGL gl, int total_cells, int cell_size)
{
for (int i = 0; i <= total_cells; i++)
{
int gap = cell_size * i;
DrawLine3D(gl, 0, 0, gap, total_cells * cell_size, 0, gap, System.Drawing.Color.Red);
DrawLine3D(gl, gap, 0, 0, gap, 0, total_cells * cell_size, System.Drawing.Color.Red);
}
}
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);
gl.Disable(OpenGL.GL_DEPTH_TEST);
// Create our texture object from a file. This creates the texture for OpenGL.
capture = new Capture(@"Video file here");
}
private void openGLControl1_Resized(object sender, EventArgs e)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
// Create an orthographic projection.
gl.MatrixMode(MatrixMode.Projection);
gl.LoadIdentity();
// NOTE: Basically no matter what I do, the only points I see are those at
// the "near" surface (with z = -zNear)--in this case, I only see green points
gl.Ortho(0, openGLControl1.Width, openGLControl1.Height, 0, 0, 1);
// Back to the modelview.
gl.MatrixMode(MatrixMode.Modelview);
}
public static void DrawGrid2D(SharpGL.OpenGL gl, int plane, float beginX, float beginY, float beginZ,
float minValue, float maxValue, float cellSize, float width, Color color)
{
/* Определение количества линий по одной оси. */
int linesAmount = (int)System.Math.Ceiling((maxValue - minValue) / cellSize);
linesAmount++;
/* Отрисовка сетки. */
for (var i = linesAmount; i > 0; i--)
{
if (plane == 0)
{
/* В плоскости XY. */
DrawLine3D(gl,
beginX + minValue, beginY + minValue + (cellSize * (i - 1)), beginZ,
beginX + maxValue, beginY + minValue + (cellSize * (i - 1)), beginZ,
width, color);
DrawLine3D(gl,
beginX + minValue + (cellSize * (i - 1)), beginY + minValue, beginZ,
beginX + minValue + (cellSize * (i - 1)), beginY + maxValue, beginZ,
width, color);
}
else if (plane == 1)
{
/* В плоскости YZ. */
DrawLine3D(gl,
beginX, beginY + minValue + (cellSize * (i - 1)), beginZ + minValue,
beginX, beginY + minValue + (cellSize * (i - 1)), beginZ + maxValue,
width, color);
DrawLine3D(gl,
beginX, beginY + minValue, beginZ + minValue + (cellSize * (i - 1)),
beginX, beginY + maxValue, beginZ + minValue + (cellSize * (i - 1)),
width, color);
}
else
{
/* В плоскости XZ. */
DrawLine3D(gl,
beginX + minValue, beginY, beginZ + minValue + (cellSize * (i - 1)),
beginX + maxValue, beginY, beginZ + minValue + (cellSize * (i - 1)),
width, color);
DrawLine3D(gl,
beginX + minValue + (cellSize * (i - 1)), beginY, beginZ + minValue,
beginX + minValue + (cellSize * (i - 1)), beginY, beginZ + maxValue,
width, color);
}
}
}
/// <summary>
/// Transform projection matrix
/// </summary>
/// <param name="gl">GL instance</param>
internal void TransformProjectionMatrix(GL gl)
{
gl.MatrixMode(GL.GL_PROJECTION);
gl.LoadIdentity();
// Perform the perspective transformation
gl.Perspective(this.FieldOfView, this.AspectRatio, this.Near, this.Far);
// Perform the look at transformation
gl.LookAt(this.Position.X, this.Position.Y, this.Position.Z, this.Target.X, this.Target.Y, this.Target.Z, this.Up.X, this.Up.Y, this.Up.Z);
gl.MatrixMode(GL.GL_MODELVIEW);
}
public static void DrawLine3D(SharpGL.OpenGL gl, float startX, float startY, float startZ,
float endX, float endY, float endZ, System.Drawing.Color lineColor)
{
gl.Begin(SharpGL.OpenGL.GL_LINES);
float cR = lineColor.R / 255.0f;
float cG = lineColor.G / 255.0f;
float cB = lineColor.B / 255.0f;
gl.Color(cR, cG, cB);
gl.Vertex(startX, startY, startZ);
gl.Vertex(endX, endY, endZ);
gl.End();
}
public Commands()
{
openGL = new SharpGL.OpenGL();
RenderModes = new ObservableCollection <string> {
"Retained Mode", "Immediate Mode"
};
MeshTypes = new ObservableCollection <string> {
"Tylne Oparcie", "Boczne Oparcie", "Siedzenie", "Noga"
};
Meshes = new ObservableCollection <Mesh>();
ImageInfo = Visibility.Hidden;
PointsToAdd = new List <Point>();
}
public static void DrawBackground(SharpGL.OpenGL gl)
{
gl.Begin(SharpGL.OpenGL.GL_POLYGON);
gl.Color(0.9f, 0.9f, 1.0f);
gl.Vertex(-500, 30, -50f);
gl.Vertex(500, 30, -50f);
gl.Color(0.0f, 0.3f, 1.0f);
gl.Vertex(500, -30, -50f);
gl.Vertex(-500, -30, -50f);
gl.End();
}
public static void Draw(SharpGL.OpenGL gl, float x, float y, float z, float size, Color color)
{
gl.PointSize(size);
gl.Color(color.R / colorConversionConstant,
color.G / colorConversionConstant,
color.B / colorConversionConstant);
gl.Begin(SharpGL.OpenGL.GL_POINTS);
gl.Vertex(x, y, z);
gl.End();
}
public static void DrawCube3D(SharpGL.OpenGL gl,
float beginX, float beginY, float beginZ,
float size, float linesWidth, Color color)
{
/* В плоскости XZ. */
DrawQuadrate2D(gl, 2, beginX, beginY, beginZ, size, linesWidth, color);
DrawQuadrate2D(gl, 2, beginX, beginY + size, beginZ, size, linesWidth, color);
/* В плоскости YZ. */
DrawQuadrate2D(gl, 1, beginX + (size / 2.0f), beginY + (size / 2.0f), beginZ,
size, linesWidth, color);
DrawQuadrate2D(gl, 1, beginX - (size / 2.0f), beginY + (size / 2.0f), beginZ,
size, linesWidth, color);
}
private void openGLControl1_OpenGLDraw(object sender, SharpGL.RenderEventArgs args)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.Clear(SharpGL.OpenGL.GL_COLOR_BUFFER_BIT | SharpGL.OpenGL.GL_DEPTH_BUFFER_BIT); // Очистка скрина
gl.LoadIdentity(); // сброс
gl.Translate(0.0f, 0.0f, -6.0f); // переместить влево
gl.Rotate(axis_rotate_X, 1.0f, 0.0f, 0.0f);
gl.Rotate(axis_rotate_Y, 0.0f, 1.0f, 0.0f);
gl.Rotate(axis_rotate_Z, 0.0f, 0.0f, 1.0f);
gl.Begin(SharpGL.OpenGL.GL_TRIANGLES); // начать рисовать пирамиду
gl.Color(1.0f, 0.0f, 0.0f); //красный
gl.Vertex(0.0f, 1.0f, 0.0f); // центр пирамиды
gl.Color(0.0f, 1.0f, 0.0f); //Зеленый
gl.Vertex(-1.0f, -1.0f, 1.0f); // левая сторона пирамиды
gl.Color(0.0f, 0.0f, 1.0f); // Синий
gl.Vertex(1.0f, -1.0f, 1.0f); // права сторона пирамиды
gl.Color(1.0f, 0.0f, 0.0f); //красный
gl.Vertex(0.0f, 1.0f, 0.0f); // центр пирамиды
gl.Color(0.0f, 0.0f, 1.0f); //Зеленый
gl.Vertex(1.0f, -1.0f, 1.0f); // левая сторона пирамиды
gl.Color(0.0f, 1.0f, 0.0f); // Синий
gl.Vertex(1.0f, -1.0f, -1.0f); // права сторона пирамиды
gl.Color(1.0f, 0.0f, 0.0f); //красный
gl.Vertex(0.0f, 1.0f, 0.0f); // центр пирамиды
gl.Color(0.0f, 1.0f, 0.0f); //Зеленый
gl.Vertex(1.0f, -1.0f, -1.0f); // левая сторона пирамиды
gl.Color(0.0f, 0.0f, 1.0f); // Синий
gl.Vertex(-1.0f, -1.0f, -1.0f); // права сторона пирамиды
gl.Color(1.0f, 0.0f, 0.0f); //красный
gl.Vertex(0.0f, 1.0f, 0.0f); // центр пирамиды
gl.Color(0.0f, 0.0f, 1.0f); //Зеленый
gl.Vertex(-1.0f, -1.0f, -1.0f); // левая сторона пирамиды
gl.Color(0.0f, 1.0f, 0.0f); // Синий
gl.Vertex(-1.0f, -1.0f, 1.0f); // права сторона пирамиды
gl.End();
gl.LoadIdentity();
}
public void Draw(SharpGL.OpenGL gl, float size, Color color)
{
/* Установка размера точки. */
gl.PointSize(size);
/* Установка цвета точки. */
gl.Color(color.R / colorConversionConstant,
color.G / colorConversionConstant,
color.B / colorConversionConstant);
gl.Begin(SharpGL.OpenGL.GL_POINTS);
gl.Vertex(this.x, this.y, this.z);
gl.End();
}
public void view(SharpGL.OpenGL gl)
{
Vector3d viewVector = GetRotatedByAngles(eyeTrace.GetNormalize());
Vector3d fromEyeToRight = new Vector3d(
((new HomogeneousCoordinates(eyeTrace.GetAsPoint3D())) * ConversionMatrix.GetRotationY(-Math.PI / 2)).ToPoint3D());
fromEyeToRight = GetRotatedByAngles(fromEyeToRight);
Vector3d vectorUp = Vector3d.Product(fromEyeToRight, viewVector).GetNormalize();
Point3D seeTo = (new Vector3d(position) + viewVector).GetAsPoint3D();
gl.LookAt(
position.x, position.y, position.z,
seeTo.x, seeTo.y, seeTo.z,
vectorUp.x, vectorUp.y, vectorUp.z
);
}
// TODO: реализовать функционал гизмо.
public static void DrawStartTriangle(SharpGL.OpenGL gl)
{
/* Создание пирамиды. */
gl.Begin(SharpGL.OpenGL.GL_TRIANGLES);
// XY triangle
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 1.0f, 0.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(0.0f, 0.0f, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(1.0f, 0.0f, 0.0f);
// ZY triangle
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 1.0f, 0.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(0.0f, 0.0f, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(0.0f, 0.0f, 1.0f);
// XZ triangle
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(1.0f, 0.0f, 0.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(0.0f, 0.0f, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(0.0f, 0.0f, 1.0f);
// XYZ triangle
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 1.0f, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(1.0f, 0.0f, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(0.0f, 0.0f, 1.0f);
gl.End();
}
public void ChangeRenderMode(SharpGL.OpenGL openGL)
{
switch (SelectedRenderMode)
{
case "Retained Mode":
{
RenderRetainedMode(openGL);
break;
}
case "Immediate Mode":
{
RenderImmediateMode(openGL);
break;
}
}
}
public ShaderWrapper(ShaderProgram shaderProgram, SharpGL.OpenGL gl)
{
m_gl = gl;
m_shaderProgram = shaderProgram;
}
