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 Run(g *Game) error { if g.Scene == nil { return fmt.Errorf("Scene property of given Game struct is empty") } // GLFW event handling must run on the main OS thread runtime.LockOSThread() if err := glfw.Init(); err != nil { return fmt.Errorf("glfw.Init failed: %s", err) } defer glfw.Terminate() glfw.WindowHint(glfw.ContextVersionMajor, OpenGLVerMinor) glfw.WindowHint(glfw.ContextVersionMinor, OpenGLVerMinor) glfw.WindowHint(glfw.Resizable, glfw.False) if g.Resizable { glfw.WindowHint(glfw.Resizable, glfw.True) } glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True) window, err := glfw.CreateWindow(int(g.Width), int(g.Height), g.Title, nil, nil) if err != nil { return fmt.Errorf("glfw.CreateWindow failed: %s", err) } window.MakeContextCurrent() // Initialize Glow if err := gl.Init(); err != nil { return fmt.Errorf("gl.Init failed:", err) } version := gl.GoStr(gl.GetString(gl.VERSION)) log.Println("gl.Init successful, OpenGL version:", version) var previousTime, deltaTime, time float32 previousTime = float32(glfw.GetTime()) - 1.0/60.0 g.Scene.Setup() for !window.ShouldClose() { time = float32(glfw.GetTime()) deltaTime = time - previousTime glfw.PollEvents() gl.ClearColor(0.2, 0.3, 0.3, 0.5) gl.Clear(gl.COLOR_BUFFER_BIT) g.Scene.Update(deltaTime) g.Scene.Draw(deltaTime) previousTime = time window.SwapBuffers() } return nil }
func initOpenGl(window *glfw.Window, w, h int) { w, h = window.GetSize() // query window to get screen pixels width, height := window.GetFramebufferSize() gl.Viewport(0, 0, width, height) gl.MatrixMode(gl.PROJECTION) gl.LoadIdentity() gl.Ortho(0, float64(w), 0, float64(h), -1, 1) gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.ClearColor(.25, .88, .83, 1) // turquoise }
func (r *EffectsRenderer) Bind() error { gl.BindFramebuffer(gl.FRAMEBUFFER, r.framebuffer) gl.Enable(gl.STENCIL_TEST) gl.Viewport(0, 0, int32(r.width), int32(r.height)) gl.ClearStencil(0) gl.ClearColor(0.0, 0.0, 0.0, 0.0) gl.StencilMask(0xFF) // Write to buffer gl.Clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT) gl.StencilMask(0x00) // Don't write to buffer return nil }
func (c *Context) CreateWindow(w, h int, name string) (err error) { c.w = w c.h = h c.name = name c.createWindow() c.SetCursor(c.cursor) gl.Init() if e := gl.GetError(); e != 0 { if e != gl.INVALID_ENUM { err = fmt.Errorf("OpenGL glInit error: %X\n", e) return } } c.OpenGLVersion = glfw.GetVersionString() c.ShaderVersion = gl.GoStr(gl.GetString(gl.SHADING_LANGUAGE_VERSION)) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.ClearColor(0.0, 0.0, 0.0, 1.0) gl.Disable(gl.CULL_FACE) glfw.SwapInterval(1) return }
func (c *Context) CreateWindow(w, h int, name string) (err error) { c.w = w c.h = h c.name = name var monitor *glfw.Monitor if c.fullscreen == true { monitor = glfw.GetPrimaryMonitor() } if c.window, err = glfw.CreateWindow(c.w, c.h, c.name, monitor, nil); err != nil { return } if c.cursor == false { c.window.SetInputMode(glfw.CursorMode, glfw.CursorHidden) } c.window.MakeContextCurrent() gl.Init() if e := gl.GetError(); e != 0 { if e == gl.INVALID_ENUM { fmt.Printf("GL_INVALID_ENUM when calling glInit\n") } else { err = fmt.Errorf("OpenGL glInit error: %X\n", e) return } } c.OpenGLVersion = glfw.GetVersionString() c.ShaderVersion = gl.GoStr(gl.GetString(gl.SHADING_LANGUAGE_VERSION)) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.ClearColor(0.0, 0.0, 0.0, 1.0) gl.Disable(gl.CULL_FACE) glfw.SwapInterval(1) if c.VAO, err = CreateVAO(); err != nil { return } gl.BindVertexArray(c.VAO) c.Events = NewEventHandler(c.window) return }
// Initializing the game and set of assets. func initialize() (*glfw.Window, *Assets, error) { if err := glfw.Init(); err != nil { return nil, nil, err } // Setting up a bunch of windowing stuff with GLFW. 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) // Creating GLFW. window, err := glfw.CreateWindow(640, 480, "Testing", nil, nil) if err != nil { return nil, nil, err } // Creating OpenGL. window.MakeContextCurrent() if err := gl.Init(); err != nil { return nil, nil, err } gl.ClearColor(0.3, 0.3, 0.3, 1.0) if config.DebugMode { version := gl.GoStr(gl.GetString(gl.VERSION)) fmt.Println("Running on OpenGL: " + version) } // Loading assets. assets, err := NewAssets([]string{"res/shaders/texrenderer"}, []string{"res/textures/texture.jpg"}) if err != nil { return nil, nil, err } return window, assets, nil }
func main() { //initializing glfw and OpenGL err := glfw.Init() if err != nil { panic(err) } defer glfw.Terminate() window, err := glfw.CreateWindow(graphics.WIDTH, graphics.HEIGHT, "Testing", nil, nil) if err != nil { panic(err) } window.MakeContextCurrent() if err := gl.Init(); err != nil { panic(err) } gl.Viewport(0, 0, graphics.WIDTH, graphics.HEIGHT) gl.ClearColor(0.0, 0.0, 0.0, 1.0) //game.Loop(window) game.EngineLoop(window) }
// Clear clears the screen using the color provided. func (c Context) Clear(color Color) { gl.ClearColor(color.R, color.G, color.B, 1.0) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) }
// DoRender does the graphical rendering of a single frame. func (gr *GameRenderer) DoRender(delta float32) { // detect any changes to size of the window tempW, tempH := gr.MainWindow.GetFramebufferSize() currentWidth, currentHeight := int32(tempW), int32(tempH) width, height := gr.Renderer.GetResolution() if width == 0 || height == 0 { groggy.Logsf("ERROR", "GameRenderer.DoRender() window size w/h: %d / %d", width, height) } if width != currentWidth || height != currentHeight { width, height = currentWidth, currentHeight gr.Renderer.ChangeResolution(width, height) } // clear the screen gl.Viewport(0, 0, int32(width), int32(height)) gl.ClearColor(0.05, 0.05, 0.05, 1.0) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // make the projection and view matrixes perspective := mgl.Perspective(mgl.DegToRad(60.0), float32(width)/float32(height), 1.0, 400.0) view := gr.camera.GetViewMatrix() // Get the landscape chunks to render -- which for now is everything landMan := gameManager.GetLandscapeManager() allChunks := landMan.GetAllChunks() // draw everything you crazy devil for _, c := range allChunks { node := c.GetTheRenderable() if node.Core.Shader == nil { node.Core.Shader = gr.Shaders["landscape"] } gr.Renderer.DrawRenderable(node, customLandscapeBinder, perspective, view) } // get the entity manager and all the entities entMan := gameManager.GetEntityManager() allEnts := entMan.GetAllEntities() // draw everything, because we're crazy for _, e := range allEnts { // make sure we have something to draw if e.Renderable == nil { // try to clone a new renderable from the asset prototypes proto, okay := loadedAssets[e.AssetPath] if okay { e.Renderable = proto.Clone() } } // sync the loc/rot to the renderable e.SyncToRenderable() // did we sort things out and make a renderable? if e.Renderable != nil { gr.Renderer.DrawRenderable(e.Renderable, nil, perspective, view) } } // draw the screen gr.Renderer.EndRenderFrame() }
func main() { // init glfw if err := glfw.Init(); err != nil { panic(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) // make an application window window, err := glfw.CreateWindow(windowWidth, windowHeight, "Hello", nil, nil) if err != nil { panic(err) } window.MakeContextCurrent() // init gl if err := gl.Init(); err != nil { panic(err) } fmt.Println("OpenGL version", gl.GoStr(gl.GetString(gl.VERSION))) // create vertex & fragment shader program, err := newProgram(vertexShader, fragmentShader) if err != nil { panic(err) } gl.UseProgram(program) gl.BindFragDataLocation(program, 0, gl.Str("fc\x00")) points := []float32{ -0.5, -0.5, 0.5, 0.5, 0.5, -0.5, -0.5, 0.5, } vertices := []uint32{ 0, 2, 1, 3, } // configure the vertex data var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) defer gl.BindVertexArray(0) var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) gl.BufferData(gl.ARRAY_BUFFER, len(points)*4, gl.Ptr(points), gl.STATIC_DRAW) var ibo uint32 gl.GenBuffers(1, &ibo) gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo) gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("pv\x00"))) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 2, gl.FLOAT, false, 2*4, gl.PtrOffset(0)) // global settings gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(1.0, 1.0, 1.0, 1.0) for !window.ShouldClose() { gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) gl.UseProgram(program) gl.BindVertexArray(vao) gl.DrawElements(gl.LINE_LOOP, 4, gl.UNSIGNED_INT, gl.PtrOffset(0)) 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() } }
// Clear instructs opengl to clear the background to a certain color func Clear(r, g, b, a float32) { gl.ClearColor(1.0, 1.0, 1.0, 1.0) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) }
// Testing stuff to do with opening an OpenGL context. func Testing() error { window, assets, err := initialize() if err != nil { return nil } defer destroy(window, assets) shaderProgram, _ := assets.GetProgram("res/shaders/texrenderer") texture, _ := assets.GetTexture("res/textures/texture.jpg") renderObject := CreateRenderObject(shaderProgram, texture, []float32{ -1.0, -1.0, 0.0, 0.0, 1.0, -1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 0.0, 1.0, }) defer renderObject.Destroy() // Testing a LineRender. lineShader, err := LoadShaderProgram("res/shaders/lineshader") if err != nil { fmt.Println("LSP: " + err.Error()) } defer DestroyShaderProgram(lineShader) lineRenders := []*LineRender{ NewLineRender(lineShader, GetPastel(1), true, 3.0, []Point{ Point{-1.0, 0}, Point{1.0, 0}, }), NewLineRender(lineShader, GetPastel(2), true, 8.0, []Point{ Point{-0.5, -0.5}, Point{0.5, 0.5}, Point{1, 0}, }), } defer func() { for _, lr := range lineRenders { lr.Destroy() } }() // Creating a 2nd LineRender from DefaultGenerateSinePoints. var phase float32 = 0 lineRender2 := NewLineRender( lineShader, GetPastel(0), false, 4.0, DefaultGenerateSinePoints(440, phase)) defer lineRender2.Destroy() gl.ClearColor(1.0, 1.0, 1.0, 1.0) for !window.ShouldClose() { gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // Rendering the outputs. renderObject.Render() for _, lr := range lineRenders { lr.Render() } lineRender2.Render() // Updating render for lineRender2. phase += 2 * math.Pi * (440.0 / 44100.0) if phase > 2*math.Pi { phase -= 2 * math.Pi } lineRender2.UpdatePoints(DefaultGenerateSinePoints(440, phase)) if config.DebugMode { // Reporting OpenGL errors. glErr := gl.GetError() if glErr != gl.NO_ERROR { fmt.Printf("OpenGL error: %d\n", glErr) } } window.SwapBuffers() glfw.PollEvents() time.Sleep(10 * time.Millisecond) } return nil }
func main() { // init glfw if err := glfw.Init(); err != nil { panic(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) // make an application window window, err := glfw.CreateWindow(windowWidth, windowHeight, "Transform", nil, nil) if err != nil { panic(err) } window.MakeContextCurrent() // init gl if err := gl.Init(); err != nil { panic(err) } fmt.Println("OpenGL version", gl.GoStr(gl.GetString(gl.VERSION))) // create vertex & fragment shader 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]) gl.BindFragDataLocation(program, 0, gl.Str("vert\x00")) points := []float32{ -0.9, -0.9, -0.9, 0.9, -0.9, -0.9, 0.9, -0.9, 0.9, -0.9, -0.9, 0.9, -0.9, 0.9, -0.9, 0.9, 0.9, -0.9, 0.9, 0.9, 0.9, -0.9, 0.9, 0.9, } vertices := []uint32{ 0, 1, 1, 2, 2, 3, 3, 0, 0, 4, 1, 5, 2, 6, 3, 7, 4, 5, 5, 6, 6, 7, 7, 4, } // configure the vertex data var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) defer gl.BindVertexArray(0) var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) gl.BufferData(gl.ARRAY_BUFFER, len(points)*4, gl.Ptr(points), gl.STATIC_DRAW) var ibo uint32 gl.GenBuffers(1, &ibo) gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo) gl.BufferData(gl.ELEMENT_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)) // global settings gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.ClearColor(0.0, 0.0, 0.0, 1.0) angleX := 0.0 angleY := 0.0 angleZ := 0.0 previousTime := glfw.GetTime() for !window.ShouldClose() { gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) time := glfw.GetTime() elapsed := time - previousTime previousTime = time angleX += math.Sin((elapsed / period) * math.Pi * 2.0) angleY += math.Sin((elapsed / period) / 6.0 * math.Pi * 2.0) angleZ += math.Sin((elapsed / period) / 3.0 * math.Pi * 2.0) model = mgl32.HomogRotate3DY(float32(angleY)).Mul4(mgl32.HomogRotate3DX(float32(angleX))).Mul4(mgl32.HomogRotate3DZ(float32(angleZ))) gl.UseProgram(program) gl.UniformMatrix4fv(modelUniform, 1, false, &model[0]) gl.BindVertexArray(vao) gl.DrawElements(gl.LINES, int32(len(vertices)), gl.UNSIGNED_INT, gl.PtrOffset(0)) window.SwapBuffers() glfw.PollEvents() } }
func InitGL() error { defer tlog.FuncLog(tlog.Func("InitGL")) err := gl.Init() if err != nil { return err } gl.GetError() // cleanup gl error state version := gl.GoStr(gl.GetString(gl.VERSION)) tlog.Println("OpenGL version", version) gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL) Check() gl.ReadBuffer(gl.BACK) Check() gl.DrawBuffer(gl.BACK) Check() gl.FrontFace(gl.CW) Check() gl.CullFace(gl.BACK) Check() gl.Disable(gl.CULL_FACE) Check() gl.ClearColor(1, 1, 0.5, 0) Check() gl.ClearDepth(1.0) Check() gl.ClearStencil(0) Check() gl.Disable(gl.STENCIL_TEST) Check() gl.StencilMask(0xFFFFFFFF) Check() gl.StencilFunc(gl.EQUAL, 0x00000000, 0x00000001) Check() gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP) Check() gl.Disable(gl.DITHER) Check() gl.Enable(gl.DEPTH_TEST) Check() gl.DepthFunc(gl.LEQUAL) Check() gl.DepthMask(true) Check() gl.DepthRange(0., 1.) Check() gl.Enable(gl.DEPTH_CLAMP) Check() gl.Enable(gl.BLEND) Check() gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) ForceCheck() return nil }
func Init() error { if err := gl.Init(); err != nil { return err } log.Printf("OpenGL version: %s", gl.GoStr(gl.GetString(gl.VERSION))) vs, err := asset.String("shader.vert") if err != nil { return err } fs, err := asset.String("shader.frag") if err != nil { return err } program, err := createProgram(vs, fs) if err != nil { return err } gl.UseProgram(program) var shaderErr error uniform := func(name string) int32 { var loc int32 loc, shaderErr = getUniformLocation(program, name) return loc } projectionViewMatrixUniform = uniform("u_projectionViewMatrix") modelMatrixUniform = uniform("u_modelMatrix") normalMatrixUniform = uniform("u_normalMatrix") ambientLightColorUniform = uniform("u_ambientLightColor") directionalLightColorUniform = uniform("u_directionalLightColor") directionalVectorUniform = uniform("u_directionalVector") textureUniform = uniform("u_texture") grayscaleUniform = uniform("u_grayscale") brightnessUniform = uniform("u_brightness") alphaUniform = uniform("u_alpha") mixColorUniform = uniform("u_mixColor") mixAmountUniform = uniform("u_mixAmount") if shaderErr != nil { return shaderErr } vm := newViewMatrix(cameraPosition, targetPosition, up) nm := vm.inverse().transpose() gl.UniformMatrix4fv(normalMatrixUniform, 1, false, &nm[0]) gl.Uniform3fv(ambientLightColorUniform, 1, &ambientLightColor[0]) gl.Uniform3fv(directionalLightColorUniform, 1, &directionalLightColor[0]) gl.Uniform3fv(directionalVectorUniform, 1, &directionalVector[0]) SizeCallback = func(width, height int) { if winWidth == width && winHeight == height { return } log.Printf("window size changed (%dx%d -> %dx%d)", int(winWidth), int(winHeight), width, height) gl.Viewport(0, 0, int32(width), int32(height)) // Calculate new perspective projection view matrix. winWidth, winHeight = width, height fw, fh := float32(width), float32(height) aspect := fw / fh fovRadians := float32(math.Pi) / 3 perspectiveProjectionViewMatrix = vm.mult(newPerspectiveMatrix(fovRadians, aspect, 1, 2000)) // Calculate new ortho projection view matrix. orthoProjectionViewMatrix = newOrthoMatrix(fw, fh, fw /* use width as depth */) } if err := initMeshes(); err != nil { return err } if err := initTextures(); err != nil { return err } gl.Enable(gl.CULL_FACE) gl.CullFace(gl.BACK) gl.Enable(gl.DEPTH_TEST) gl.DepthFunc(gl.LESS) gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.ClearColor(0, 0, 0, 0) return nil }