func TestStackPushPopPeek(t *testing.T) { stack := NewTransformStack() if !stack.Peek().ApproxEqual(mgl32.Ident4()) { t.Errorf("Peek not working") } stack.Push(mgl32.HomogRotate3DY(mgl32.DegToRad(90))) if !stack.Peek().ApproxEqual(mgl32.HomogRotate3DY(mgl32.DegToRad(90))) { t.Errorf("Peek not working") } if stack.Len() != 2 { t.Errorf("Peek alters stack length") } pop, err := stack.Pop() if err != nil || !pop.ApproxEqual(mgl32.HomogRotate3DY(mgl32.DegToRad(90))) { t.Errorf("Pop is unsuccessful") } if stack.Len() != 1 { t.Errorf("Pop does not actually shorten stack") } _, err = stack.Pop() if err == nil { t.Errorf("Popping stack with 1 element does not return error as expected") } }
// GetCone returns the Source's directional volume cones by inner angle, outer angle, // and outer volume. func (s *Source) GetCone() (float32, float32, float32) { if s.isValid() { c := s.source.Cone() return mgl32.DegToRad(float32(c.InnerAngle)), mgl32.DegToRad(float32(c.OuterAngle)), c.OuterVolume } return mgl32.DegToRad(float32(s.cone.InnerAngle)), mgl32.DegToRad(float32(s.cone.OuterAngle)), s.cone.OuterVolume }
func ExampleRebase() { parent1 := NewTransformStack() scale := mgl32.Scale3D(2, 2, 2) rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90)) trans := mgl32.Translate3D(5, 5, 5) parent1.Push(trans) parent1.Push(rot) parent1.Push(scale) parent2 := parent1.Copy() trans2 := mgl32.Translate3D(1, 1, 1) rot2 := mgl32.HomogRotate3DX(mgl32.DegToRad(45)) parent1.Push(trans2) parent1.Push(rot2) // Replay the pushes the changes from parent1 after the copy onto parent2, as if // they had been done on parent2 instead parent2, err := Rebase(parent1, 4, parent2) if err != nil { panic(err) } // Now parent2 and parent 1 should be the same! fmt.Println(parent2.Peek().ApproxEqualThreshold(parent1.Peek(), 1e-4)) // Output: true }
//NewTransform defines a new Rotation and Translation //x, y, z are the angle in degrees rotation around the repsective axis //addition is true when this will be applied in addition to an existing orientation //localref is true if the orientation should be applied in the object local reference //or in the absolute reference. If addition is false this has no effect //xt, yt, zt are the translation offset to apply in the x, y, and z axis //transabs is true when this translation will be applied in relation to the current //translation ZXY YZX XYZ func NewTransform(x, y, z float32, rot RotationType, xt, yt, zt float32, tran TranslationType) *Transform { return &Transform{ quat: mgl32.AnglesToQuat(mgl32.DegToRad(z), mgl32.DegToRad(y), mgl32.DegToRad(x), mgl32.ZYX), rType: rot, trans: mgl32.Vec3{xt, yt, zt}, tType: tran, } }
func (c SpritesheetFrameConfig) ToSpritesheetFrame() *SpritesheetFrame { var ( texX = c.textureX / c.textureOriginalW texY = c.textureY / c.textureOriginalH texW = c.textureW / c.textureOriginalW texH = c.textureH / c.textureOriginalH ) var ( texMove = mgl32.Translate3D(texX, -texH-texY, 0.0) texScale = mgl32.Scale3D(texW, texH, 1.0) texRotate = mgl32.HomogRotate3DZ(mgl32.DegToRad(0)) texAdj = texMove.Mul4(texScale).Mul4(texRotate).Transpose() ) var ( ptScale = mgl32.Scale3D(c.sourceW/c.pxPerUnit, c.sourceH/c.pxPerUnit, 1.0) ptAdj = ptScale.Transpose() ) return &SpritesheetFrame{ Frame: FrameConfig{ PointAdjustment: ptAdj, TextureAdjustment: texAdj, }, Width: c.sourceW / c.pxPerUnit, Height: c.sourceH / c.pxPerUnit, } }
func TestStackMultiPush(t *testing.T) { stack := NewTransformStack() scale := mgl32.Scale3D(2, 2, 2) rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90)) trans := mgl32.Translate3D(4, 5, 6) stack.Push(trans) stack.Push(rot) if !stack.Peek().ApproxEqualThreshold(trans.Mul4(rot), 1e-4) { t.Errorf("Stack does not multiply first two pushes correctly") } stack.Push(scale) if !stack.Peek().ApproxEqualThreshold(trans.Mul4(rot).Mul4(scale), 1e-4) { t.Errorf("Stack does not multiple third push correctly") } stack.Unwind(2) stack.Push(scale) if !stack.Peek().ApproxEqualThreshold(trans.Mul4(scale), 1e-4) { t.Errorf("Unwinding and multiplying does not work correctly") } }
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 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) }
func makePerspective(fov, aspect, near, far float32) mgl32.Mat4 { ymax := near * float32(math.Tan(float64(mgl32.DegToRad(fov*0.5)))) ymin := -ymax xmin := ymin * aspect xmax := ymax * aspect return mgl32.Frustum(xmin, xmax, ymin, ymax, near, far) }
// 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) }
//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 (i *Instance) GetModel() mgl32.Mat4 { if i.dirty { var model mgl32.Mat4 model = mgl32.Translate3D( i.position.X(), i.position.Y(), i.position.Z(), ) model = model.Mul4(mgl32.HomogRotate3DZ(mgl32.DegToRad(i.rotation))) model = model.Mul4(mgl32.Scale3D(i.scale.X(), i.scale.Y(), i.scale.Z())) i.model = model i.dirty = false } return i.model }
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 }
// createRenderer creates a new graphics Renderer engine and does // any initializiation necessary. // // NOTE: in the future, this can create either a forward or deferred // renderer with more advanced options. func createRenderer(mainWindow *glfw.Window) (*GameRenderer, error) { gr := new(GameRenderer) gr.Shaders = make(map[string]*fizzle.RenderShader) // create the renderer itself windowW, windowH := mainWindow.GetFramebufferSize() forwardRenderer := fizzle.NewForwardRenderer(mainWindow) forwardRenderer.Init(int32(windowW), int32(windowH)) gr.Renderer = forwardRenderer gr.MainWindow = mainWindow // load the landscape diffuse shader shader, err := fizzle.LoadShaderProgramFromFiles(landscapeShaderPath, nil) if err != nil { return nil, fmt.Errorf("Failed to compile and link the diffuse shader program!\n%v", err) } gr.Shaders["landscape"] = shader // load the diffuse shader shader, err = fizzle.LoadShaderProgramFromFiles(diffuseShaderPath, nil) if err != nil { return nil, fmt.Errorf("Failed to compile and link the diffuse shader program!\n%v", err) } gr.Shaders["diffuse"] = shader // put a test light in the renderer light := fizzle.NewLight() //light.Position = mgl.Vec3{8.0, 8.0, 8.0} light.DiffuseColor = mgl.Vec4{1.0, 1.0, 1.0, 1.0} light.Direction = mgl.Vec3{0.1, -1.0, -0.1} light.DiffuseIntensity = 0.6 light.AmbientIntensity = 0.4 //light.Attenuation = 1.0 forwardRenderer.ActiveLights[0] = light // setup the camera to look at the cube gr.camera = fizzle.NewOrbitCamera(mgl.Vec3{0.0, 0.0, 0.0}, mgl.DegToRad(35.0), 16.0, mgl.DegToRad(90.0)) // set some OpenGL flags gl.Enable(gl.CULL_FACE) gl.Enable(gl.DEPTH_TEST) return gr, nil }
func TestReseed(t *testing.T) { stack := NewTransformStack() scale := mgl32.Scale3D(2, 2, 2) rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90)) trans := mgl32.Translate3D(4, 5, 6) stack.Push(trans) stack.Push(rot) stack.Push(scale) trans2 := mgl32.Translate3D(1, 2, 3) err := stack.Reseed(1, trans2) if err != nil { t.Fatalf("Rebase returned error when it should not %v", err) } if !stack.Peek().ApproxEqualThreshold(trans2.Mul4(rot).Mul4(scale), 1e-4) { t.Fatalf("Rebase does not remultiply correctly. Got\n %v expected\n %v. (Previous state:\n %v)", stack.Peek(), trans2.Mul4(rot).Mul4(scale), trans.Mul4(rot).Mul4(scale)) } }
func TestRebase(t *testing.T) { stack := NewTransformStack() stack2 := NewTransformStack() scale := mgl32.Scale3D(2, 2, 2) rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90)) trans := mgl32.Translate3D(4, 5, 6) trans2 := mgl32.Translate3D(1, 2, 3) stack.Push(trans) stack.Push(rot) stack2.Push(trans2) stack2.Push(scale) out, _ := Rebase(stack2, 1, stack) if !out.Peek().ApproxEqualThreshold(trans.Mul4(rot).Mul4(trans2).Mul4(scale), 1e-4) { t.Log("\n", out) t.Errorf("Rebase unsuccessful. Got\n %v, expected\n %v", out.Peek(), trans.Mul4(rot).Mul4(trans2).Mul4(scale)) } }
func ExampleReseed() { stack := NewTransformStack() scale := mgl32.Scale3D(2, 2, 2) rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90)) trans := mgl32.Translate3D(4, 5, 6) stack.Push(trans) stack.Push(rot) stack.Push(scale) fmt.Println("Initial state:\n", stack.Peek()) trans2 := mgl32.Translate3D(1, 2, 3) err := stack.Reseed(1, trans2) if err == nil { panic("Rebase failed") } fmt.Println("After rebase:\n", stack.Peek()) fmt.Println("Should be:\n", trans2.Mul4(rot).Mul4(scale)) }
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 *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 (s *Sprite) transform() mgl.Mat4 { S := mgl.Scale2D(s.scale, s.scale).Mat4() R := mgl.Rotate2D(mgl.DegToRad(s.rotation)).Mat4() T := mgl.Translate3D(s.x, s.y, 0) return T.Mul4(R).Mul4(S) }
func (gl *GameLayer) Render() { var ( count = int(gl.state.ObjectCount) tiles []twodee.SpriteConfig = make([]twodee.SpriteConfig, count) player []twodee.SpriteConfig = make([]twodee.SpriteConfig, 1) rando []twodee.SpriteConfig frame *twodee.SpritesheetFrame frame1 *twodee.SpritesheetFrame = gl.sheet.GetFrame("numbered_squares_tall_07") frame2 *twodee.SpritesheetFrame = gl.sheet.GetFrame("numbered_squares_wide_14") coord float32 playerPt = gl.player.Pos() ) gl.batch.Bind() if err := gl.batch.Draw(gl.level, 0, 0, 0); err != nil { panic(err) } gl.batch.Unbind() gl.sheetTexture.Bind() for i := 0; i < count; i++ { frame = gl.sheet.GetFrame(fmt.Sprintf("numbered_squares_%02d", (i%16)+1)) coord = float32(i-(count/2)) / (float32(count) / 20.0) tiles[i] = twodee.SpriteConfig{ View: twodee.ModelViewConfig{ coord, coord, 0, mgl32.DegToRad(float32(i * 15)), 0.0, 0.0, 1.0, 1.0, 1.0, }, Frame: frame.Frame, } } frame = gl.sheet.GetFrame(fmt.Sprintf("numbered_squares_%02d", gl.player.Frame()+1)) player[0] = twodee.SpriteConfig{ View: twodee.ModelViewConfig{ playerPt.X, playerPt.Y, 0, 0, 0, 0, 1.0, 1.0, 1.0, }, Frame: frame.Frame, } gl.glow.Bind() gl.sprite.Draw(player) gl.glow.Unbind() rando = []twodee.SpriteConfig{ twodee.SpriteConfig{ View: twodee.ModelViewConfig{ playerPt.X - 1.0, playerPt.Y - 2.0, 0, 0, 0, 0, 1.0, 1.0, 1.0, }, Frame: frame1.Frame, }, twodee.SpriteConfig{ View: twodee.ModelViewConfig{ 0, 0, 0, 0, 0, 0, 1.0, 1.0, 1.0, }, Frame: frame2.Frame, }, } gl.sprite.Draw(tiles) gl.sprite.Draw(rando) gl.sprite.Draw(player) gl.glow.Draw() gl.sheetTexture.Unbind() if len(gl.lineSegments) > 1 { line := twodee.NewLineGeometry(gl.lineSegments, false) style := &twodee.LineStyle{ Thickness: 0.2, Color: color.RGBA{0, 0, 255, 128}, Inner: 0.0, } modelview := mgl32.Ident4() gl.lines.Bind() gl.lines.Draw(line, modelview, style) gl.lines.Unbind() } }
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() } }
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 }
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() } }
// 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() }
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 }
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() } }