func main() { // Initialize GLFW for window management glfw.SetErrorCallback(glfwErrorCallback) if !glfw.Init() { panic("failed to initialize glfw") } defer glfw.Terminate() glfw.WindowHint(glfw.Resizable, glfw.False) glfw.WindowHint(glfw.ContextVersionMajor, 3) glfw.WindowHint(glfw.ContextVersionMinor, 3) glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // Necessary for OS X glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile) // Necessary for OS X glfw.WindowHint(glfw.OpenglDebugContext, glfw.True) window, err := glfw.CreateWindow(WindowWidth, WindowHeight, "Cube", nil, nil) if err != nil { panic(err) } window.MakeContextCurrent() // Initialize Glow if err := gl.Init(); err != nil { panic(err) } // Note that it is possible to use GL functions spanning multiple versions if err := gl4.Init(); err != nil { fmt.Printf("Could not initialize GL 4.4 (non-fatal)") } if gl.ARB_debug_output { gl.Enable(gl.DEBUG_OUTPUT_SYNCHRONOUS_ARB) gl.DebugMessageCallbackARB(gl.DebugProc(glDebugCallback), gl.Ptr(nil)) // Trigger an error to demonstrate debug output gl.Enable(gl.CONTEXT_FLAGS) } version := gl.GoStr(gl.GetString(gl.VERSION)) fmt.Println("OpenGL version", version) // Configure the vertex and fragment shaders program, err := newProgram(vertexShader, fragmentShader) if err != nil { panic(err) } gl.UseProgram(program) projection := mgl32.Perspective(70.0, float32(WindowWidth)/WindowHeight, 0.1, 10.0) projectionUniform := gl.GetUniformLocation(program, gl.Str("projection\x00")) gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0]) camera := mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0}) cameraUniform := gl.GetUniformLocation(program, gl.Str("camera\x00")) gl.UniformMatrix4fv(cameraUniform, 1, false, &camera[0]) model := mgl32.Ident4() modelUniform := gl.GetUniformLocation(program, gl.Str("model\x00")) gl.UniformMatrix4fv(modelUniform, 1, false, &model[0]) textureUniform := gl.GetUniformLocation(program, gl.Str("tex\x00")) gl.Uniform1i(textureUniform, 0) gl.BindFragDataLocation(program, 0, gl.Str("outputColor\x00")) // Load the texture texture, err := newTexture("square.png") if err != nil { panic(err) } // Configure the vertex data var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) gl.BufferData(gl.ARRAY_BUFFER, len(cubeVertices)*4, gl.Ptr(cubeVertices), gl.STATIC_DRAW) vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00"))) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0)) texCoordAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertTexCoord\x00"))) gl.EnableVertexAttribArray(texCoordAttrib) gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4)) // Configure global settings gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(1.0, 1.0, 1.0, 1.0) angle := 0.0 previousTime := glfw.GetTime() for !window.ShouldClose() { gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // Update time := glfw.GetTime() elapsed := time - previousTime previousTime = time angle += elapsed model = mgl32.HomogRotate3D(float32(angle), mgl32.Vec3{0, 1, 0}) // Render gl.UseProgram(program) gl.UniformMatrix4fv(modelUniform, 1, false, &model[0]) gl.BindVertexArray(vao) gl.ActiveTexture(gl.TEXTURE0) gl.BindTexture(gl.TEXTURE_2D, texture) gl.DrawArrays(gl.TRIANGLES, 0, 6*2*3) // Maintenance window.SwapBuffers() glfw.PollEvents() } }
func onStart(glctx gl.Context, sz size.Event) { log.Printf("creating GL program") var err error keystate = map[touch.Sequence]int{} program, err = glutil.CreateProgram(glctx, vertexShader, fragmentShader) if err != nil { log.Printf("error creating GL program: %v", err) return } glctx.Enable(gl.DEPTH_TEST) position = glctx.GetAttribLocation(program, "position") texCordIn = glctx.GetAttribLocation(program, "texCordIn") color = glctx.GetUniformLocation(program, "color") drawi = glctx.GetUniformLocation(program, "drawi") projection = glctx.GetUniformLocation(program, "projection") camera = glctx.GetUniformLocation(program, "camera") loadTexture(glctx) glctx.UseProgram(program) projectionMat := mgl32.Perspective(mgl32.DegToRad(75.0), float32(1), 0.5, 40.0) glctx.UniformMatrix4fv(projection, projectionMat[:]) cameraMat := mgl32.LookAtV(mgl32.Vec3{0.5, 0, 1.5}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0}) glctx.UniformMatrix4fv(camera, cameraMat[:]) board = NewBoard(glctx, float32(0.05), 10) numKeys := len(board.bigKeys) + len(board.smallKeys) InitializeSound(numKeys) }
func onPaint(glctx gl.Context, sz size.Event) { glctx.Viewport(0, 0, sz.WidthPx, sz.HeightPx) glctx.ClearColor(0.5, 0.5, 0.5, 1) glctx.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) glctx.UseProgram(program) projectionMtx = mgl32.Perspective(45, float32(width)/float32(height), 0.1, 100) arcBallMtx := arcball.getMtx() glctx.UniformMatrix4fv(projection, projectionMtx[:]) glctx.UniformMatrix4fv(view, arcBallMtx[:]) glctx.BindBuffer(gl.ARRAY_BUFFER, triBuf) glctx.EnableVertexAttribArray(position) glctx.EnableVertexAttribArray(color) glctx.EnableVertexAttribArray(normals) vertSize := 4 * (coordsPerVertex + colorPerVertex + normalsPerVertex) glctx.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, vertSize, 0) glctx.VertexAttribPointer(color, colorPerVertex, gl.FLOAT, false, vertSize, 4*coordsPerVertex) glctx.VertexAttribPointer(normals, normalsPerVertex, gl.FLOAT, false, vertSize, 4*(coordsPerVertex+colorPerVertex)) glctx.DepthMask(true) glctx.Uniform3fv(lightPos, light.Pos[:]) glctx.Uniform3fv(lightIntensity, light.Intensities[:]) for _, k := range piano.Keys { glctx.Uniform4fv(tint, k.Color[:]) mtx := k.GetMtx() normMat := mtx.Mat3().Inv().Transpose() glctx.UniformMatrix3fv(normalMatrix, normMat[:]) glctx.UniformMatrix4fv(model, mtx[:]) glctx.DrawArrays(gl.TRIANGLES, 0, len(triangleData)/vertSize) } modelMtx := mgl32.Ident4() modelMtx = modelMtx.Mul4(mgl32.Translate3D(worldPos.X(), worldPos.Y(), worldPos.Z())) modelMtx = modelMtx.Mul4(mgl32.Scale3D(0.5, 0.5, 0.5)) /* glctx.Uniform4fv(tint, red[:]) // Disable depthmask so we dont get the pixel depth of the cursor cube glctx.DepthMask(false) glctx.UniformMatrix4fv(model, modelMtx[:]) glctx.DepthMask(true) */ glctx.DisableVertexAttribArray(position) glctx.DisableVertexAttribArray(color) glctx.DisableVertexAttribArray(normals) fps.Draw(sz) }
// // Draw Loop Function // This function gets called on every update. // func drawLoop(glw *wrapper.Glw) { // Sets the Clear Color (Background Color) gl.ClearColor(0.0, 0.0, 0.0, 1.0) // Clears the Window gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // Enables Depth gl.Enable(gl.DEPTH_TEST) // Sets the Shader program to Use gl.UseProgram(shaderProgram) // Define the model transformations for the cube cube.ResetModel() cube.Translate(x+0.5, y, z) cube.Scale(scale, scale, scale) //scale equally in all axis cube.Rotate(-angle_x, mgl32.Vec3{1, 0, 0}) //rotating in clockwise direction around x-axis cube.Rotate(-angle_y, mgl32.Vec3{0, 1, 0}) //rotating in clockwise direction around y-axis cube.Rotate(-angle_z, mgl32.Vec3{0, 0, 1}) //rotating in clockwise direction around z-axis // Define the model transformations for our sphere sphere.ResetModel() sphere.Translate(-x-0.5, 0, 0) sphere.Scale(scale/3.0, scale/3.0, scale/3.0) //scale equally in all axis sphere.Rotate(-angle_x, mgl32.Vec3{1, 0, 0}) //rotating in clockwise direction around x-axis sphere.Rotate(-angle_y, mgl32.Vec3{0, 1, 0}) //rotating in clockwise direction around y-axis sphere.Rotate(-angle_z, mgl32.Vec3{0, 0, 1}) //rotating in clockwise direction around z-axis // Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units var Projection mgl32.Mat4 = mgl32.Perspective(30.0, aspect_ratio, 0.1, 100.0) // Camera matrix var View mgl32.Mat4 = mgl32.LookAtV( mgl32.Vec3{0, 0, 4}, // Camera is at (0,0,4), in World Space mgl32.Vec3{0, 0, 0}, // and looks at the origin mgl32.Vec3{0, 1, 0}, // Head is up (set to 0,-1,0 to look upside-down) ) // Send our uniforms variables to the currently bound shader, gl.Uniform1ui(colourmodeUniform, uint32(colourmode)) gl.UniformMatrix4fv(viewUniform, 1, false, &View[0]) gl.UniformMatrix4fv(projectionUniform, 1, false, &Projection[0]) // Draws the Cube gl.UniformMatrix4fv(modelUniform, 1, false, &cube.Model[0]) cube.Draw() // Draw our sphere gl.UniformMatrix4fv(modelUniform, 1, false, &sphere.Model[0]) sphere.DrawSphere() gl.DisableVertexAttribArray(0) gl.UseProgram(0) /* Modify our animation variables */ angle_x += angle_inc_x angle_y += angle_inc_y angle_z += angle_inc_z }
func renderCallback(delta float64) { gl.Viewport(0, 0, int32(app.Width), int32(app.Height)) gl.ClearColor(0.196078, 0.6, 0.8, 1.0) // some pov-ray sky blue gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // make the projection and view matrixes projection := mgl.Perspective(mgl.DegToRad(60.0), float32(app.Width)/float32(app.Height), 1.0, 200.0) view := app.CameraRotation.Mat4() view = view.Mul4(mgl.Translate3D(-app.CameraPos[0], -app.CameraPos[1], -app.CameraPos[2])) // draw the cube cube.Node.Draw(projection, view) // draw all of the bullets for _, bullet := range bullets { bullet.Node.Draw(projection, view) } // draw the backboard backboard.Node.Draw(projection, view) // draw the ground ground.Draw(projection, view) //time.Sleep(10 * time.Millisecond) }
// Load loads and sets up the model func (m *Model) Load(fileName string) { m.loadFile(fileName) shader := sm.Shader{VertSrcFile: m.data.VertShaderFile, FragSrcFile: m.data.FragShaderFile, Name: fmt.Sprintf("%s:%s", m.data.VertShaderFile, m.data.FragShaderFile)} program, err := m.shaders.LoadProgram(shader, false) if err != nil { return } m.currentProgram = program gl.UseProgram(m.currentProgram) m.projection = mgl32.Perspective(mgl32.DegToRad(45.0), float32(windowWidth)/windowHeight, 0.1, 10.0) m.projectionUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("projection\x00")) gl.UniformMatrix4fv(m.projectionUniform, 1, false, &m.projection[0]) m.camera = mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0}) m.cameraUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("camera\x00")) gl.UniformMatrix4fv(m.cameraUniform, 1, false, &m.camera[0]) m.modelUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("model\x00")) gl.UniformMatrix4fv(m.modelUniform, 1, false, &m.model[0]) m.textureUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("tex\x00")) gl.Uniform1i(m.textureUniform, 0) gl.BindFragDataLocation(m.currentProgram, 0, gl.Str("outputColor\x00")) // Load the texture m.textures.LoadTexture(m.data.TextureFile, m.data.TextureFile) // Configure the vertex data gl.GenVertexArrays(1, &m.vao) gl.BindVertexArray(m.vao) var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) gl.BufferData(gl.ARRAY_BUFFER, len(m.data.Verts)*4, gl.Ptr(m.data.Verts), gl.STATIC_DRAW) vertAttrib := uint32(gl.GetAttribLocation(m.currentProgram, gl.Str("vert\x00"))) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, m.data.VertSize*4, gl.PtrOffset(0)) // 4:number of bytes in a float32 texCoordAttrib := uint32(gl.GetAttribLocation(m.currentProgram, gl.Str("vertTexCoord\x00"))) gl.EnableVertexAttribArray(texCoordAttrib) gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, true, m.data.VertSize*4, gl.PtrOffset(3*4)) // 4:number of bytes in a float32 if m.data.Indexed { var indices uint32 gl.GenBuffers(1, &indices) gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, indices) gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(m.data.Indices)*4, gl.Ptr(m.data.Indices), gl.STATIC_DRAW) } gl.BindVertexArray(0) }
func SetPerspective(width, height int) { Projection := mathgl.Perspective(mathgl.DegToRad(45.0), float32(width/height), 0.1, 100.0) viewM = mathgl.LookAt(0.0, 0.0, 20.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) projectionM = Projection gl.Disable(gl.CULL_FACE) gl.Enable(gl.DEPTH_TEST) }
func (e *Engine) Draw(c size.Event) { gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(0.5, 0.8, 0.8, 1) gl.Clear(gl.COLOR_BUFFER_BIT) gl.Clear(gl.DEPTH_BUFFER_BIT) gl.UseProgram(e.shader.program) gl.Uniform3fv(e.shader.lightdir, []float32{0.5, 0.6, 0.7}) m := mgl32.Perspective(1.3, float32(c.WidthPt/c.HeightPt), 0.1, 10.0) gl.UniformMatrix4fv(e.shader.projectionmatrix, m[:]) eye := mgl32.Vec3{0, 0, 0.2} center := mgl32.Vec3{0, 0, 0} up := mgl32.Vec3{0, 1, 0} m = mgl32.LookAtV(eye, center, up) gl.UniformMatrix4fv(e.shader.viewmatrix, m[:]) m = mgl32.HomogRotate3D((e.touchx/float32(c.WidthPt)-0.5)*6.28, mgl32.Vec3{0, 1, 0}) gl.UniformMatrix4fv(e.shader.modelmatrix, m[:]) m = mgl32.HomogRotate3D((e.touchx/float32(c.WidthPt)-0.5)*6.28, mgl32.Vec3{0, -1, 0}) gl.UniformMatrix4fv(e.shader.lightmatrix, m[:]) coordsPerVertex := 3 for _, obj := range e.shape.Objs { gl.BindBuffer(gl.ARRAY_BUFFER, obj.coord) gl.EnableVertexAttribArray(e.shader.vertCoord) gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 12, 0) texCoordsPerVertex := 2 gl.BindBuffer(gl.ARRAY_BUFFER, obj.uvcoord) gl.EnableVertexAttribArray(e.shader.texcoord) gl.VertexAttribPointer(e.shader.texcoord, texCoordsPerVertex, gl.FLOAT, false, 8, 0) gl.BindBuffer(gl.ARRAY_BUFFER, obj.normal) gl.EnableVertexAttribArray(e.shader.normal) gl.VertexAttribPointer(e.shader.normal, 3, gl.FLOAT, false, 12, 0) gl.BindTexture(gl.TEXTURE_2D, obj.tex) gl.DrawArrays(gl.TRIANGLES, 0, obj.vcount) gl.DisableVertexAttribArray(e.shader.texcoord) gl.DisableVertexAttribArray(e.shader.normal) gl.DisableVertexAttribArray(e.shader.vertCoord) } debug.DrawFPS(c) }
func (e *Engine) Draw(c size.Event) { gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(0.2, 0.2, 0.2, 1) gl.Clear(gl.COLOR_BUFFER_BIT) gl.Clear(gl.DEPTH_BUFFER_BIT) gl.UseProgram(e.shader.program) m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0) gl.UniformMatrix4fv(e.shader.projection, m[:]) eye := mgl32.Vec3{0, 0, 8} center := mgl32.Vec3{0, 0, 0} up := mgl32.Vec3{0, 1, 0} m = mgl32.LookAtV(eye, center, up) gl.UniformMatrix4fv(e.shader.view, m[:]) m = mgl32.HomogRotate3D(float32(e.touchLoc.X/c.WidthPt-0.5)*3.14*2, mgl32.Vec3{0, 1, 0}) gl.UniformMatrix4fv(e.shader.modelx, m[:]) m = mgl32.HomogRotate3D(float32(e.touchLoc.Y/c.HeightPt-0.5)*3.14, mgl32.Vec3{1, 0, 0}) gl.UniformMatrix4fv(e.shader.modely, m[:]) coordsPerVertex := 3 for _, obj := range e.shape.Objs { gl.BindBuffer(gl.ARRAY_BUFFER, obj.coord) gl.EnableVertexAttribArray(e.shader.vertCoord) gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 12, 0) if obj.useuv == true { gl.Uniform1i(e.shader.useuv, 1) texCoordsPerVertex := 2 gl.BindBuffer(gl.ARRAY_BUFFER, obj.uvcoord) gl.EnableVertexAttribArray(e.shader.vertTexCoord) gl.VertexAttribPointer(e.shader.vertTexCoord, texCoordsPerVertex, gl.FLOAT, false, 8, 0) gl.BindTexture(gl.TEXTURE_2D, obj.tex) } else { gl.Uniform1i(e.shader.useuv, 0) gl.Uniform4f(e.shader.color, obj.color[0], obj.color[1], obj.color[2], obj.color[3]) } gl.DrawArrays(gl.TRIANGLES, 0, obj.vcount) if obj.useuv { gl.DisableVertexAttribArray(e.shader.vertTexCoord) } gl.DisableVertexAttribArray(e.shader.vertCoord) } debug.DrawFPS(c) }
//TestLoop is a method that initiate the game func EngineLoop(window *glfw.Window) { mat := mgl32.Perspective(mgl32.DegToRad(45.0), float32(graphics.WIDTH)/graphics.HEIGHT, 0.1, 100.0).Mul4(mgl32.Translate3D(0.0, 0.0, -5.0)) shader, err := mvcShader.CreateMVCShader() if err != nil { panic(err) } mesh := cubeMesh.CreateVertexArray() newEngine := Engine{mat: mat, shader: shader.BlankShader, mesh: mesh, BaseEngine: BaseEngine{run: true, window: window}} mesh.SetPos(newEngine.shader) newEngine.loop(&newEngine) }
func (me *test) Display(c *Core) { me.o1.Draw(c) me.o2.Draw(c) projection := mgl32.Perspective(mgl32.DegToRad(Fov), float32(WindowWidth)/WindowHeight, Near, Far) view := mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0}) model := mgl32.Ident4() MVP := projection.Mul4(view).Mul4(model) gl.UniformMatrix4fv(mvpLoc, 1, false, &MVP[0]) gl.Uniform1i(TexLoc, 0) }
func (c *Camera) GetMouseVector(windowSize mgl32.Vec2, mouse mgl32.Vec2) mgl32.Vec3 { v, err := mgl32.UnProject( mgl32.Vec3{mouse.X(), windowSize.Y() - mouse.Y(), 0.5}, mgl32.LookAtV(c.Translation, c.Lookat, c.Up), mgl32.Perspective(mgl32.DegToRad(c.Angle), windowSize.X()/windowSize.Y(), c.Near, c.Far), 0, 0, int(windowSize.X()), int(windowSize.Y()), ) if err == nil { return v.Sub(c.Translation).Normalize() } else { log.Println("Error converting camera vector: ", err) } return c.Lookat }
func (e *Engine) Draw(c size.Event) { since := time.Now().Sub(e.started) //gl.Enable() gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(0, 0, 0, 1) gl.Clear(gl.COLOR_BUFFER_BIT) gl.Clear(gl.DEPTH_BUFFER_BIT) gl.UseProgram(e.shader.program) m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0) gl.UniformMatrix4fv(e.shader.projection, m[:]) eye := mgl32.Vec3{3, 3, 3} center := mgl32.Vec3{0, 0, 0} up := mgl32.Vec3{0, 1, 0} m = mgl32.LookAtV(eye, center, up) gl.UniformMatrix4fv(e.shader.view, m[:]) m = mgl32.HomogRotate3D(float32(since.Seconds()), mgl32.Vec3{0, 1, 0}) gl.UniformMatrix4fv(e.shader.model, m[:]) gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf) coordsPerVertex := 3 texCoordsPerVertex := 2 vertexCount := len(cubeData) / (coordsPerVertex + texCoordsPerVertex) gl.EnableVertexAttribArray(e.shader.vertCoord) gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 20, 0) // 4 bytes in float, 5 values per vertex gl.EnableVertexAttribArray(e.shader.vertTexCoord) gl.VertexAttribPointer(e.shader.vertTexCoord, texCoordsPerVertex, gl.FLOAT, false, 20, 12) gl.BindTexture(gl.TEXTURE_2D, e.shape.texture) gl.DrawArrays(gl.TRIANGLES, 0, vertexCount) gl.DisableVertexAttribArray(e.shader.vertCoord) debug.DrawFPS(c) }
func (e *Engine) Draw(c event.Config) { since := time.Now().Sub(e.started) gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(0, 0, 0, 1) gl.Clear(gl.COLOR_BUFFER_BIT) gl.Clear(gl.DEPTH_BUFFER_BIT) gl.UseProgram(e.shader.program) // Setup MVP var m mgl.Mat4 m = mgl.Perspective(0.785, float32(c.Width/c.Height), 0.1, 10.0) gl.UniformMatrix4fv(e.shader.projection, m[:]) m = mgl.LookAtV( mgl.Vec3{3, 3, 3}, // eye mgl.Vec3{0, 0, 0}, // center mgl.Vec3{0, 1, 0}, // up ) gl.UniformMatrix4fv(e.shader.view, m[:]) m = mgl.HomogRotate3D(float32(since.Seconds()), mgl.Vec3{0, 1, 0}) gl.UniformMatrix4fv(e.shader.model, m[:]) // Draw our shape gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf) gl.EnableVertexAttribArray(e.shader.vertCoord) gl.VertexAttribPointer(e.shader.vertCoord, e.shape.coordsPerVertex, gl.FLOAT, false, 20, 0) // 4 bytes in float, 5 values per vertex gl.EnableVertexAttribArray(e.shader.vertTexCoord) gl.VertexAttribPointer(e.shader.vertTexCoord, e.shape.texCoordsPerVertex, gl.FLOAT, false, 20, 12) gl.ActiveTexture(gl.TEXTURE0) gl.BindTexture(gl.TEXTURE_2D, e.shape.texture) gl.DrawArrays(gl.TRIANGLES, 0, e.shape.vertexCount) gl.DisableVertexAttribArray(e.shader.vertCoord) //debug.DrawFPS(c) }
func CreateCamera(x, y, z, width, height, fov, near, far float32) *Camera { cam := &Camera{ Transform: CreateTransform(x, y, z), Width: width, Height: height, Ratio: float32(width) / float32(height), Fov: fov, Near: near, Far: far, Projection: mgl.Perspective(mgl.DegToRad(fov), width/height, near, far), //Projection: mgl.Ortho(-width/2,width/2,-height/2,height/2,-100,100), } /* do an initial update at t=0 to initialize vectors */ cam.Update(0.0) return cam }
func (e *Engine) Draw(c size.Event) { gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(0, 0, 0, 1) gl.Clear(gl.COLOR_BUFFER_BIT) gl.Clear(gl.DEPTH_BUFFER_BIT) gl.UseProgram(e.shader.program) m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0) gl.UniformMatrix4fv(e.shader.projection, m[:]) eye := mgl32.Vec3{0, 3, 3} center := mgl32.Vec3{0, 0, 0} up := mgl32.Vec3{0, 1, 0} m = mgl32.LookAtV(eye, center, up) gl.UniformMatrix4fv(e.shader.view, m[:]) m = mgl32.HomogRotate3D(float32(e.touchLocX*5/c.WidthPt), mgl32.Vec3{0, 1, 0}) gl.UniformMatrix4fv(e.shader.modelx, m[:]) m = mgl32.HomogRotate3D(float32(e.touchLocY*5/c.HeightPt), mgl32.Vec3{1, 0, 0}) gl.UniformMatrix4fv(e.shader.modely, m[:]) gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf) gl.EnableVertexAttribArray(e.shader.vertCoord) gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 0, 0) gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.colorbuf) gl.EnableVertexAttribArray(e.shader.color) gl.VertexAttribPointer(e.shader.color, colorsPerVertex, gl.FLOAT, false, 0, 0) //更新color值 gl.DrawArrays(gl.TRIANGLES, 0, vertexCount) gl.DisableVertexAttribArray(e.shader.vertCoord) gl.DisableVertexAttribArray(e.shader.color) debug.DrawFPS(c) }
func (e *Engine) Draw(c size.Event) { gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(0.2, 0.2, 0.2, 1) gl.Clear(gl.COLOR_BUFFER_BIT) gl.Clear(gl.DEPTH_BUFFER_BIT) gl.UseProgram(e.shader.program) m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0) gl.UniformMatrix4fv(e.shader.projection, m[:]) eye := mgl32.Vec3{0, 0, 5} center := mgl32.Vec3{0, 0, 0} up := mgl32.Vec3{0, 1, 0} m = mgl32.LookAtV(eye, center, up) gl.UniformMatrix4fv(e.shader.view, m[:]) m = mgl32.HomogRotate3D(float32(e.touchLoc.X*10/c.WidthPt), mgl32.Vec3{0, 1, 0}) gl.UniformMatrix4fv(e.shader.modelx, m[:]) m = mgl32.HomogRotate3D(float32(e.touchLoc.Y*10/c.HeightPt), mgl32.Vec3{1, 0, 0}) gl.UniformMatrix4fv(e.shader.modely, m[:]) coordsPerVertex := 3 for _, buf := range e.shape.bufs { gl.BindBuffer(gl.ARRAY_BUFFER, buf.coord) gl.EnableVertexAttribArray(e.shader.vertCoord) gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 0, 0) gl.Uniform4f(e.shader.color, buf.color[0], buf.color[1], buf.color[2], buf.color[3]) gl.DrawArrays(gl.TRIANGLES, 0, buf.vcount) gl.DisableVertexAttribArray(e.shader.vertCoord) } debug.DrawFPS(c) }
func Loop() bool { if !llgl.EventLoop() { return false } ratio := llgl.ResizeViewport() if ratio != 0 { state.projection = mgl.Perspective(mgl.DegToRad(45.0), ratio, 0.1, 10.0) glstate.projectionUL.SetMat4(state.projection) } state.angle += 0.001 state.model = mgl.HomogRotate3D(float32(state.angle), mgl.Vec3{1, 0, 0}) glstate.modelUL.SetMat4(state.model) llgl.Clear() for i := 0; i < 1*10; i++ { llgl.DrawTriangleArray(0, int32(len(state.data)/5)) } fpsCounter.TickAndLog() llgl.SwapBuffers() return true }
func programLoop(window *win.Window) error { // the linked shader program determines how the data will be rendered vertShader, err := gfx.NewShaderFromFile("shaders/phong.vert", gl.VERTEX_SHADER) if err != nil { return err } fragShader, err := gfx.NewShaderFromFile("shaders/phong.frag", gl.FRAGMENT_SHADER) if err != nil { return err } program, err := gfx.NewProgram(vertShader, fragShader) if err != nil { return err } defer program.Delete() lightFragShader, err := gfx.NewShaderFromFile("shaders/light.frag", gl.FRAGMENT_SHADER) if err != nil { return err } // special shader program so that lights themselves are not affected by lighting lightProgram, err := gfx.NewProgram(vertShader, lightFragShader) if err != nil { return err } VAO := createVAO(cubeVertices, nil) lightVAO := createVAO(cubeVertices, nil) // ensure that triangles that are "behind" others do not draw over top of them gl.Enable(gl.DEPTH_TEST) camera := cam.NewFpsCamera(mgl32.Vec3{0, 0, 3}, mgl32.Vec3{0, 1, 0}, -90, 0, window.InputManager()) for !window.ShouldClose() { // swaps in last buffer, polls for window events, and generally sets up for a new render frame window.StartFrame() // update camera position and direction from input evevnts camera.Update(window.SinceLastFrame()) // background color gl.ClearColor(0, 0, 0, 1.0) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // depth buffer needed for DEPTH_TEST // cube rotation matrices rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-45 * float32(glfw.GetTime())))) rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-45 * float32(glfw.GetTime())))) rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-45 * float32(glfw.GetTime())))) // creates perspective fov := float32(60.0) projectTransform := mgl32.Perspective(mgl32.DegToRad(fov), float32(window.Width())/float32(window.Height()), 0.1, 100.0) camTransform := camera.GetTransform() lightPos := mgl32.Vec3{0.6, 1, 0.1} lightTransform := mgl32.Translate3D(lightPos.X(), lightPos.Y(), lightPos.Z()).Mul4( mgl32.Scale3D(0.2, 0.2, 0.2)) program.Use() gl.UniformMatrix4fv(program.GetUniformLocation("view"), 1, false, &camTransform[0]) gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false, &projectTransform[0]) gl.BindVertexArray(VAO) // draw each cube after all coordinate system transforms are bound // obj is colored, light is white gl.Uniform3f(program.GetUniformLocation("material.ambient"), 1.0, 0.5, 0.31) gl.Uniform3f(program.GetUniformLocation("material.diffuse"), 1.0, 0.5, 0.31) gl.Uniform3f(program.GetUniformLocation("material.specular"), 0.5, 0.5, 0.5) gl.Uniform1f(program.GetUniformLocation("material.shininess"), 32.0) lightColor := mgl32.Vec3{ float32(math.Sin(glfw.GetTime() * 1)), float32(math.Sin(glfw.GetTime() * 0.35)), float32(math.Sin(glfw.GetTime() * 0.65)), } diffuseColor := mgl32.Vec3{ 0.5 * lightColor[0], 0.5 * lightColor[1], 0.5 * lightColor[2], } ambientColor := mgl32.Vec3{ 0.2 * lightColor[0], 0.2 * lightColor[1], 0.2 * lightColor[2], } gl.Uniform3f(program.GetUniformLocation("light.ambient"), ambientColor[0], ambientColor[1], ambientColor[2]) gl.Uniform3f(program.GetUniformLocation("light.diffuse"), diffuseColor[0], diffuseColor[1], diffuseColor[2]) gl.Uniform3f(program.GetUniformLocation("light.specular"), 1.0, 1.0, 1.0) gl.Uniform3f(program.GetUniformLocation("light.position"), lightPos.X(), lightPos.Y(), lightPos.Z()) for _, pos := range cubePositions { // turn the cubes into rectangular prisms for more fun worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2]) worldTransform := worldTranslate.Mul4( rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4(), ) gl.UniformMatrix4fv(program.GetUniformLocation("model"), 1, false, &worldTransform[0]) gl.DrawArrays(gl.TRIANGLES, 0, 36) } gl.BindVertexArray(0) // Draw the light obj after the other boxes using its separate shader program // this means that we must re-bind any uniforms lightProgram.Use() gl.BindVertexArray(lightVAO) gl.UniformMatrix4fv(lightProgram.GetUniformLocation("model"), 1, false, &lightTransform[0]) gl.UniformMatrix4fv(lightProgram.GetUniformLocation("view"), 1, false, &camTransform[0]) gl.UniformMatrix4fv(lightProgram.GetUniformLocation("project"), 1, false, &projectTransform[0]) gl.DrawArrays(gl.TRIANGLES, 0, 36) gl.BindVertexArray(0) // end of draw loop } return nil }
// Draw draws a single frame func Draw(width, height int, delta float64) { tickAnimatedTextures(delta) frameID++ sync: for { select { case f := <-syncChan: f() default: break sync } } // Only update the viewport if the window was resized if lastHeight != height || lastWidth != width || lastFOV != FOV.Value() { lastWidth = width lastHeight = height lastFOV = FOV.Value() perspectiveMatrix = mgl32.Perspective( (math.Pi/180)*float32(lastFOV), float32(width)/float32(height), 0.1, 500.0, ) gl.Viewport(0, 0, width, height) frustum.SetPerspective( (math.Pi/180)*float32(lastFOV), float32(width)/float32(height), 0.1, 500.0, ) initTrans() } mainFramebuffer.Bind() gl.Enable(gl.Multisample) gl.ActiveTexture(0) glTexture.Bind(gl.Texture2DArray) gl.ClearColor(ClearColour.R, ClearColour.G, ClearColour.B, 1.0) gl.Clear(gl.ColorBufferBit | gl.DepthBufferBit) chunkProgram.Use() viewVector = mgl32.Vec3{ float32(math.Cos(Camera.Yaw-math.Pi/2) * -math.Cos(Camera.Pitch)), float32(-math.Sin(Camera.Pitch)), float32(-math.Sin(Camera.Yaw-math.Pi/2) * -math.Cos(Camera.Pitch)), } cam := mgl32.Vec3{-float32(Camera.X), -float32(Camera.Y), float32(Camera.Z)} cameraMatrix = mgl32.LookAtV( cam, cam.Add(mgl32.Vec3{-viewVector.X(), -viewVector.Y(), viewVector.Z()}), mgl32.Vec3{0, -1, 0}, ) cameraMatrix = cameraMatrix.Mul4(mgl32.Scale3D(-1.0, 1.0, 1.0)) frustum.SetCamera( cam, cam.Add(mgl32.Vec3{-viewVector.X(), -viewVector.Y(), viewVector.Z()}), mgl32.Vec3{0, -1, 0}, ) shaderChunk.PerspectiveMatrix.Matrix4(&perspectiveMatrix) shaderChunk.CameraMatrix.Matrix4(&cameraMatrix) shaderChunk.Texture.Int(0) shaderChunk.LightLevel.Float(LightLevel) shaderChunk.SkyOffset.Float(SkyOffset) chunkPos := position{ X: int(Camera.X) >> 4, Y: int(Camera.Y) >> 4, Z: int(Camera.Z) >> 4, } nearestBuffer = buffers[chunkPos] for _, dir := range direction.Values { validDirs[dir] = viewVector.Dot(dir.AsVec()) > -0.8 } renderOrder = renderOrder[:0] renderBuffer(nearestBuffer, chunkPos, direction.Invalid, delta) drawLines() drawModels() clouds.tick(delta) chunkProgramT.Use() shaderChunkT.PerspectiveMatrix.Matrix4(&perspectiveMatrix) shaderChunkT.CameraMatrix.Matrix4(&cameraMatrix) shaderChunkT.Texture.Int(0) shaderChunkT.LightLevel.Float(LightLevel) shaderChunkT.SkyOffset.Float(SkyOffset) // Copy the depth buffer mainFramebuffer.BindRead() transFramebuffer.BindDraw() gl.BlitFramebuffer( 0, 0, lastWidth, lastHeight, 0, 0, lastWidth, lastHeight, gl.DepthBufferBit, gl.Nearest, ) gl.Enable(gl.Blend) gl.DepthMask(false) transFramebuffer.Bind() gl.ClearColor(0, 0, 0, 1) gl.Clear(gl.ColorBufferBit) gl.ClearBuffer(gl.Color, 0, []float32{0, 0, 0, 1}) gl.ClearBuffer(gl.Color, 1, []float32{0, 0, 0, 0}) gl.BlendFuncSeparate(gl.OneFactor, gl.OneFactor, gl.ZeroFactor, gl.OneMinusSrcAlpha) for _, chunk := range renderOrder { if chunk.countT > 0 && chunk.bufferT.IsValid() { shaderChunkT.Offset.Int3(chunk.X, chunk.Y*4096-chunk.Y*int(4096*(1-chunk.progress)), chunk.Z) chunk.arrayT.Bind() gl.DrawElements(gl.Triangles, chunk.countT, elementBufferType, 0) } } gl.UnbindFramebuffer() gl.Disable(gl.DepthTest) gl.Clear(gl.ColorBufferBit) gl.Disable(gl.Blend) transDraw() gl.Enable(gl.DepthTest) gl.DepthMask(true) gl.BlendFunc(gl.SrcAlpha, gl.OneMinusSrcAlpha) gl.Disable(gl.Multisample) drawUI() if debugFramebuffers.Value() { gl.Enable(gl.Multisample) blitBuffers() gl.Disable(gl.Multisample) } }
func programLoop(window *win.Window) error { // the linked shader program determines how the data will be rendered vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER) if err != nil { return err } fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER) if err != nil { return err } program, err := gfx.NewProgram(vertShader, fragShader) if err != nil { return err } defer program.Delete() VAO := createVAO(cubeVertices, nil) texture0, err := gfx.NewTextureFromFile("../images/RTS_Crate.png", gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE) if err != nil { panic(err.Error()) } texture1, err := gfx.NewTextureFromFile("../images/trollface-transparent.png", gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE) if err != nil { panic(err.Error()) } // ensure that triangles that are "behind" others do not draw over top of them gl.Enable(gl.DEPTH_TEST) camera := cam.NewFpsCamera(mgl32.Vec3{0, 0, 3}, mgl32.Vec3{0, 1, 0}, -90, 0, window.InputManager()) for !window.ShouldClose() { // swaps in last buffer, polls for window events, and generally sets up for a new render frame window.StartFrame() // update camera position and direction from input evevnts camera.Update(window.SinceLastFrame()) // background color gl.ClearColor(0.2, 0.5, 0.5, 1.0) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // depth buffer needed for DEPTH_TEST program.Use() // bind textures texture0.Bind(gl.TEXTURE0) texture0.SetUniform(program.GetUniformLocation("ourTexture0")) texture1.Bind(gl.TEXTURE1) texture1.SetUniform(program.GetUniformLocation("ourTexture1")) // cube rotation matrices rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-60 * float32(glfw.GetTime())))) rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-60 * float32(glfw.GetTime())))) rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-60 * float32(glfw.GetTime())))) // creates perspective fov := float32(60.0) projectTransform := mgl32.Perspective(mgl32.DegToRad(fov), float32(window.Width())/float32(window.Height()), 0.1, 100.0) camTransform := camera.GetTransform() gl.UniformMatrix4fv(program.GetUniformLocation("camera"), 1, false, &camTransform[0]) gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false, &projectTransform[0]) gl.BindVertexArray(VAO) // draw each cube after all coordinate system transforms are bound for _, pos := range cubePositions { worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2]) worldTransform := (worldTranslate.Mul4(rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4())) gl.UniformMatrix4fv(program.GetUniformLocation("world"), 1, false, &worldTransform[0]) gl.DrawArrays(gl.TRIANGLES, 0, 36) } gl.BindVertexArray(0) texture0.UnBind() texture1.UnBind() // end of draw loop } return nil }
// Since go has multiple return values, I just went ahead and made it return the view and perspective matrices (in that order) rather than messing with getter methods func (c *Camera) ComputeViewPerspective() (mgl32.Mat4, mgl32.Mat4) { if mgl64.FloatEqual(-1.0, c.time) { c.time = glfw.GetTime() } currTime := glfw.GetTime() deltaT := currTime - c.time xPos, yPos := c.window.GetCursorPosition() c.window.SetCursorPosition(width/2.0, height/2.0) c.hAngle += mouseSpeed * ((width / 2.0) - float64(xPos)) c.vAngle += mouseSpeed * ((height / 2.0) - float64(yPos)) dir := mgl32.Vec3{ float32(math.Cos(c.vAngle) * math.Sin(c.hAngle)), float32(math.Sin(c.vAngle)), float32(math.Cos(c.vAngle) * math.Cos(c.hAngle))} right := mgl32.Vec3{ float32(math.Sin(c.hAngle - math.Pi/2.0)), 0.0, float32(math.Cos(c.hAngle - math.Pi/2.0))} up := right.Cross(dir) if c.window.GetKey(glfw.KeyUp) == glfw.Press || c.window.GetKey('W') == glfw.Press { c.pos = c.pos.Add(dir.Mul(float32(deltaT * speed))) } if c.window.GetKey(glfw.KeyDown) == glfw.Press || c.window.GetKey('S') == glfw.Press { c.pos = c.pos.Sub(dir.Mul(float32(deltaT * speed))) } if c.window.GetKey(glfw.KeyRight) == glfw.Press || c.window.GetKey('D') == glfw.Press { c.pos = c.pos.Add(right.Mul(float32(deltaT * speed))) } if c.window.GetKey(glfw.KeyLeft) == glfw.Press || c.window.GetKey('A') == glfw.Press { c.pos = c.pos.Sub(right.Mul(float32(deltaT * speed))) } // Adding to the original tutorial, Space goes up if c.window.GetKey(glfw.KeySpace) == glfw.Press { c.pos = c.pos.Add(up.Mul(float32(deltaT * speed))) } // Adding to the original tutorial, left control goes down if c.window.GetKey(glfw.KeyLeftControl) == glfw.Press { c.pos = c.pos.Sub(up.Mul(float32(deltaT * speed))) } fov := initialFOV //- 5.0*float64(glfw.MouseWheel()) proj := mgl32.Perspective(float32(fov), 4.0/3.0, 0.1, 100.0) view := mgl32.LookAtV(c.pos, c.pos.Add(dir), up) c.time = currTime return view, proj }
func main() { runtime.LockOSThread() if !glfw.Init() { fmt.Fprintf(os.Stderr, "Can't open GLFW") return } defer glfw.Terminate() glfw.WindowHint(glfw.Samples, 4) glfw.WindowHint(glfw.ContextVersionMajor, 3) glfw.WindowHint(glfw.ContextVersionMinor, 3) glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile) glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs window, err := glfw.CreateWindow(1024, 768, "Tutorial 3", nil, nil) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) return } window.MakeContextCurrent() gl.Init() gl.GetError() // Ignore error window.SetInputMode(glfw.StickyKeys, 1) gl.ClearColor(0., 0., 0.4, 0.) vertexArray := gl.GenVertexArray() defer vertexArray.Delete() vertexArray.Bind() prog := helper.MakeProgram("SimpleTransform.vertexshader", "SingleColor.fragmentshader") defer prog.Delete() matrixID := prog.GetUniformLocation("MVP") Projection := mgl32.Perspective(45.0, 4.0/3.0, 0.1, 100.0) //Projection := mathgl.Identity(4,mathgl.FLOAT64) //Projection := mathgl.Ortho2D(-5,5,-5,5) View := mgl32.LookAt(4.0, 3.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) //View := mathgl.Identity(4,mathgl.FLOAT64) Model := mgl32.Ident4() //Model := mathgl.Scale3D(2.,2.,2.).Mul(mathgl.HomogRotate3DX(25.0)).Mul(mathgl.Translate3D(.5,.2,-.7)) MVP := Projection.Mul4(View).Mul4(Model) // Remember, transform multiplication order is "backwards" vBufferData := [...]float32{ -1., -1., 0., 1., -1., 0., 0., 1., 0.} //elBufferData := [...]uint8{0, 1, 2} // Not sure why this is here buffer := gl.GenBuffer() defer buffer.Delete() buffer.Bind(gl.ARRAY_BUFFER) gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData, gl.STATIC_DRAW) // Equivalent to a do... while for ok := true; ok; ok = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) { gl.Clear(gl.COLOR_BUFFER_BIT) prog.Use() matrixID.UniformMatrix4fv(false, MVP) attribLoc := gl.AttribLocation(0) attribLoc.EnableArray() buffer.Bind(gl.ARRAY_BUFFER) attribLoc.AttribPointer(3, gl.FLOAT, false, 0, nil) gl.DrawArrays(gl.TRIANGLES, 0, 3) attribLoc.DisableArray() window.SwapBuffers() glfw.PollEvents() } }
func programLoop(window *glfw.Window) error { // the linked shader program determines how the data will be rendered vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER) if err != nil { return err } fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER) if err != nil { return err } program, err := gfx.NewProgram(vertShader, fragShader) if err != nil { return err } defer program.Delete() vertices := []float32{ // position // texture position -0.5, -0.5, -0.5, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 1.0, -0.5, 0.5, 0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, -0.5, 1.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, 0.5, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, } indices := []uint32{} VAO := createVAO(vertices, indices) texture0, err := gfx.NewTextureFromFile("../images/RTS_Crate.png", gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE) if err != nil { panic(err.Error()) } texture1, err := gfx.NewTextureFromFile("../images/trollface-transparent.png", gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE) if err != nil { panic(err.Error()) } cubePositions := [][]float32{ []float32{0.0, 0.0, -3.0}, []float32{2.0, 5.0, -15.0}, []float32{-1.5, -2.2, -2.5}, []float32{-3.8, -2.0, -12.3}, []float32{2.4, -0.4, -3.5}, []float32{-1.7, 3.0, -7.5}, []float32{1.3, -2.0, -2.5}, []float32{1.5, 2.0, -2.5}, []float32{1.5, 0.2, -1.5}, []float32{-1.3, 1.0, -1.5}, } gl.Enable(gl.DEPTH_TEST) for !window.ShouldClose() { // poll events and call their registered callbacks glfw.PollEvents() // background color gl.ClearColor(0.2, 0.5, 0.5, 1.0) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // draw vertices program.Use() // set texture0 to uniform0 in the fragment shader texture0.Bind(gl.TEXTURE0) texture0.SetUniform(program.GetUniformLocation("ourTexture0")) // set texture1 to uniform1 in the fragment shader texture1.Bind(gl.TEXTURE1) texture1.SetUniform(program.GetUniformLocation("ourTexture1")) // update shader transform matrices // Create transformation matrices rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-60 * float32(glfw.GetTime())))) rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-60 * float32(glfw.GetTime())))) rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-60 * float32(glfw.GetTime())))) viewTransform := mgl32.Translate3D(0, 0, -3) projectTransform := mgl32.Perspective(mgl32.DegToRad(60), windowWidth/windowHeight, 0.1, 100.0) gl.UniformMatrix4fv(program.GetUniformLocation("view"), 1, false, &viewTransform[0]) gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false, &projectTransform[0]) gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateX"), 1, false, &rotateX[0]) gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateY"), 1, false, &rotateY[0]) gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateZ"), 1, false, &rotateZ[0]) gl.BindVertexArray(VAO) for _, pos := range cubePositions { worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2]) worldTransform := (worldTranslate.Mul4(rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4())) gl.UniformMatrix4fv(program.GetUniformLocation("world"), 1, false, &worldTransform[0]) gl.DrawArrays(gl.TRIANGLES, 0, 36) } // gl.DrawElements(gl.TRIANGLES, 36, gl.UNSIGNED_INT, unsafe.Pointer(nil)) gl.BindVertexArray(0) texture0.UnBind() texture1.UnBind() // end of draw loop // swap in the rendered buffer window.SwapBuffers() } return nil }
func Main() { err := glfw.Init() if err != nil { panic(err) } defer glfw.Terminate() glfw.WindowHint(glfw.Resizable, glfw.False) glfw.WindowHint(glfw.ContextVersionMajor, 3) glfw.WindowHint(glfw.ContextVersionMinor, 2) glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True) window, err := glfw.CreateWindow(WindowWidth, WindowHeight, "Cube", nil, nil) Window = window if err != nil { panic(err) } window.MakeContextCurrent() // Initialize Glow if err := gl.Init(); err != nil { panic(err) } version := gl.GoStr(gl.GetString(gl.VERSION)) fmt.Println("OpenGL version", version) // Configure the vertex and fragment shaders program, err := newProgram("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader") if err != nil { panic(err) } gl.UseProgram(program) projection := mgl32.Perspective(mgl32.DegToRad(45.0), float32(WindowWidth)/WindowHeight, 0.1, 10.0) projectionUniform := gl.GetUniformLocation(program, gl.Str("projection\x00")) gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0]) camera := mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0}) cameraUniform := gl.GetUniformLocation(program, gl.Str("camera\x00")) gl.UniformMatrix4fv(cameraUniform, 1, false, &camera[0]) model := mgl32.Ident4() modelUniform := gl.GetUniformLocation(program, gl.Str("model\x00")) gl.UniformMatrix4fv(modelUniform, 1, false, &model[0]) textureUniform := gl.GetUniformLocation(program, gl.Str("tex\x00")) gl.Uniform1i(textureUniform, 0) gl.BindFragDataLocation(program, 0, gl.Str("outputColor\x00")) // Configure global settings gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(1.0, 1.0, 1.0, 1.0) angle := 0.0 previousTime := glfw.GetTime() width, height := window.GetSize() window.SetCursorPos(float64(width/2), float64(height/2)) window.SetKeyCallback(input.OnKey) window.SetCursorPosCallback(input.OnCursor) window.SetMouseButtonCallback(input.OnMouse) meshes.LoadColladaCube("cube.dae") for !player.ShouldClose { gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // Update time := glfw.GetTime() elapsed := time - previousTime previousTime = time angle += elapsed model = mgl32.HomogRotate3D(float32(angle), mgl32.Vec3{0, 1, 0}) // Render gl.UseProgram(program) // gl.UniformMatrix4fv(modelUniform, 1, false, &model[0]) player.MainPlayer.Draw(program) for _, element := range game.Universe { (element).Draw(program) } // Maintenance window.SwapBuffers() glfw.PollEvents() } }
func main() { vertices, normals := obj.Parse(os.Args[1]) // initialize GLFW if err := glfw.Init(); err != nil { panic(err) } defer glfw.Terminate() // set opengl core profile 3.3 glfw.WindowHint(glfw.ContextVersionMajor, 3) glfw.WindowHint(glfw.ContextVersionMinor, 3) glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True) window, err := glfw.CreateWindow(640, 480, "GOpenGL", nil, nil) if err != nil { panic(err) } window.MakeContextCurrent() // initialise OpenGL library if err := gl.Init(); err != nil { panic(err) } // link program from shaders program, err := newProgram("vertex.glsl", "fragment.glsl") if err != nil { panic(err) } gl.UseProgram(program) // vertex attribute object holds links between attributes and vbo var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) // vertex buffer with per-vertex data var vbo [2]uint32 gl.GenBuffers(2, &vbo[0]) // position data gl.BindBuffer(gl.ARRAY_BUFFER, vbo[0]) gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) // set up position attribute with layout of vertices posAttrib := uint32(gl.GetAttribLocation(program, gl.Str("position\x00"))) gl.VertexAttribPointer(posAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0)) gl.EnableVertexAttribArray(posAttrib) // normal data gl.BindBuffer(gl.ARRAY_BUFFER, vbo[1]) gl.BufferData(gl.ARRAY_BUFFER, len(normals)*4, gl.Ptr(normals), gl.STATIC_DRAW) normAttrib := uint32(gl.GetAttribLocation(program, gl.Str("normal\x00"))) gl.VertexAttribPointer(normAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0)) gl.EnableVertexAttribArray(normAttrib) uniModel := gl.GetUniformLocation(program, gl.Str("model\x00")) uniView := gl.GetUniformLocation(program, gl.Str("view\x00")) uniProj := gl.GetUniformLocation(program, gl.Str("proj\x00")) matView := mgl32.LookAt(2.0, 2.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0) gl.UniformMatrix4fv(uniView, 1, false, &matView[0]) matProj := mgl32.Perspective(mgl32.DegToRad(45.0), 640.0/480.0, 1.0, 10.0) gl.UniformMatrix4fv(uniProj, 1, false, &matProj[0]) uniLightDir := gl.GetUniformLocation(program, gl.Str("lightDir\x00")) uniLightCol := gl.GetUniformLocation(program, gl.Str("lightCol\x00")) gl.Uniform3f(uniLightDir, -0.5, 0.0, -1.0) gl.Uniform3f(uniLightCol, 0.0, 0.5, 0.5) startTime := glfw.GetTime() gl.Enable(gl.DEPTH_TEST) gl.ClearColor(1.0, 1.0, 1.0, 1.0) for !window.ShouldClose() { // clear buffer gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) matRot := mgl32.HomogRotate3DZ(float32(glfw.GetTime() - startTime)) gl.UniformMatrix4fv(uniModel, 1, false, &matRot[0]) gl.DrawArrays(gl.TRIANGLES, 0, int32(len(vertices))) window.SwapBuffers() glfw.PollEvents() } }
//SetPerspective sets the projection to perspective. func (c *Camera) SetPerspective(angle, ratio, zNear, zFar float32) { c.Projection = glm.Perspective(angle, ratio, zNear, zFar) }
// Perspective computes the projection matrix and saves it func (c *EulerCamera) SetPerspective(fovy, aspect, near, far float32) { c.projection = mgl.Perspective(fovy, aspect, near, far) }
func main() { if err := glfw.Init(); err != nil { log.Fatalln("failed to initialize glfw:", err) } defer glfw.Terminate() glfw.WindowHint(glfw.Resizable, glfw.False) glfw.WindowHint(glfw.ContextVersionMajor, 4) glfw.WindowHint(glfw.ContextVersionMinor, 1) glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True) window, err := glfw.CreateWindow(windowWidth, windowHeight, "Cube", nil, nil) if err != nil { panic(err) } window.MakeContextCurrent() // Initialize Glow if err := gl.Init(); err != nil { panic(err) } version := gl.GoStr(gl.GetString(gl.VERSION)) fmt.Println("OpenGL version", version) // Configure the vertex and fragment shaders program, err := newProgram(vertexShader, fragmentShader) if err != nil { panic(err) } gl.UseProgram(program) projection := mgl32.Perspective(mgl32.DegToRad(45.0), float32(windowWidth)/windowHeight, 0.1, 10.0) projectionUniform := gl.GetUniformLocation(program, gl.Str("projection\x00")) gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0]) camera := mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0}) cameraUniform := gl.GetUniformLocation(program, gl.Str("camera\x00")) gl.UniformMatrix4fv(cameraUniform, 1, false, &camera[0]) model := mgl32.Ident4() modelUniform := gl.GetUniformLocation(program, gl.Str("model\x00")) gl.UniformMatrix4fv(modelUniform, 1, false, &model[0]) textureUniform := gl.GetUniformLocation(program, gl.Str("tex\x00")) gl.Uniform1i(textureUniform, 0) gl.BindFragDataLocation(program, 0, gl.Str("outputColor\x00")) // Load the texture texture, err := newTexture("square.png") if err != nil { panic(err) } // Configure the vertex data var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) gl.BufferData(gl.ARRAY_BUFFER, len(cubeVertices)*4, gl.Ptr(cubeVertices), gl.STATIC_DRAW) vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00"))) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0)) texCoordAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertTexCoord\x00"))) gl.EnableVertexAttribArray(texCoordAttrib) gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4)) // Configure global settings gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(1.0, 1.0, 1.0, 1.0) angle := 0.0 previousTime := glfw.GetTime() for !window.ShouldClose() { gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // Update time := glfw.GetTime() elapsed := time - previousTime previousTime = time angle += elapsed model = mgl32.HomogRotate3D(float32(angle), mgl32.Vec3{0, 1, 0}) // Render gl.UseProgram(program) gl.UniformMatrix4fv(modelUniform, 1, false, &model[0]) gl.BindVertexArray(vao) gl.ActiveTexture(gl.TEXTURE0) gl.BindTexture(gl.TEXTURE_2D, texture) gl.DrawArrays(gl.TRIANGLES, 0, 6*2*3) // Maintenance window.SwapBuffers() glfw.PollEvents() } }
// SetPerspective set a perspective projection func (cam *Camera) SetPerspective(angle float32, w int, h int, zDepth int) { cam.Bounds = mgl32.Vec3{float32(w), float32(h), float32(zDepth)} cam.projection = mgl32.Perspective(mgl32.DegToRad(angle), float32(w)/float32(h), 0.1, 10.0) cam.update() }