/// <summary> /// Pushes this object into the provided OpenGL instance. /// This will generally push elements of the attribute stack /// and then set current values. /// </summary> /// <param name="gl">The OpenGL instance.</param> public virtual void Push(OpenGL gl) { // Push texture attributes. gl.PushAttrib(Enumerations.AttributeMask.Texture); // Bind the texture. Bind(gl); }
/// <summary> /// Creates the display list. This function draws the /// geometry as well as compiling it. /// </summary> private void CreateDisplayList(OpenGL gl) { // Create the display list. displayList = new DisplayList(); // Generate the display list and displayList.Generate(gl); displayList.New(gl, DisplayList.DisplayListMode.CompileAndExecute); // Push attributes, set the color. gl.PushAttrib(OpenGL.GL_CURRENT_BIT | OpenGL.GL_ENABLE_BIT | OpenGL.GL_LINE_BIT); gl.Disable(OpenGL.GL_LIGHTING); gl.Disable(OpenGL.GL_TEXTURE_2D); gl.LineWidth(1.0f); // Draw the grid lines. gl.Begin(OpenGL.GL_LINES); for (int i = -10; i <= 10; i++) { float fcol = ((i % 10) == 0) ? 0.3f : 0.15f; gl.Color(fcol, fcol, fcol); gl.Vertex(i, -10, 0); gl.Vertex(i, 10, 0); gl.Vertex(-10, i, 0); gl.Vertex(10, i, 0); } gl.End(); // Restore attributes. gl.PopAttrib(); // End the display list. displayList.End(gl); }
/// <summary> /// Sets the attributes. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void SetAttributes(OpenGL gl) { if(enableAlphaTest.HasValue) gl.EnableIf(OpenGL.GL_ALPHA_TEST,enableAlphaTest.Value); if(enableAutoNormal.HasValue) gl.EnableIf(OpenGL.GL_AUTO_NORMAL,enableAutoNormal.Value); if(enableBlend.HasValue) gl.EnableIf(OpenGL.GL_BLEND,enableBlend.Value); if(enableCullFace.HasValue) gl.EnableIf(OpenGL.GL_CULL_FACE,enableCullFace.Value); if(enableDepthTest.HasValue) gl.EnableIf(OpenGL.GL_DEPTH_TEST,enableDepthTest.Value); if(enableDither.HasValue) gl.EnableIf(OpenGL.GL_DITHER,enableDither.Value); if(enableFog.HasValue) gl.EnableIf(OpenGL.GL_FOG,enableFog.Value); if(enableLighting.HasValue) gl.EnableIf(OpenGL.GL_LIGHTING,enableLighting.Value); if(enableLineSmooth.HasValue) gl.EnableIf(OpenGL.GL_LINE_SMOOTH,enableLineSmooth.Value); if(enableLineStipple.HasValue) gl.EnableIf(OpenGL.GL_LINE_STIPPLE,enableLineStipple.Value); if(enableColorLogicOp.HasValue) gl.EnableIf(OpenGL.GL_COLOR_LOGIC_OP,enableColorLogicOp.Value); if(enableIndexLogicOp.HasValue) gl.EnableIf(OpenGL.GL_INDEX_LOGIC_OP,enableIndexLogicOp.Value); if(enableNormalize.HasValue) gl.EnableIf(OpenGL.GL_NORMALIZE,enableNormalize.Value); if(enablePointSmooth.HasValue) gl.EnableIf(OpenGL.GL_POINT_SMOOTH,enablePointSmooth.Value); if(enablePolygonOffsetLine.HasValue) gl.EnableIf(OpenGL.GL_POLYGON_OFFSET_LINE,enablePolygonOffsetLine.Value); if(enablePolygonOffsetFill.HasValue) gl.EnableIf(OpenGL.GL_POLYGON_OFFSET_FILL,enablePolygonOffsetFill.Value); if(enablePolygonOffsetPoint.HasValue) gl.EnableIf(OpenGL.GL_POLYGON_OFFSET_POINT,enablePolygonOffsetPoint.Value); if(enablePolygonSmooth.HasValue) gl.EnableIf(OpenGL.GL_POLYGON_SMOOTH,enablePolygonSmooth.Value); if(enablePolygonStipple.HasValue) gl.EnableIf(OpenGL.GL_POLYGON_STIPPLE,enablePolygonStipple.Value); if(enableScissorTest.HasValue) gl.EnableIf(OpenGL.GL_SCISSOR_TEST,enableScissorTest.Value); if(enableStencilTest.HasValue) gl.EnableIf(OpenGL.GL_STENCIL,enableStencilTest.Value); if(enableTexture1D.HasValue) gl.EnableIf(OpenGL.GL_TEXTURE_1D,enableTexture1D.Value); if (enableTexture2D.HasValue) gl.EnableIf(OpenGL.GL_TEXTURE_2D, enableTexture2D.Value); }
public void SetData(OpenGL gl, uint attributeIndex, float[] rawData, bool isNormalised, int stride) { // Set the data, specify its shape and assign it to a vertex attribute (so shaders can bind to it). gl.BufferData(OpenGL.GL_ARRAY_BUFFER, rawData, OpenGL.GL_STATIC_DRAW); gl.VertexAttribPointer(attributeIndex, stride, OpenGL.GL_FLOAT, isNormalised, 0, IntPtr.Zero); gl.EnableVertexAttribArray(attributeIndex); }
/// <summary> /// Sets the attributes. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void SetAttributes(OpenGL gl) { if(enableAlphaTest.HasValue && alphaTestFunction.HasValue && alphaTestReferenceValue.HasValue) { gl.EnableIf(OpenGL.GL_ALPHA_TEST, enableAlphaTest.Value); gl.AlphaFunc(alphaTestFunction.Value, alphaTestReferenceValue.Value); } if(enableBlend.HasValue && blendingSourceFactor.HasValue && blendingDestinationFactor.HasValue) { gl.EnableIf(OpenGL.GL_BLEND, enableBlend.Value); gl.BlendFunc(blendingSourceFactor.Value, blendingDestinationFactor.Value); } if(enableDither.HasValue) gl.EnableIf(OpenGL.GL_DITHER, enableDither.Value); if(drawBufferMode.HasValue) gl.DrawBuffer(drawBufferMode.Value); if(enableLogicOp.HasValue && logicOp.HasValue) { gl.EnableIf(OpenGL.GL_COLOR_LOGIC_OP, enableLogicOp.Value); gl.LogicOp(logicOp.Value); } if(colorModeClearColor != null) gl.ClearColor(colorModeClearColor.R, colorModeClearColor.G, colorModeClearColor.B, colorModeClearColor.A); //todowritemask }
/// <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); }
public void Create(OpenGL gl) { // Generate the texture object array. uint[] ids = new uint[1]; gl.GenTextures(1, ids); textureObject = ids[0]; }
public void Create(OpenGL gl) { // Generate the vertex array. uint[] ids = new uint[1]; gl.GenVertexArrays(1, ids); vertexArrayObject = ids[0]; }
/// <summary> /// Sets the attributes. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void SetAttributes(OpenGL gl) { if (enable.HasValue) gl.EnableIf(OpenGL.GL_LIGHTING, enable.Value); if (ambientLight != null) gl.LightModel(LightModelParameter.Ambient, ambientLight); if (localViewer.HasValue) gl.LightModel(LightModelParameter.LocalViewer, localViewer.Value == true ? 1 : 0); if (twoSided.HasValue) gl.LightModel(LightModelParameter.TwoSide, twoSided.Value == true ? 1 : 0); }
public void Create(OpenGL gl) { // Generate the vertex array. uint[] ids = new uint[1]; gl.GenBuffers(1, ids); bufferObject = ids[0]; }
/// <summary> /// Creates the render context provider. Must also create the OpenGL extensions. /// </summary> /// <param name="openGLVersion">The desired OpenGL version.</param> /// <param name="gl">The OpenGL context.</param> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <param name="bitDepth">The bit depth.</param> /// <param name="parameter">The extra parameter.</param> /// <returns></returns> public override bool Create(OpenGLVersion openGLVersion, OpenGL gl, int width, int height, int bitDepth, object parameter) { // Call the base. base.Create(openGLVersion, gl, width, height, bitDepth, parameter); // Get the desktop DC. IntPtr desktopDC = Win32.GetDC(IntPtr.Zero); // Create our DC as a compatible DC for the desktop. deviceContextHandle = Win32.CreateCompatibleDC(desktopDC); // Release the desktop DC. Win32.ReleaseDC(IntPtr.Zero, desktopDC); // Create our dib section. dibSection.Create(deviceContextHandle, width, height, bitDepth); // Create the render context. Win32.wglMakeCurrent(IntPtr.Zero, IntPtr.Zero); renderContextHandle = Win32.wglCreateContext(deviceContextHandle); // Make current. MakeCurrent(); // Update the context if required. UpdateContextVersion(gl); // Return success. return true; }
/// <summary> /// Destroy in the context of the supplied OpenGL instance. /// </summary> /// <param name="gl">The OpenGL instance.</param> public void DestroyInContext(OpenGL gl) { // Delete the shader. gl.DeleteShader(ShaderObject); ShaderObject = 0; CurrentOpenGLContext = null; }
/// <summary> /// Creates the shader program. /// </summary> /// <param name="gl">The gl.</param> /// <param name="vertexShaderSource">The vertex shader source.</param> /// <param name="fragmentShaderSource">The fragment shader source.</param> /// <param name="attributeLocations">The attribute locations. This is an optional array of /// uint attribute locations to their names.</param> /// <exception cref="ShaderCompilationException"></exception> public void Create(OpenGL gl, string vertexShaderSource, string fragmentShaderSource, Dictionary<uint, string> attributeLocations) { // Create the shaders. vertexShader.Create(gl, OpenGL.GL_VERTEX_SHADER, vertexShaderSource); fragmentShader.Create(gl, OpenGL.GL_FRAGMENT_SHADER, fragmentShaderSource); // Create the program, attach the shaders. shaderProgramObject = gl.CreateProgram(); gl.AttachShader(shaderProgramObject, vertexShader.ShaderObject); gl.AttachShader(shaderProgramObject, fragmentShader.ShaderObject); // Before we link, bind any vertex attribute locations. if (attributeLocations != null) { foreach (var vertexAttributeLocation in attributeLocations) gl.BindAttribLocation(shaderProgramObject, vertexAttributeLocation.Key, vertexAttributeLocation.Value); } // Now we can link the program. gl.LinkProgram(shaderProgramObject); // Now that we've compiled and linked the shader, check it's link status. If it's not linked properly, we're // going to throw an exception. if (GetLinkStatus(gl) == false) { throw new ShaderCompilationException(string.Format("Failed to link shader program with ID {0}.", shaderProgramObject), GetInfoLog(gl)); } }
/// <summary> /// Initialises the Scene. /// </summary> /// <param name="gl">The OpenGL instance.</param> public void Initialise(OpenGL gl) { // We're going to specify the attribute locations for the position and normal, // so that we can force both shaders to explicitly have the same locations. const uint positionAttribute = 0; const uint normalAttribute = 1; var attributeLocations = new Dictionary<uint, string> { {positionAttribute, "Position"}, {normalAttribute, "Normal"}, }; // Create the per pixel shader. shaderPerPixel = new ShaderProgram(); shaderPerPixel.Create(gl, ManifestResourceLoader.LoadTextFile(@"Shaders\PerPixel.vert"), ManifestResourceLoader.LoadTextFile(@"Shaders\PerPixel.frag"), attributeLocations); // Create the toon shader. shaderToon = new ShaderProgram(); shaderToon.Create(gl, ManifestResourceLoader.LoadTextFile(@"Shaders\Toon.vert"), ManifestResourceLoader.LoadTextFile(@"Shaders\Toon.frag"), attributeLocations); // Generate the geometry and it's buffers. trefoilKnot.GenerateGeometry(gl, positionAttribute, normalAttribute); }
/// <summary> /// Sets the attributes. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void SetAttributes(OpenGL gl) { if (enableDepthTest.HasValue) gl.EnableIf(OpenGL.GL_DEPTH_TEST, enableDepthTest.Value); if (depthFunction.HasValue) gl.DepthFunc(depthFunction.Value); if (depthClearValue.HasValue) gl.ClearDepth(depthClearValue.Value); if (enableDepthWritemask.HasValue) gl.EnableIf(OpenGL.GL_DEPTH_WRITEMASK, enableDepthWritemask.Value); }
/// <summary> /// Sets the attributes. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void SetAttributes(OpenGL gl) { if (viewportX.HasValue && viewportY.HasValue && viewportWidth.HasValue && viewportHeight.HasValue) gl.Viewport(viewportX.Value, viewportY.Value, viewportWidth.Value, viewportHeight.Value); if (depthRangeNear.HasValue && depthRangeFar.HasValue) gl.DepthRange(depthRangeNear.Value, depthRangeFar.Value); }
/// <summary> /// Only valid to be called after the render context is created, this function attempts to /// move the render context to the OpenGL version originally requested. If this is > 2.1, this /// means building a new context. If this fails, we'll have to make do with 2.1. /// </summary> /// <param name="gl">The OpenGL instance.</param> protected void UpdateContextVersion(OpenGL gl) { // If the request version number is anything up to and including 2.1, standard render contexts // will provide what we need (as long as the graphics card drivers are up to date). var requestedVersionNumber = VersionAttribute.GetVersionAttribute(requestedOpenGLVersion); if (requestedVersionNumber.IsAtLeastVersion(3, 0) == false) { createdOpenGLVersion = requestedOpenGLVersion; return; } // Now the none-trivial case. We must use the WGL_ARB_create_context extension to // attempt to create a 3.0+ context. try { int[] attributes = { OpenGL.WGL_CONTEXT_MAJOR_VERSION_ARB, requestedVersionNumber.Major, OpenGL.WGL_CONTEXT_MINOR_VERSION_ARB, requestedVersionNumber.Minor, OpenGL.WGL_CONTEXT_FLAGS_ARB, OpenGL.WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, 0 }; var hrc = gl.CreateContextAttribsARB(IntPtr.Zero, attributes); Win32.wglMakeCurrent(IntPtr.Zero, IntPtr.Zero); Win32.wglDeleteContext(renderContextHandle); Win32.wglMakeCurrent(deviceContextHandle, hrc); renderContextHandle = hrc; } catch(Exception) { // TODO: can we actually get the real version? createdOpenGLVersion = OpenGLVersion.OpenGL2_1; } }
/// <summary> /// Destroy in the context of the supplied OpenGL instance. /// </summary> /// <param name="gl">The OpenGL instance.</param> public void DestroyInContext(OpenGL gl) { // Delete the shader. gl.DeleteProgram(ProgramObject); ProgramObject = 0; CurrentOpenGLContext = null; }
/// <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, Core.RenderMode renderMode) { base.Render(gl, renderMode); // Begin drawing a NURBS surface. gl.BeginSurface(nurbsRenderer); // Draw the surface. gl.NurbsSurface(nurbsRenderer, // The internal nurbs object. sKnots.Length, // Number of s-knots. sKnots, // The s-knots themselves. tKnots.Length, // The number of t-knots. tKnots, // The t-knots themselves. ControlPoints.Width * 3, // The size of a row of control points. 3, // The size of a control points. ControlPoints.ToFloatArray(), // The control points. ControlPoints.Width, // The order, i.e degree + 1. ControlPoints.Height, // The order, i.e degree + 1. OpenGL.GL_MAP2_VERTEX_3); // Type of data to generate. // End the surface. gl.EndSurface(nurbsRenderer); // Draw the control points. ControlPoints.Draw(gl, DrawControlPoints, DrawControlGrid); }
/// <summary> /// Initialises the scene. /// </summary> /// <param name="gl">The OpenGL instance.</param> /// <param name="width">The width of the screen.</param> /// <param name="height">The height of the screen.</param> public void Initialise(OpenGL gl, float width, float height) { // Set a blue clear colour. gl.ClearColor(0.4f, 0.6f, 0.9f, 0.0f); // Create the shader program. var vertexShaderSource = ManifestResourceLoader.LoadTextFile("Shader.vert"); var fragmentShaderSource = ManifestResourceLoader.LoadTextFile("Shader.frag"); shaderProgram = new ShaderProgram(); shaderProgram.Create(gl, vertexShaderSource, fragmentShaderSource, null); shaderProgram.BindAttributeLocation(gl, attributeIndexPosition, "in_Position"); shaderProgram.BindAttributeLocation(gl, attributeIndexColour, "in_Color"); shaderProgram.AssertValid(gl); // Create a perspective projection matrix. const float rads = (60.0f / 360.0f) * (float)Math.PI * 2.0f; projectionMatrix = glm.perspective(rads, width / height, 0.1f, 100.0f); // Create a view matrix to move us back a bit. viewMatrix = glm.translate(new mat4(1.0f), new vec3(0.0f, 0.0f, -5.0f)); // Create a model matrix to make the model a little bigger. modelMatrix = glm.scale(new mat4(1.0f), new vec3(2.5f)); // Now create the geometry for the square. CreateVerticesForSquare(gl); }
/// <summary> /// This function begins feedback, recording the scene etc. End finishes /// feedback, and parses the feedback buffer. /// </summary> public virtual void Begin(OpenGL gl) { // Set the feedback buffer. gl.FeedbackBuffer(feedbackBuffer.Length, OpenGL.GL_3D_COLOR_TEXTURE, feedbackBuffer); // Set the rendermode to feedback. gl.RenderMode(OpenGL.GL_FEEDBACK); }
/// <summary> /// Create in the context of the supplied OpenGL instance. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void CreateInContext(OpenGL gl) { // Create the fragment shader. ShaderObject = gl.CreateShader(OpenGL.GL_FRAGMENT_SHADER); // Store the current context. CurrentOpenGLContext = gl; }
/// <summary> /// Sets the attributes. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void SetAttributes(OpenGL gl) { if (perspectiveCorrectionHint.HasValue) gl.Hint(HintTarget.PerspectiveCorrection, perspectiveCorrectionHint.Value); if (pointSmoothHint.HasValue) gl.Hint(HintTarget.LineSmooth, pointSmoothHint.Value); if (lineSmoothHint.HasValue) gl.Hint(HintTarget.PointSmooth, lineSmoothHint.Value); if (polygonSmoothHint.HasValue) gl.Hint(HintTarget.PolygonSmooth, polygonSmoothHint.Value); if (fogHint.HasValue) gl.Hint(HintTarget.Fog, fogHint.Value); }
/// <summary> /// Pushes the effect onto the specified parent element. /// </summary> /// <param name="gl">The OpenGL instance.</param> /// <param name="parentElement">The parent element.</param> public override void Push(OpenGL gl, Core.SceneElement parentElement) { // Push the stack. gl.PushMatrix(); // Perform the transformation. arcBall.TransformMatrix(gl); }
/// <summary> /// Render to the provided instance of OpenGL. /// </summary> /// <param name="gl">The OpenGL instance.</param> /// <param name="renderMode">The render mode.</param> public virtual void Render(OpenGL gl, RenderMode renderMode) { // Set the quadric properties. gl.QuadricDrawStyle(glQuadric, (uint)drawStyle); gl.QuadricOrientation(glQuadric, (int)orientation); gl.QuadricNormals(glQuadric, (uint)normals); gl.QuadricTexture(glQuadric, textureCoords ? 1 : 0); }
/// <summary> /// Unfreezes the specified gl. /// </summary> /// <param name="gl">The gl.</param> public void Unfreeze(OpenGL gl) { if (isFrozen) { displayList.Delete(gl); isFrozen = false; } }
/// <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) { // Call the base. base.Render(gl, renderMode); // Draw a sphere with the current settings. gl.Sphere(glQuadric, radius, slices, stacks); }
/// <summary> /// Sets the attributes. /// </summary> /// <param name="gl">The OpenGL instance.</param> public override void SetAttributes(OpenGL gl) { if (enableScissorTest.HasValue) gl.EnableIf(OpenGL.GL_SCISSOR_TEST, enableScissorTest.Value); if (scissorX.HasValue && scissorY.HasValue && scissorWidth.HasValue && scissorHeight.HasValue) gl.Scissor(scissorX.Value, scissorY.Value, scissorWidth.Value, scissorHeight.Value); }
/// <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) { // Call the base. base.Render(gl, renderMode); // Draw a quadric with the current settings. gl.Cylinder(glQuadric, baseRadius, topRadius, height, slices, stacks); }
/// <summary> /// This is the class' main function, to override this function and perform a /// perspective transformation. /// </summary> public override void TransformProjectionMatrix(OpenGL gl) { // Perform the look at transformation. gl.Perspective(FieldOfView, AspectRatio, Near, Far); gl.LookAt((double)Position.X, (double)Position.Y, (double)Position.Z, (double)target.X, (double)target.Y, (double)target.Z, (double)upVector.X, (double)upVector.Y, (double)upVector.Z); }
/// <summary> /// Render texture with FBO and draw it to memory. /// </summary> private void RenderTexWithFBOandDraw() { OpenGL gl = openGLControl.OpenGL; // render to texture // adjust viewport and projection matrix to texture dimension gl.Viewport(0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT); gl.MatrixMode(OpenGL.GL_PROJECTION); gl.LoadIdentity(); gl.Perspective(fovy, (double)Width / (double)Height, 0.01f, 100.0); gl.LookAt( status.eye.x + status.kinect.x, status.eye.y + status.kinect.y, status.eye.z + status.kinect.z, buildingModelCursor.GetCoordinate().x, buildingModelCursor.GetCoordinate().y, buildingModelCursor.GetCoordinate().z, 0, 1, 0 ); // with FBO // set the rendering destination to FBO gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, framebuffer_name[0]); gl.MatrixMode(OpenGL.GL_MODELVIEW); gl.LoadIdentity(); // clear buffer gl.ClearColor(0, 0, 0, 1); gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT); // start to draw gl.PushMatrix(); // Load the identity matrix. gl.Enable(OpenGL.GL_TEXTURE_2D); drawer.DrawBuildingPart(gl, buildingModelCursor, DrawType.Full); if (status != null && buildingModelCursor != null) { switch (buildingModelCursor.GetBuildingType()) { case BuildingObjectType.Floor: drawer.DrawBuildingPart(gl, buildingOutsideModel, DrawType.WireFrame); drawer.DrawBuildingPart(gl, buildingModelCursor, DrawType.Full); break; case BuildingObjectType.Object: System.Collections.Hashtable childs = buildingModelCursor.Father.GetChilds(); foreach (System.Collections.DictionaryEntry childEntry in buildingModelCursor.Father.GetChilds()) { BuildingObjectLib3DS child = childEntry.Value as BuildingObjectLib3DS; if (child != buildingModelCursor) { drawer.DrawBuildingPart(gl, child, DrawType.WireFrame); } else { drawer.DrawBuildingPart(gl, child, DrawType.Full); } } break; case BuildingObjectType.Room: // TODO case BuildingObjectType.Outside: case BuildingObjectType.Building: drawer.DrawBuildingPart(gl, buildingModelCursor, DrawType.Full); break; } } //drawer.DrawBuildingPart(gl, modelForFun, DrawType.Full); gl.PopMatrix(); // back to normal window-system-provided framebuffer gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, 0); // unbind // trigger mipmaps generation explicitly // NOTE: If GL_GENERATE_MIPMAP is set to GL_TRUE, then glCopyTexSubImage2D() // triggers mipmap generation automatically. However, the texture attached // onto a FBO should generate mipmaps manually via glGenerateMipmapEXT(). gl.BindTexture(OpenGL.GL_TEXTURE_2D, texture_name[0]); gl.GenerateMipmapEXT(OpenGL.GL_TEXTURE_2D); //gl.TexEnv(OpenGL.GL_TEXTURE_ENV, OpenGL.GL_TEXTURE_ENV_MODE, OpenGL.GL_ADD); gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0); // TODO: without FBO, maybe need }
public SkeletonMeshRenderer(OpenGL gl) { batcher = new MeshBatcher(gl); Bone.yDown = false; }
/// <summary> /// Draw string in opengl /// </summary> /// <param name="gl"></param> /// <param name="dispText"></param> /// <param name="posX"></param> /// <param name="posY"></param> /// <param name="foreColor"></param> private void DrawString(OpenGL gl, string dispText, int posX, int posY, float[] foreColor) { gl.DrawText(posX, posY, foreColor[0], foreColor[1], foreColor[2], this.FontFamily.Source, (float)this.FontSize, dispText); }
/// <summary> /// Pops us from Object Space using the transformation into the specified OpenGL instance. /// </summary> public void PopObjectSpace(OpenGL gl) { // Pop the matrix. gl.PopMatrix(); }
public void Render(OpenGL gl, RenderMode renderMode) { //if (renderMode == RenderMode.HitTest) { return; } RenderModel(args, gl, renderMode); }
/// <summary> /// Initializes a new instance of the <see cref="OpenGLEventArgs"/> class. /// </summary> /// <param name="gl">The gl.</param> public OpenGLEventArgs(OpenGL gl) { OpenGL = gl; }
public void Draw(OpenGL gl, float width, Color color) { this.model.Draw(gl, width, color); }
/// <summary> /// Create in the context of the supplied OpenGL instance. /// </summary> /// <param name="gl">The OpenGL instance.</param> public void CreateInContext(OpenGL gl) { // Create the NURBS renderer. nurbsRenderer = gl.NewNurbsRenderer(); CurrentOpenGLContext = gl; }
/// <summary> /// Draw axis with all lines /// </summary> /// <param name="gl"></param> private void DrawAxis(OpenGL gl, double width, double height) { //Get the axis color, secondary lines color and ticks color var axisLineColor = AxisBrush.GetRGBAf(); var axisSecondaryLineColor = SecondaryGridBrush.GetRGBAf(); var ticksColor = TicksBrush.GetRGBAf(); var ticksScaleColor = TicksScaleBrush.GetRGBAf(); // Get length of Tick line double tickWidth = 5; #region Draw YTicks and labels // Ticks line of axis-Y and ticks double gapY = height / (YGapCount + 1); double realValueOfGapY = (MaxY - MinY) / (YGapCount + 1); for (int num = 0; num <= YGapCount + 1; num++) { double posX = tickWidth; double posY = gapY * num; // Draw secondary line if (IsSecondaryLineVisible) { gl.PushAttrib(OpenGL.GL_ENABLE_BIT); if (IsDotDash) { gl.LineStipple(1, 0xAAAA); gl.Enable(OpenGL.GL_LINE_STIPPLE); } else { gl.Disable(OpenGL.GL_LINE_STIPPLE); } gl.Color(axisSecondaryLineColor[0], axisSecondaryLineColor[1], axisSecondaryLineColor[2]);// will be chaged by drawText if without it gl.Begin(OpenGL.GL_LINES); gl.Vertex(0.0d, posY); gl.Vertex(width, posY); gl.End(); gl.PopAttrib(); } // Draw ticks line gl.Color(ticksScaleColor[0], ticksScaleColor[1], ticksScaleColor[2]);// will be chaged by drawText if without it gl.Begin(OpenGL.GL_LINES); gl.Vertex(0.0d, posY); gl.Vertex(tickWidth, posY); gl.End(); // Draw ticks string dispText = (num * realValueOfGapY + MinY).ToString("f2"); double textWidth = 0, textHeight = 0; GetSizeOfText(gl, dispText, ref textWidth, ref textHeight); double textPosX = 2 * tickWidth; double textPosY = num == YGapCount + 1 ? posY - textHeight : (num == 0 ? posY + 2 : posY); DrawString(gl, dispText, (int)textPosX, (int)textPosY, ticksColor); } #endregion #region Draw XTicks and labels // Ticks line of axis-X and ticks double gapX = width / (XGapCount + 1); double realValueOfGapX = (MaxX - MinX).TotalMilliseconds / (XGapCount + 1);// Milliseconds in one gap for (int num = 0; num <= XGapCount + 1; num++) { double posX = num * gapX; // Draw secondary line if (IsSecondaryLineVisible) { gl.PushAttrib(OpenGL.GL_ENABLE_BIT); if (IsDotDash) { gl.LineStipple(1, 0xAAAA); gl.Enable(OpenGL.GL_LINE_STIPPLE); } else { gl.Disable(OpenGL.GL_LINE_STIPPLE); } gl.Color(axisSecondaryLineColor[0], axisSecondaryLineColor[1], axisSecondaryLineColor[2]);// will be chaged by drawText if without it gl.Begin(OpenGL.GL_LINES); gl.Vertex(posX, 0.0d); gl.Vertex(posX, height); gl.End(); gl.PopAttrib(); } // Draw ticks line gl.Color(ticksScaleColor[0], ticksScaleColor[1], ticksScaleColor[2]);// will be chaged by drawText if without it gl.Begin(OpenGL.GL_LINES); gl.Vertex(posX, 0.0d); gl.Vertex(posX, tickWidth); gl.End(); // Draw text string dispText = (MinX + TimeSpan.FromMilliseconds(realValueOfGapX * num)).ToString("HH:mm:ss"); double textWidth = 0, textHeight = 0; GetSizeOfText(gl, dispText, ref textWidth, ref textHeight); double textPosX = num == XGapCount + 1 ? posX - textWidth - 5 : posX - textWidth / 2; double textPosY = tickWidth + textHeight / 2; DrawString(gl, dispText, (int)textPosX, (int)textPosY, ticksColor); } #endregion #region Draw Axis-X and Axis-Y // Left line of axis-Y gl.Color(axisLineColor[0], axisLineColor[1], axisLineColor[2]); gl.Begin(OpenGL.GL_LINES); gl.Vertex(0.0d, 0.0d); gl.Vertex(0.0d, height); gl.End(); // Draw right line when the axis is boxed if (IsBoxed) { gl.Begin(OpenGL.GL_LINES); gl.Vertex(width, 0.0d); gl.Vertex(width, height); gl.End(); } // Left line of axis-Y gl.Color(axisLineColor[0], axisLineColor[1], axisLineColor[2]); gl.Begin(OpenGL.GL_LINES); gl.Vertex(0.0d, 0.0d); gl.Vertex(width, 0.0d); gl.End(); // Draw right line when the axis is boxed if (IsBoxed) { gl.Begin(OpenGL.GL_LINES); gl.Vertex(0.0d, height); gl.Vertex(width, height); gl.End(); } #endregion }
/// <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, Core.RenderMode renderMode) { // Set the properties. gl.NurbsProperty(nurbsRenderer, (int)OpenGL.GLU_DISPLAY_MODE, (float)displayMode); }
public void Sync(EnginePtr exeeng, Direct3D exed3d, OpenGL exeogl, Havok exehvk, GuiFactory exegui, Forms exefms, DirectIpt exedip, WinIpt exewip, FFmpeg exeffm, CryptoPP execpp, ID3Lib exeid3, WinAudio exewad, XAudio2 exexa2, WinMidi exemid, WinSock exewsk, AsyncWorkers exeaws, SQLite exesql, HaruPdf exepdf, RayTracer exertr, Pbrt exepbrt, PythonScriptEngine exepse, Console execle) { IronSightEnginePINVOKE.Direct3D_Sync(swigCPtr, EnginePtr.getCPtr(exeeng), Direct3D.getCPtr(exed3d), OpenGL.getCPtr(exeogl), Havok.getCPtr(exehvk), GuiFactory.getCPtr(exegui), Forms.getCPtr(exefms), DirectIpt.getCPtr(exedip), WinIpt.getCPtr(exewip), FFmpeg.getCPtr(exeffm), CryptoPP.getCPtr(execpp), ID3Lib.getCPtr(exeid3), WinAudio.getCPtr(exewad), XAudio2.getCPtr(exexa2), WinMidi.getCPtr(exemid), WinSock.getCPtr(exewsk), AsyncWorkers.getCPtr(exeaws), SQLite.getCPtr(exesql), HaruPdf.getCPtr(exepdf), RayTracer.getCPtr(exertr), Pbrt.getCPtr(exepbrt), PythonScriptEngine.getCPtr(exepse), Console.getCPtr(execle)); if (IronSightEnginePINVOKE.SWIGPendingException.Pending) { throw IronSightEnginePINVOKE.SWIGPendingException.Retrieve(); } }
// Constructor, Initializes a new instance of the "FormGPS" class. public FormGPS() { //winform initialization InitializeComponent(); //build the gesture structures SetupStructSizes(); //create a new section and set left and right positions //created whether used or not, saves restarting program for (int j = 0; j < MAXSECTIONS; j++) { section[j] = new CSection(this); } // Get the OpenGL object. OpenGL gl = openGLControl.OpenGL; OpenGL glBack = openGLControlBack.OpenGL; //create the world grid worldGrid = new CWorldGrid(gl, this); //our vehicle made with gl object and pointer of mainform vehicle = new CVehicle(gl, this); //our NMEA parser pn = new CNMEA(this); //create the ABLine instance ABLine = new CABLine(gl, this); //new instance of contour mode ct = new CContour(gl, this); //new instance of contour mode curve = new CABCurve(gl, this); //new instance of auto headland turn yt = new CYouTurn(gl, glBack, this); //module communication mc = new CModuleComm(this); //perimeter list object periArea = new CPerimeter(gl); //boundary object boundz = new CBoundary(gl, glBack, this); //headland object hl = new CHeadland(gl, this); //rate object rc = new CRate(this); //headland entry/exit sequences seq = new CSequence(this); //nmea simulator built in. sim = new CSim(this); //all the autosteer objects ast = new CAutoSteer(this); //all the attitude, heading, roll, pitch reference system ahrs = new CAHRS(this); //A recorded path recPath = new CRecordedPath(gl, this); //start the stopwatch swFrame.Start(); //resource for gloabal language strings _rm = new ResourceManager("AgOpenGPS.gStr", Assembly.GetExecutingAssembly()); }
public VBO(OpenGL gl) { _gl = gl; _gl.GenBuffers(1, _handle); }
public DrawHelper(OpenGL ngl, uint nOpenglMode, List <Point> nListPoints) { gl = ngl; openglMode = nOpenglMode; listPoints = nListPoints; }
private void setLightColor(OpenGL gl) { gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_AMBIENT, lightColor[0]); //环境光 gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_DIFFUSE, lightColor[1]); //漫反射 gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPECULAR, lightColor[2]); //镜面光 }
public override void glBind(MDagPath shapePath) { // ONLY push and pop required attributes performance reasons... // OpenGL.glPushAttrib(OpenGL.GL_LIGHTING_BIT); lightingOn = OpenGL.glIsEnabled(OpenGL.GL_LIGHTING); if (lightingOn > 0) { OpenGL.glEnable(OpenGL.GL_COLOR_MATERIAL); OpenGL.glColorMaterial(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_DIFFUSE); } // Base colour is always white OpenGL.glColor4f(1.0f, 1.0f, 1.0f, 1.0f); // Bind texture if (libOpenMayaNet.MAYA_API_VERSION >= 800) { MObject l_object = shapePath.node; MFnMesh mesh = new MFnMesh(l_object); String uvSetName = "map1"; MObjectArray textures = new MObjectArray(); boundTexture = false; mesh.getAssociatedUVSetTextures(uvSetName, textures); if (textures.length > 0) { MImageFileInfo.MHwTextureType hwType = new MImageFileInfo.MHwTextureType(); MHwTextureManager.glBind(textures[0], ref hwType); boundTexture = true; } if (!boundTexture) { OpenGL.glDisable(OpenGL.GL_TEXTURE_2D); OpenGL.glBindTexture(OpenGL.GL_TEXTURE_2D, 0); } } else { // To get this code branch to compile, replace <change file name here> // with an appropriate file name if (id == 0) { MImage fileImage = new MImage(); fileImage.readFromFile("<change file name here>"); uint[] param = new uint[1]; OpenGL.glGenTextures(1, param); id = param[0]; OpenGL.glEnable(OpenGL.GL_TEXTURE_2D); OpenGL.glBindTexture(OpenGL.GL_TEXTURE_2D, id); unsafe { uint width = 0, height = 0; fileImage.getSize(out width, out height); byte *pPixels = fileImage.pixels(); OpenGL.glTexImage2D(OpenGL.GL_TEXTURE_2D, 0, (int)OpenGL.GL_RGBA8, (int)width, (int)height, 0, OpenGL.GL_RGBA, OpenGL.GL_UNSIGNED_BYTE, pPixels); } } else { OpenGL.glEnable(OpenGL.GL_TEXTURE_2D); OpenGL.glBindTexture(OpenGL.GL_TEXTURE_2D, id); } boundTexture = true; } if (boundTexture) { OpenGL.glTexParameteri(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_WRAP_S, (int)OpenGL.GL_REPEAT); OpenGL.glTexParameteri(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_WRAP_T, (int)OpenGL.GL_REPEAT); OpenGL.glTexParameteri(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, (int)OpenGL.GL_LINEAR); OpenGL.glTexParameteri(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, (int)OpenGL.GL_LINEAR); } OpenGL.glEnableClientState(OpenGL.GL_VERTEX_ARRAY); return; }
/// <summary> /// Destroy in the context of the supplied OpenGL instance. /// </summary> /// <param name="gl">The OpenGL instance.</param> public void DestroyInContext(OpenGL gl) { // Destroy the NURBS renderer. gl.DeleteNurbsRenderer(nurbsRenderer); CurrentOpenGLContext = null; }
public void DrawArea(OpenGL gl, Color color) { this.model.DrawArea(gl, color); }
private void SetVertex(OpenGL gl, float x, float y, float z) { gl.Vertex(x * zoom, y * zoom, z * zoom); }
// unbind OpenGL Vertex Array Object and OpenGL Vertex Buffer Object private static void unbindBuffers() { OpenGL.BindBuffer(OpenGL.GL_ARRAY_BUFFER, 0); OpenGL.BindVertexArray(0); }
private void OpenGLControl_OpenGLDraw(object sender, SharpGL.SceneGraph.OpenGLEventArgs args) { this.Title = "APLIMAT Final Exam"; OpenGL gl = args.OpenGL; // Clear The Screen And The Depth Buffer gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT); // Move Left And Into The Screen gl.LoadIdentity(); gl.Translate(0.0f, 0.0f, -100.0f); if (Keyboard.IsKeyDown(Key.W)) { playerCube.ApplyForce(Vector3.Up * speed); } if (Keyboard.IsKeyDown(Key.D)) { playerCube.ApplyForce(Vector3.Right * speed); } if (Keyboard.IsKeyDown(Key.A)) { playerCube.ApplyForce(Vector3.Left * speed); } if (Keyboard.IsKeyDown(Key.S)) { playerCube.ApplyForce(Vector3.Down * speed); } Console.WriteLine("X:" + playerCube.Position.x + " Y:" + playerCube.Position.y); gl.Color(0.196078f, 0.6f, 0.8f); sea.Draw(gl); gl.Color(1.0, 1.0, 1.0); playerCube.Draw(gl); if (sea.Contains(playerCube)) { var dragForce = sea.CalculateDragForce(playerCube) * 1f; playerCube.ApplyForce(dragForce); sea.changeColor(gl, 0, 0, 61); if (playerCube.Position.y <= sea1) { playerCube.Position.y = sea1; playerCube.Velocity.y *= -1; } if (playerCube.Position.x >= sea3) { playerCube.Position.x = sea3; playerCube.Velocity.x *= -1; } if (playerCube.Position.x <= sea2) { playerCube.Position.x = sea2; playerCube.Velocity.x *= -1; } } if (!sea.Contains(playerCube)) { if (playerCube.Position.y <= sea4) { if (playerCube.Position.x <= sea2) { playerCube.Position.y = sea4; playerCube.Velocity.y *= -1; playerCube.Velocity.x *= -1; } if (playerCube.Position.x >= -54 && playerCube.Position.x <= -28) { playerCube.Position.y = 3.5f; playerCube.Velocity.y *= -1; playerCube.Velocity.x *= -1; } if (playerCube.Position.x >= -13 && playerCube.Position.x <= 13) { playerCube.Position.y = 3.5f; playerCube.Velocity.y *= -1; playerCube.Velocity.x *= -1; } if (playerCube.Position.x >= 28 && playerCube.Position.x <= 54) { playerCube.Position.y = 3.5f; playerCube.Velocity.y *= -1; playerCube.Velocity.x *= -1; } if (playerCube.Position.x >= sea3) { playerCube.Position.y = sea4; playerCube.Velocity.y *= -1; playerCube.Velocity.x *= -1; } } if (playerCube.Position.x >= sea2 && playerCube.Position.x <= sea3) { if (playerCube.Position.y <= sea4) { if (playerCube.Position.x <= sea2) { playerCube.Position.x = sea2; playerCube.Velocity.x *= -1; } if (playerCube.Position.x >= sea3) { playerCube.Position.x = sea3; playerCube.Velocity.x *= -1; } } } } //cliff and sea #region gl.Color(0.36, 0.25, 0.20); cliff1.Draw(gl); cliff1.Scale = new Vector3(1 * cliff1.Mass / 4, 1 * cliff1.Mass / 2, 0); cliff2.Draw(gl); cliff2.Scale = new Vector3(1 * cliff2.Mass / 4, 1 * cliff2.Mass / 2, 0); cliff3.Draw(gl); cliff3.Scale = new Vector3(1 * cliff3.Mass / 1, 1 * cliff3.Mass / 8, 0); //middle cliff cliff4.Draw(gl); cliff4.Scale = new Vector3(1 * cliff4.Mass / 8, 1 * cliff4.Mass / 4, 0); cliff5.Draw(gl); cliff5.Scale = new Vector3(1 * cliff5.Mass / 8, 1 * cliff5.Mass / 4, 0); cliff6.Draw(gl); cliff6.Scale = new Vector3(1 * cliff6.Mass / 8, 1 * cliff6.Mass / 4, 0); #endregion #region sample for testing #endregion #region idea2 #endregion #region keypress if (Keyboard.IsKeyDown(Key.W)) { myCube.ApplyForce(Vector3.Up * speed); } if (Keyboard.IsKeyDown(Key.D)) { myCube.ApplyForce(Vector3.Right * speed); } if (Keyboard.IsKeyDown(Key.A)) { myCube.ApplyForce(Vector3.Left * speed); } if (Keyboard.IsKeyDown(Key.S)) { myCube.ApplyForce(Vector3.Down * speed); } if (Mouse.LeftButton == MouseButtonState.Pressed) { } #endregion }
public void Draw(OpenGL gl, Skeleton skeleton) { if (skeleton == null) { return; } var drawOrder = skeleton.DrawOrder; var drawOrderItems = skeleton.DrawOrder.Items; float skeletonR = skeleton.R, skeletonG = skeleton.G, skeletonB = skeleton.B, skeletonA = skeleton.A; for (int i = 0, n = drawOrder.Count; i < n; i++) { float[] vertices = this.vertices; Slot slot = drawOrderItems[i]; Attachment attachment = slot.Attachment; if (attachment is RegionAttachment) { RegionAttachment regionAttachment = (RegionAttachment)attachment; MeshItem item = batcher.NextItem(4, 6); item.triangles = quadTriangles; VertexPositionColorTexture[] itemVertices = item.vertices; AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject; item.texture = (uint)region.page.rendererObject; Color color; float a = skeletonA * slot.A * regionAttachment.A; if (premultipliedAlpha) { color = new Color( skeletonR * slot.R * regionAttachment.R * a, skeletonG * slot.G * regionAttachment.G * a, skeletonB * slot.B * regionAttachment.B * a, a); } else { color = new Color( skeletonR * slot.R * regionAttachment.R, skeletonG * slot.G * regionAttachment.G, skeletonB * slot.B * regionAttachment.B, a); } itemVertices[TL].color = color; itemVertices[BL].color = color; itemVertices[BR].color = color; itemVertices[TR].color = color; regionAttachment.ComputeWorldVertices(slot.Bone, vertices); itemVertices[TL].position = new Vector2(vertices[RegionAttachment.X1], vertices[RegionAttachment.Y1]); itemVertices[BL].position = new Vector2(vertices[RegionAttachment.X2], vertices[RegionAttachment.Y2]); itemVertices[BR].position = new Vector2(vertices[RegionAttachment.X3], vertices[RegionAttachment.Y3]); itemVertices[TR].position = new Vector2(vertices[RegionAttachment.X4], vertices[RegionAttachment.Y4]); float[] uvs = regionAttachment.UVs; itemVertices[TL].textureCoordinate = new Vector2(uvs[RegionAttachment.X1], uvs[RegionAttachment.Y1]); itemVertices[BL].textureCoordinate = new Vector2(uvs[RegionAttachment.X2], uvs[RegionAttachment.Y2]); itemVertices[BR].textureCoordinate = new Vector2(uvs[RegionAttachment.X3], uvs[RegionAttachment.Y3]); itemVertices[TR].textureCoordinate = new Vector2(uvs[RegionAttachment.X4], uvs[RegionAttachment.Y4]); } else if (attachment is MeshAttachment) { MeshAttachment mesh = (MeshAttachment)attachment; int vertexCount = mesh.WorldVerticesLength; if (vertices.Length < vertexCount) { vertices = new float[vertexCount]; } mesh.ComputeWorldVertices(slot, vertices); int[] triangles = mesh.Triangles; MeshItem item = batcher.NextItem(vertexCount, triangles.Length); item.triangles = triangles; AtlasRegion region = (AtlasRegion)mesh.RendererObject; item.texture = (uint)region.page.rendererObject; Color color; float a = skeletonA * slot.A * mesh.A; if (premultipliedAlpha) { color = new Color( skeletonR * slot.R * mesh.R * a, skeletonG * slot.G * mesh.G * a, skeletonB * slot.B * mesh.B * a, a); } else { color = new Color( skeletonR * slot.R * mesh.R, skeletonG * slot.G * mesh.G, skeletonB * slot.B * mesh.B, a); } float[] uvs = mesh.UVs; VertexPositionColorTexture[] itemVertices = item.vertices; for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2) { itemVertices[ii].color = color; itemVertices[ii].position = new Vector2(vertices[v], vertices[v + 1]); itemVertices[ii].textureCoordinate = new Vector2(uvs[v], uvs[v + 1]); } } } batcher.Draw(gl); }
public static void Run() { GLFW.SetErrorCallback(onError); if (!GLFW.Initialize()) { Console.WriteLine($"Failed to initialize GLFW."); return; } var possibleWindow = createWindow("GLFW Drawing Test"); if (!possibleWindow.HasValue) { Console.WriteLine($"Unable to load create window."); GLFW.Terminate(); return; } IntPtr window = possibleWindow.Value; GLFW.MakeContextCurrent(window); GLFW.SetKeyCallback(window, keyBindings); setupViewport(window); string vertexShaderText = loadShaderFile("Shaders/triangle.vert"); // create the OpenGL Vertex Shader Object uint vertexShader = 0; try { vertexShader = createShader(OpenGL.GL_VERTEX_SHADER, vertexShaderText); } catch (ShaderCompileException e) { Console.WriteLine(e.Message); GLFW.Terminate(); return; } string fragmentShaderText = loadShaderFile("Shaders/orange.frag"); // create the OpenGL Fragment Shader Object uint fragmentShader = 0; try { fragmentShader = createShader(OpenGL.GL_FRAGMENT_SHADER, fragmentShaderText); } catch (ShaderCompileException e) { Console.WriteLine(e.Message); OpenGL.DeleteShader(vertexShader); GLFW.Terminate(); return; } uint program = 0; try { program = createProgram(vertexShader, fragmentShader); } catch (LinkingException e) { Console.WriteLine(e.Message); OpenGL.DeleteShader(vertexShader); OpenGL.DeleteShader(fragmentShader); GLFW.Terminate(); return; } OpenGL.DeleteShader(vertexShader); OpenGL.DeleteShader(fragmentShader); uint vertexArray = loadVertexArrayObject(); uint vertexBuffer = loadVertexBufferObject(); // (x, y, z) coordinate pairs float[] vertices = { 0.0f, 0.5f, 0.0f, // top 0.5f, -0.5f, 0.0f, // bottom right -0.5f, -0.5f, 0.0f // bottom left }; loadVertices(vertices); // divide by 3 since each vertex is made up of 3 points setupDrawing(vertices.Length / 3); unbindBuffers(); while (GLFW.WindowShouldClose(window) == 0) { GLFW.PollEvents(); // red, green, and blue values range from 0 (0) - 255 (1) OpenGL.ClearColor(1 / 255.0f, 113 / 255.0f, 187 / 255.0f, 1.0f); OpenGL.Clear(OpenGL.GL_COLOR_BUFFER_BIT); OpenGL.UseProgram(program); OpenGL.BindVertexArray(vertexArray); OpenGL.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3); OpenGL.BindVertexArray(0); GLFW.SwapBuffers(window); } // delete vertex array OpenGL.DeleteVertexArrays(1, ref vertexArray); // delete vertex buffer OpenGL.DeleteBuffers(1, ref vertexBuffer); // terminate GLFW, clearing any resources allocated by GLFW GLFW.Terminate(); }
private void FillNode(TreemapNode n, RectD nBounds, RectD vBounds, double pxX, double pxY, int depth) { if (Overlaps(nBounds, vBounds)) { GLTexture tex = n.Texture; if (tex != null && tex.Valid) { OpenGL.glEnd(); OpenGL.glEnable(OpenGL.GL_TEXTURE_2D); OpenGL.glDisable(OpenGL.GL_BLEND); tex.Bind(); OpenGL.glColor3f(1.0f, 1.0f, 1.0f); OpenGL.glBegin(OpenGL.GL_QUADS); } else { RGB col = new RGB(new HSV(depth * (1.0f / 6.0f), 0.5f - depth / 256.0f, 1)); OpenGL.glColor3f(col.r, col.g, col.b); } { OpenGL.glTexCoord2f(0.0f, 0.0f); OpenGL.glVertex2f((float)nBounds.Left, (float)nBounds.Top); OpenGL.glTexCoord2f(0.0f, 1.0f); OpenGL.glVertex2f((float)nBounds.Left, (float)nBounds.Bottom); OpenGL.glTexCoord2f(1.0f, 1.0f); OpenGL.glVertex2f((float)nBounds.Right, (float)nBounds.Bottom); OpenGL.glTexCoord2f(1.0f, 0.0f); OpenGL.glVertex2f((float)nBounds.Right, (float)nBounds.Top); } if (tex != null && tex.Valid) { OpenGL.glEnd(); tex.Unbind(); OpenGL.glDisable(OpenGL.GL_TEXTURE_2D); OpenGL.glEnable(OpenGL.GL_BLEND); OpenGL.glBegin(OpenGL.GL_QUADS); } RectD conBounds = new RectD( nBounds.Left + nBounds.Width * 0.01f, nBounds.Top + nBounds.Height * 0.03f, nBounds.Right - nBounds.Width * 0.01f, nBounds.Bottom - nBounds.Height * 0.01f); for (int i = 0, c = n.Children.Count; i != c; ++i) { TreemapNode cn = n.Children[i]; RectD cBounds = new RectD( cn.Bounds.Left * conBounds.Width + conBounds.Left, cn.Bounds.Top * conBounds.Height + conBounds.Top, cn.Bounds.Right * conBounds.Width + conBounds.Left, cn.Bounds.Bottom * conBounds.Height + conBounds.Top); if (cBounds.Width > pxX * 5) { cBounds.Left += pxX * m_pxNodeMargin; cBounds.Right -= pxX * m_pxNodeMargin; } if (cBounds.Height > pxY * 5) { cBounds.Top += pxY * m_pxNodeMargin; cBounds.Bottom -= pxY * m_pxNodeMargin; } FillNode(cn, cBounds, vBounds, pxX, pxY, depth + 1); } } }
private void openGLControl1_OpenGLInitialized(object sender, EventArgs e) { OpenGL gl = openGLControl1.OpenGL; gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT); }
public SSBObject() { Device = GraphicsManager.Instance.Device; }
public SceneInfo_Secondary(OpenGL _gl, DataForDraw_angled _Data) : base(_gl) { Data = _Data; }
//vẽ hình static void Repaint(Point pStart, Point pEnd, int Shape, int Size, Scolor Color, bool checkClickDown, ref Sgraph temp, ref OpenGL gl) { double Rx, Ry; Point pTemp = new Point(); gl.Color(Color.R / 255.0, Color.G / 255.0, Color.B / 255.0, 0); gl.LineWidth(Size); switch (Shape) { case 0: //vẽ đoạn thẳng gl.Begin(OpenGL.GL_LINES); // chọn chế độ vẽ đường thẳng gl.Vertex(pStart.X, gl.RenderContextProvider.Height - pStart.Y); gl.Vertex(pEnd.X, gl.RenderContextProvider.Height - pEnd.Y); gl.End(); gl.Flush(); // Thực hiện lệnh vẽ ngay lập tức thay vì đợi sau 1 khoảng thời gian break; case 1: //vẽ hình tròn double thetar; Rx = Math.Sqrt(Math.Pow(pStart.X - pEnd.X, 2) + Math.Pow(pStart.Y - pEnd.Y, 2)); gl.Begin(OpenGL.GL_LINE_LOOP); for (int i = 0; i < 360; i++) { thetar = i * Math.PI / 180; gl.Vertex(pStart.X + Rx * Math.Cos(thetar), gl.RenderContextProvider.Height - pStart.Y + Rx * Math.Sin(thetar)); } gl.End(); gl.Flush(); // Thực hiện lệnh vẽ ngay lập tức thay vì đợi sau 1 khoảng thời gian break; case 2: //ve hình chữ nhật gl.Begin(OpenGL.GL_LINE_LOOP); gl.Vertex(pStart.X, gl.RenderContextProvider.Height - pStart.Y); gl.Vertex(pStart.X, gl.RenderContextProvider.Height - pEnd.Y); gl.Vertex(pEnd.X, gl.RenderContextProvider.Height - pEnd.Y); gl.Vertex(pEnd.X, gl.RenderContextProvider.Height - pStart.Y); gl.End(); gl.Flush(); // Thực hiện lệnh vẽ ngay lập tức thay vì đợi sau 1 khoảng thời gian if (checkClickDown == false) { temp.List_Graph_Point.Clear(); temp.List_Graph_Point.Add(pStart); pTemp.X = pStart.X; pTemp.Y = pEnd.Y; temp.List_Graph_Point.Add(pTemp); temp.List_Graph_Point.Add(pEnd); pTemp.X = pEnd.X; pTemp.Y = pStart.Y; temp.List_Graph_Point.Add(pTemp); } break; case 3: //ve elip Rx = Math.Sqrt(Math.Pow(pStart.X - pEnd.X, 2)); Ry = Math.Sqrt(Math.Pow(pStart.Y - pEnd.Y, 2)); double x, y; gl.Begin(OpenGL.GL_LINE_LOOP); for (int i = 0; i < 360; i++) { thetar = i * Math.PI / 180; x = pStart.X + Rx * Math.Cos(thetar); y = gl.RenderContextProvider.Height - pStart.Y + Ry * Math.Sin(thetar); gl.Vertex(x, y); } gl.End(); gl.Flush(); // Thực hiện lệnh vẽ ngay lập tức thay vì đợi sau 1 khoảng thời gian break; case 4: //ve tam giac deu Rx = Math.Sqrt(Math.Pow(pStart.X - pEnd.X, 2) + Math.Pow(pStart.Y - pEnd.Y, 2)); gl.Begin(OpenGL.GL_LINE_LOOP); for (int i = 0; i < 360; i += 120) { { thetar = i * Math.PI / 180; gl.Vertex(pStart.X + Rx * Math.Cos(thetar - Math.PI / 2), gl.RenderContextProvider.Height - pStart.Y - Rx * Math.Sin(thetar - Math.PI / 2)); } } gl.End(); gl.Flush(); // Thực hiện lệnh vẽ ngay lập tức thay vì đợi sau 1 khoảng thời gian if (checkClickDown == false) { temp.List_Graph_Point.Clear(); for (int i = 0; i < 360; i += 120) { { thetar = i * Math.PI / 180; pTemp.X = (int)(pStart.X + Rx * Math.Cos(thetar - Math.PI / 2)); pTemp.Y = (int)(pStart.Y + Rx * Math.Sin(thetar - Math.PI / 2)); temp.List_Graph_Point.Add(pTemp); } } } break; case 5: //ve ngu giac deu Rx = Math.Sqrt(Math.Pow(pStart.X - pEnd.X, 2) + Math.Pow(pStart.Y - pEnd.Y, 2)); gl.Begin(OpenGL.GL_LINE_LOOP); for (int i = 0; i < 360; i += 72) { //if (i % 72 == 0) { thetar = i * Math.PI / 180; gl.Vertex(pStart.X + Rx * Math.Cos(thetar + Math.PI / 2), gl.RenderContextProvider.Height - pStart.Y + Rx * Math.Sin(thetar + Math.PI / 2)); } } gl.End(); gl.Flush(); // Thực hiện lệnh vẽ ngay lập tức thay vì đợi sau 1 khoảng thời gian if (checkClickDown == false) { temp.List_Graph_Point.Clear(); for (int i = 0; i < 360; i += 72) { { thetar = i * Math.PI / 180; pTemp.X = (int)(pStart.X + Rx * Math.Cos(thetar + Math.PI / 2)); pTemp.Y = (int)(pStart.Y - Rx * Math.Sin(thetar + Math.PI / 2)); temp.List_Graph_Point.Add(pTemp); } } } break; case 6: //ve luc giac deu Rx = Math.Sqrt(Math.Pow(pStart.X - pEnd.X, 2) + Math.Pow(pStart.Y - pEnd.Y, 2)); gl.Begin(OpenGL.GL_LINE_LOOP); for (int i = 1; i < 360; i++) { if (i % 30 == 0 && i % 60 != 0) { thetar = i * Math.PI / 180; gl.Vertex(pStart.X + Rx * Math.Cos(thetar + Math.PI / 2), gl.RenderContextProvider.Height - pStart.Y + Rx * Math.Sin(thetar + Math.PI / 2)); } } gl.End(); gl.Flush(); // Thực hiện lệnh vẽ ngay lập tức thay vì đợi sau 1 khoảng thời gian if (checkClickDown == false) { temp.List_Graph_Point.Clear(); for (int i = 0; i < 360; i++) { if (i % 30 == 0 && i % 60 != 0) { thetar = i * Math.PI / 180; pTemp.X = (int)(pStart.X + Rx * Math.Cos(thetar + Math.PI / 2)); pTemp.Y = (int)(pStart.Y - Rx * Math.Sin(thetar + Math.PI / 2)); temp.List_Graph_Point.Add(pTemp); } } } break; } }
public override void CreateInContext(OpenGL gl) { ShaderObject = gl.CreateShader(0x8DD9); CurrentOpenGLContext = gl; }
private void openGLControl1_OpenGLDraw(object sender, RenderEventArgs e) { UpdateLabelInfo(); // Get the OpenGL object, just to clean up the code. OpenGL gl = this.openGLControl1.OpenGL; gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer gl.LoadIdentity(); // Reset The View // gl.Color(1.0f, 1.0f, 1.0f); // gl.FontBitmaps.DrawText(gl, 0, 0, "Arial", "Argh"); var width = this.openGLControl1.Width; var height = this.openGLControl1.Height; //gl.Ortho(-width / 2, width / 2, -height / 2, height / 2, -100, 100); //gl.LookAt() gl.Translate(-1.5f, 0.0f, -6.0f); // Move Left And Into The Screen gl.Rotate(rtri, 0.0f, 1.0f, 0.0f); // Rotate The Pyramid On It's Y Axis gl.Begin(OpenGL.GL_TRIANGLES); // Start Drawing The Pyramid gl.Color(1.0f, 0.0f, 0.0f); // Red gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Front) gl.Color(0.0f, 1.0f, 0.0f); // Green gl.Vertex(-1.0f, -1.0f, 1.0f); // Left Of Triangle (Front) gl.Color(0.0f, 0.0f, 1.0f); // Blue gl.Vertex(1.0f, -1.0f, 1.0f); // Right Of Triangle (Front) gl.Color(1.0f, 0.0f, 0.0f); // Red gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Right) gl.Color(0.0f, 0.0f, 1.0f); // Blue gl.Vertex(1.0f, -1.0f, 1.0f); // Left Of Triangle (Right) gl.Color(0.0f, 1.0f, 0.0f); // Green gl.Vertex(1.0f, -1.0f, -1.0f); // Right Of Triangle (Right) gl.Color(1.0f, 0.0f, 0.0f); // Red gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Back) gl.Color(0.0f, 1.0f, 0.0f); // Green gl.Vertex(1.0f, -1.0f, -1.0f); // Left Of Triangle (Back) gl.Color(0.0f, 0.0f, 1.0f); // Blue gl.Vertex(-1.0f, -1.0f, -1.0f); // Right Of Triangle (Back) gl.Color(1.0f, 0.0f, 0.0f); // Red gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Left) gl.Color(0.0f, 0.0f, 1.0f); // Blue gl.Vertex(-1.0f, -1.0f, -1.0f); // Left Of Triangle (Left) gl.Color(0.0f, 1.0f, 0.0f); // Green gl.Vertex(-1.0f, -1.0f, 1.0f); // Right Of Triangle (Left) gl.End(); // Done Drawing The Pyramid gl.LoadIdentity(); gl.Translate(1.5f, 0.0f, -7.0f); // Move Right And Into The Screen gl.Rotate(rquad, 1.0f, 1.0f, 1.0f); // Rotate The Cube On X, Y & Z gl.Begin(OpenGL.GL_QUADS); // Start Drawing The Cube gl.Color(0.0f, 1.0f, 0.0f); // Set The Color To Green gl.Vertex(1.0f, 1.0f, -1.0f); // Top Right Of The Quad (Top) gl.Vertex(-1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Top) gl.Vertex(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Quad (Top) gl.Vertex(1.0f, 1.0f, 1.0f); // Bottom Right Of The Quad (Top) gl.Color(1.0f, 0.5f, 0.0f); // Set The Color To Orange gl.Vertex(1.0f, -1.0f, 1.0f); // Top Right Of The Quad (Bottom) gl.Vertex(-1.0f, -1.0f, 1.0f); // Top Left Of The Quad (Bottom) gl.Vertex(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Quad (Bottom) gl.Vertex(1.0f, -1.0f, -1.0f); // Bottom Right Of The Quad (Bottom) gl.Color(1.0f, 0.0f, 0.0f); // Set The Color To Red gl.Vertex(1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Front) gl.Vertex(-1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Front) gl.Vertex(-1.0f, -1.0f, 1.0f); // Bottom Left Of The Quad (Front) gl.Vertex(1.0f, -1.0f, 1.0f); // Bottom Right Of The Quad (Front) gl.Color(1.0f, 1.0f, 0.0f); // Set The Color To Yellow gl.Vertex(1.0f, -1.0f, -1.0f); // Bottom Left Of The Quad (Back) gl.Vertex(-1.0f, -1.0f, -1.0f); // Bottom Right Of The Quad (Back) gl.Vertex(-1.0f, 1.0f, -1.0f); // Top Right Of The Quad (Back) gl.Vertex(1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Back) gl.Color(0.0f, 0.0f, 1.0f); // Set The Color To Blue gl.Vertex(-1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Left) gl.Vertex(-1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Left) gl.Vertex(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Quad (Left) gl.Vertex(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Quad (Left) gl.Color(1.0f, 0.0f, 1.0f); // Set The Color To Violet gl.Vertex(1.0f, 1.0f, -1.0f); // Top Right Of The Quad (Right) gl.Vertex(1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Right) gl.Vertex(1.0f, -1.0f, 1.0f); // Bottom Left Of The Quad (Right) gl.Vertex(1.0f, -1.0f, -1.0f); // Bottom Right Of The Quad (Right) gl.End(); // Done Drawing The Q gl.Flush(); rtri += 3.0f; // 0.2f; // Increase The Rotation Variable For The Triangle rquad -= 3.0f; // 0.15f; // Decrease The Rotation Variable For The Quad }