func (s *MainState) Resize(width, height int) { aspect := float32(width) / float32(height) if width > height { s.projection = mgl32.Ortho2D(-aspect, aspect, -1, 1) } else { s.projection = mgl32.Ortho2D(-1, 1, -1/aspect, 1/aspect) } gl.Viewport(0, 0, int32(width), int32(height)) }
func (s *MainState) Resize(width int, height int) { println("resize!", width, height) aspect := float32(width) / float32(height) if width > height { projection = mgl32.Ortho2D(-aspect, aspect, -1, 1) } else { projection = mgl32.Ortho2D(-1, 1, -1/aspect, 1/aspect) } gl.Viewport(0, 0, int32(width), int32(height)) return }
// NewBasicRenderContext returns a render context for the provided parameters. func NewBasicRenderContext(width, height int, viewMatrix mgl32.Mat4) *RenderContext { return &RenderContext{ viewportWidth: width, viewportHeight: height, viewMatrix: viewMatrix, projectionMatrix: mgl32.Ortho2D(0, float32(width), float32(height), 0)} }
func (glr *GlRenderer) initScreen() { var err error glr.program, err = createScreenShader() if err != nil { panic(err) } gl.UseProgram(glr.program) projection := mgl32.Ortho2D(-1, 1, 1, -1) projectionUniform := gl.GetUniformLocation(glr.program, gl.Str("projection\x00")) gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0]) textureUniform := gl.GetUniformLocation(glr.program, gl.Str("tex\x00")) gl.Uniform1i(textureUniform, 0) glr.texture = createScreenTexture(glr.width, glr.height) gl.GenVertexArrays(1, &glr.vao) gl.BindVertexArray(glr.vao) var quadVertices = []float32{ // X, Y, Z, U, V 1.0, -1.0, 0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, -1.0, -1.0, 0.0, 0.0, 0.0, -1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, } var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) gl.BufferData(gl.ARRAY_BUFFER, len(quadVertices)*4, gl.Ptr(quadVertices), gl.STATIC_DRAW) vertAttrib := uint32(gl.GetAttribLocation(glr.program, gl.Str("vert\x00"))) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0)) texCoordAttrib := uint32(gl.GetAttribLocation(glr.program, gl.Str("vertTexCoord\x00"))) gl.EnableVertexAttribArray(texCoordAttrib) gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4)) gl.Enable(gl.DEPTH_TEST) gl.ClearColor(1.0, 1.0, 1.0, 1.0) }
func CreateContext(width, height int) Context { vertexShader := ` #version 330 uniform mat4 projection; uniform mat4 camera; uniform mat4 model; in vec3 vert; void main() { gl_Position = projection * camera * model * vec4(vert, 1); } ` + "\x00" fragmentShader := ` #version 330 uniform vec4 color; out vec4 outputColor; void main() { outputColor = color; } ` + "\x00" vertices := []float32{ 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, } 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, 3) glfw.WindowHint(glfw.ContextVersionMinor, 3) glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True) window, err := glfw.CreateWindow(width, height, "OpenGL", nil, nil) if err != nil { panic(err) } window.MakeContextCurrent() if err := gl.Init(); err != nil { panic(err) } program, err := newProgram(vertexShader, fragmentShader) if err != nil { panic(err) } gl.UseProgram(program) projection := mgl32.Ortho2D(0, 800, 0, 600) projectionUniform := gl.GetUniformLocation(program, gl.Str("projection\x00")) gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0]) camera := mgl32.LookAtV(mgl32.Vec3{0, 0, 0.5}, 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]) 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(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00"))) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0)) gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) return Context{Window: window, program: program} }
func main() { glfw.SetErrorCallback(errorCallback) // lock glfw/gl calls to a single thread runtime.LockOSThread() runtime.GOMAXPROCS(8) // Render, read commands, send input, extra for file loading, etc if !glfw.Init() { panic("Could not init glfw!") } defer glfw.Terminate() glfw.WindowHint(glfw.ContextVersionMajor, 3) glfw.WindowHint(glfw.ContextVersionMinor, 3) glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile) window, err := glfw.CreateWindow(800, 600, "Example", nil, nil) if err != nil { panic(err) } window.SetFramebufferSizeCallback(func(w *glfw.Window, width, height int) { fmt.Printf("Framebuffer size is now %vx%v\n", width, height) // Keep aspect ratio from camwidth/camheight camRatio := camWidth / camHeight bufRatio := float32(width) / float32(height) var newWidth, newHeight float32 switch { case camRatio > bufRatio: newHeight = float32(width) / camRatio newWidth = float32(width) case bufRatio > camRatio: newWidth = float32(height) * camRatio newHeight = float32(height) } fmt.Printf("Viewport size is now %vx%v; cam ratio is %v; viewport ratio is %v;\n", newWidth, newHeight, camRatio, newWidth/newHeight) gl.Viewport((width-int(newWidth))/2, (height-int(newHeight))/2, int(newWidth), int(newHeight)) }) defer window.Destroy() window.MakeContextCurrent() glfw.SwapInterval(1) gl.Init() // Enable blending gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) vao := gl.GenVertexArray() vao.Bind() vbo := gl.GenBuffer() vbo.Bind(gl.ARRAY_BUFFER) verticies := []float32{-0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, -0.5} gl.BufferData(gl.ARRAY_BUFFER, len(verticies)*4, verticies, gl.STATIC_DRAW) vertex_shader := gl.CreateShader(gl.VERTEX_SHADER) vertex_shader.Source(vertex) vertex_shader.Compile() fmt.Println(vertex_shader.GetInfoLog()) defer vertex_shader.Delete() fragment_shader := gl.CreateShader(gl.FRAGMENT_SHADER) fragment_shader.Source(fragment) fragment_shader.Compile() fmt.Println(fragment_shader.GetInfoLog()) defer fragment_shader.Delete() program := gl.CreateProgram() program.AttachShader(vertex_shader) program.AttachShader(fragment_shader) program.BindFragDataLocation(0, "outColor") program.Link() program.Use() defer program.Delete() positionAttrib := program.GetAttribLocation("position") positionAttrib.AttribPointer(2, gl.FLOAT, false, 0, nil) positionAttrib.EnableArray() defer positionAttrib.DisableArray() modelMat := program.GetUniformLocation("modelView") projMat := program.GetUniformLocation("projection") spriteSize := program.GetUniformLocation("size") cmd := exec.Command(os.Args[1], os.Args[2:]...) stdoutReader, stdoutWriter := io.Pipe() cmd.Stdout = stdoutWriter input := bufio.NewReader(stdoutReader) stdinReader, stdinWriter := io.Pipe() cmd.Stdin = stdinReader stderr, err := cmd.StderrPipe() chkErr(err) go io.Copy(os.Stderr, stderr) err = cmd.Start() chkErr(err) window.SetKeyCallback(handleKey) go func() { runtime.LockOSThread() for !window.ShouldClose() { sendInput(stdinWriter) //fmt.Fprintf(stdinWriter, "T %v\n", time.Now()) <-ticks readCommands(input) } }() frameCnt := 0 queueDepth := 0 then := time.Now() for !window.ShouldClose() { frameCnt++ queueDepth += len(commandBus) if frameCnt%120 == 0 { fmt.Printf("Queue depth: %v. Render time: %v. Decode time: %v.\n", queueDepth/120, time.Since(then)/120, decodeTime/time.Duration(decodes)) queueDepth = 0 then = time.Now() decodeTime = time.Duration(0) decodes = 0 } for len(commandBus) > 0 { (<-commandBus)() } halfwidth := camWidth / 2.0 halfheight := camHeight / 2.0 projection := mathgl.Ortho2D(camera.x-halfwidth, camera.x+halfwidth, camera.y+halfheight, camera.y-halfheight) projection = mathgl.Scale3D(camera.sx, camera.sy, 1).Mul4(projection) projection = mathgl.HomogRotate3DZ(camera.rot).Mul4(projection) projMat.UniformMatrix4f(false, (*[16]float32)(&projection)) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) for _, sprite := range sprites { sMat := mathgl.Scale3D(sprite.sx, sprite.sy, 1) sMat = mathgl.HomogRotate3DZ(sprite.rot).Mul4(sMat) sMat = mathgl.Translate3D(sprite.x, sprite.y, sprite.z).Mul4(sMat) // temp hack bank in sprite.bank = 1 sMap := findSMap(sprite.smap) spriteSize.Uniform2f(float32(sMap.getWidth()*sprite.cellwidth), float32(sMap.getHeight()*sprite.cellheight)) modelMat.UniformMatrix4f(false, (*[16]float32)(&sMat)) gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4) } window.SwapBuffers() glfw.PollEvents() if window.GetKey(glfw.KeyEscape) == glfw.Press { window.SetShouldClose(true) } } }
func (f *Font) ResizeWindow(width float32, height float32) { f.WindowWidth = width f.WindowHeight = height f.OrthographicMatrix = mgl32.Ortho2D(-f.WindowWidth/2, f.WindowWidth/2, -f.WindowHeight/2, f.WindowHeight/2) }
func (glRenderer *OpenglRenderer) DrawGeometry(geometry *renderer.Geometry, transform mgl32.Mat4) { glRenderer.enableShader() glRenderer.enableMaterial() glRenderer.enableCubeMap() if glRenderer.activeShader == nil { panic("ERROR: No shader is configured.") } shader := glRenderer.activeShader program := shader.Program params := glRenderer.rendererParams glRenderer.enableDepthTest(params.DepthTest) glRenderer.enableDepthMask(params.DepthMask) glRenderer.enableCullFace(params.CullBackface) glRenderer.enableUnlit(params.Unlit) glRenderer.setTransparency(params.Transparency) // set buffers gl.BindBuffer(gl.ARRAY_BUFFER, geometry.VboId) gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, geometry.IboId) // update buffers if geometry.VboDirty && len(geometry.Verticies) > 0 && len(geometry.Indicies) > 0 { gl.BufferData(gl.ARRAY_BUFFER, len(geometry.Verticies)*4, gl.Ptr(geometry.Verticies), gl.DYNAMIC_DRAW) gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(geometry.Indicies)*4, gl.Ptr(geometry.Indicies), gl.DYNAMIC_DRAW) geometry.VboDirty = false } // set uniforms modelNormal := transform.Inv().Transpose() shader.Uniforms["model"] = transform shader.Uniforms["modelNormal"] = modelNormal // set camera uniforms cam := glRenderer.camera win := glRenderer.WindowDimensions() shader.Uniforms["cameraTranslation"] = cam.Translation if cam.Ortho { shader.Uniforms["projection"] = mgl32.Ortho2D(0, win.X(), win.Y(), 0) shader.Uniforms["camera"] = mgl32.Ident4() } else { shader.Uniforms["projection"] = mgl32.Perspective(mgl32.DegToRad(cam.Angle), win.X()/win.Y(), cam.Near, cam.Far) shader.Uniforms["camera"] = mgl32.LookAtV(cam.Translation, cam.Lookat, cam.Up) } shader.Uniforms["unlit"] = glRenderer.unlit shader.Uniforms["useTextures"] = glRenderer.useTextures shader.Uniforms["ambientLightValue"] = glRenderer.ambientLightValue shader.Uniforms["nbPointLights"] = glRenderer.nbPointLights shader.Uniforms["pointLightValues"] = glRenderer.pointLightValues shader.Uniforms["pointLightPositions"] = glRenderer.pointLightPositions shader.Uniforms["nbDirectionalLights"] = glRenderer.nbDirectionalLights shader.Uniforms["directionalLightValues"] = glRenderer.directionalLightValues shader.Uniforms["directionalLightVectors"] = glRenderer.directionalLightVectors // set custom uniforms setupUniforms(shader) // set verticies attribute vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00"))) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, renderer.VertexStride*4, gl.PtrOffset(0)) // set normals attribute normAttrib := uint32(gl.GetAttribLocation(program, gl.Str("normal\x00"))) gl.EnableVertexAttribArray(normAttrib) gl.VertexAttribPointer(normAttrib, 3, gl.FLOAT, false, renderer.VertexStride*4, gl.PtrOffset(3*4)) // set texture coord attribute texCoordAttrib := uint32(gl.GetAttribLocation(program, gl.Str("texCoord\x00"))) gl.EnableVertexAttribArray(texCoordAttrib) gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, renderer.VertexStride*4, gl.PtrOffset(6*4)) // vertex color attribute colorAttrib := uint32(gl.GetAttribLocation(program, gl.Str("color\x00"))) gl.EnableVertexAttribArray(colorAttrib) gl.VertexAttribPointer(colorAttrib, 4, gl.FLOAT, false, renderer.VertexStride*4, gl.PtrOffset(8*4)) gl.DrawElements(gl.TRIANGLES, (int32)(len(geometry.Indicies)), gl.UNSIGNED_INT, gl.PtrOffset(0)) }