func (p *Program) createVAO() error { gl.GenVertexArrays(1, &p.vao) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR gl.GenVertexArray %X", e) } gl.BindVertexArray(p.vao) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR array.Bind %X", e) } return nil }
func CreateVAO() (array uint32, err error) { gl.GenVertexArrays(1, &array) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR gl.GenVertexArray %X", e) return } gl.BindVertexArray(array) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR array.Bind %X", e) return } return }
func (tr *TextRenderer) Unbind() error { gl.BindBuffer(gl.ARRAY_BUFFER, 0) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } return nil }
// Runs the visualization with a set of DelayedNoteData. The DelayedNote data is // used to push information to the synth as well as represent the data visually. func RunVisualization(notes *synth.NoteArrangement, oNoteChannel chan synth.DelayedNoteData) error { window, assets, err := initialize() if err != nil { return err } defer destroy(window, assets) // The main update loop. ct, lt, dt := 0.0, 0.0, 0.0 for !window.ShouldClose() { // Keeping the current time. lt = ct ct = glfw.GetTime() dt = ct - lt // Real render loop. gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) if config.DebugMode { glErr := gl.GetError() if glErr != gl.NO_ERROR { fmt.Printf("OpenGL error: %d\n", glErr) } } window.SwapBuffers() glfw.PollEvents() if dt < 1/1000.0 { // Delay the thread to keep up w/ updating? } } return nil }
func (lr *LinesRenderer) Draw(line *LineGeometry, mv mgl32.Mat4, style *LineStyle) (err error) { var ( dataBytes int = len(line.Vertices) * int(lr.stride) indexBytes int = len(line.Indices) * int(lr.stride) elementCount int32 = int32(len(line.Indices)) r, g, b, a = style.Color.RGBA() ) gl.Uniform1f(lr.thicknessLoc, style.Thickness) gl.Uniform1f(lr.innerLoc, style.Inner) gl.Uniform4f(lr.colorLoc, float32(r)/255.0, float32(g)/255.0, float32(b)/255.0, float32(a)/255.0) gl.UniformMatrix4fv(lr.modelviewLoc, 1, false, &mv[0]) if dataBytes > lr.bufferBytes { lr.bufferBytes = dataBytes gl.BufferData(gl.ARRAY_BUFFER, dataBytes, gl.Ptr(line.Vertices), gl.STREAM_DRAW) gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, indexBytes, gl.Ptr(line.Indices), gl.STREAM_DRAW) } else { gl.BufferSubData(gl.ARRAY_BUFFER, 0, dataBytes, gl.Ptr(line.Vertices)) gl.BufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, indexBytes, gl.Ptr(line.Indices)) } gl.DrawElements(gl.TRIANGLES, elementCount, gl.UNSIGNED_INT, gl.PtrOffset(0)) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func NewRenderer(bufferSize int) (r *Renderer, err error) { var ( instance renderInstance instanceStride = unsafe.Sizeof(instance) ) r = &Renderer{ shader: core.NewProgram(), bufferSize: bufferSize, buffer: make([]renderInstance, bufferSize), stride: instanceStride, } if err = r.shader.Load(VERTEX, FRAGMENT); err != nil { return } r.shader.Bind() r.vbo = core.NewArrayBuffer() r.shader.Attrib("f_InstanceFrame", instanceStride).Float(unsafe.Offsetof(instance.frame), 1) r.shader.Attrib("m_Model", instanceStride).Mat4(unsafe.Offsetof(instance.model), 1) r.shader.Attrib("v_Color", instanceStride).Vec4(unsafe.Offsetof(instance.color), 1) r.textureData = r.shader.UniformBlock("TextureData", 1) r.uView = r.shader.Uniform("m_View") r.uProj = r.shader.Uniform("m_Projection") if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func NewLinesRenderer(camera *Camera) (lr *LinesRenderer, err error) { var ( program uint32 vbos = make([]uint32, 2) point TexturedPoint ) if program, err = BuildProgram(LINES_VERTEX, LINES_FRAGMENT); err != nil { return } gl.GenBuffers(2, &vbos[0]) lr = &LinesRenderer{ Renderer: NewRenderer(camera), program: program, buffer: vbos[0], indexBuffer: vbos[1], bufferBytes: 0, positionLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Position\x00"))), normalLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Normal\x00"))), miterLoc: uint32(gl.GetAttribLocation(program, gl.Str("f_Miter\x00"))), modelviewLoc: gl.GetUniformLocation(program, gl.Str("m_ModelView\x00")), projectionLoc: gl.GetUniformLocation(program, gl.Str("m_Projection\x00")), thicknessLoc: gl.GetUniformLocation(program, gl.Str("f_Thickness\x00")), colorLoc: gl.GetUniformLocation(program, gl.Str("v_Color\x00")), innerLoc: gl.GetUniformLocation(program, gl.Str("f_Inner\x00")), offPosition: gl.PtrOffset(int(unsafe.Offsetof(point.X))), offNormal: gl.PtrOffset(int(unsafe.Offsetof(point.TextureX))), offMiter: gl.PtrOffset(int(unsafe.Offsetof(point.Z))), stride: int32(unsafe.Sizeof(point)), } if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func (lr *LinesRenderer) Unbind() (err error) { gl.BindBuffer(gl.ARRAY_BUFFER, 0) gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func (lr *LinesRenderer) Delete() (err error) { gl.BindBuffer(gl.ARRAY_BUFFER, 0) gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0) gl.DeleteBuffers(1, &lr.buffer) gl.DeleteBuffers(1, &lr.indexBuffer) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func (r *Renderer) draw(geometry *Geometry, count int) (err error) { if count <= 0 { return } r.vbo.Upload(r.buffer, count*int(r.stride)) gl.DrawArraysInstanced(gl.TRIANGLES, 0, int32(len(geometry.Points)), int32(count)) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func (tr *TextRenderer) Draw(tex *Texture, x, y, scale float32) (err error) { gl.ActiveTexture(gl.TEXTURE0) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.BindTexture(gl.TEXTURE_2D, tex.Texture) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.Uniform3f(tr.ScaleLoc, float32(tex.Width)*scale, float32(tex.Height)*scale, 1) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.Uniform3f(tr.TransLoc, x, y, 0) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.BindBuffer(gl.ARRAY_BUFFER, 0) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } return nil }
func (tr *TextRenderer) Bind() error { gl.UseProgram(tr.Program) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.Uniform1i(tr.TextureUnitLoc, 0) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.BindBuffer(gl.ARRAY_BUFFER, tr.VBO) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.EnableVertexAttribArray(tr.PositionLoc) gl.VertexAttribPointer(tr.PositionLoc, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0)) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.EnableVertexAttribArray(tr.TextureLoc) gl.VertexAttribPointer(tr.TextureLoc, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4)) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } gl.UniformMatrix4fv(tr.ProjectionLoc, 1, false, &tr.Renderer.Camera.Projection[0]) if e := gl.GetError(); e != 0 { return fmt.Errorf("ERROR: %X", e) } return nil }
func CreateVBO(size int, data interface{}, usage uint32) (buffer uint32, err error) { gl.GenBuffers(1, &buffer) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR gl.GenBuffer %X", e) return } gl.BindBuffer(gl.ARRAY_BUFFER, buffer) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR buffer.Bind %X", e) return } gl.BufferData(gl.ARRAY_BUFFER, size, gl.Ptr(data), usage) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR gl.BufferData %X", e) return } gl.BindBuffer(gl.ARRAY_BUFFER, 0) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR buffer.Unbind %X", e) return } return }
func (lr *LinesRenderer) Bind() (err error) { gl.UseProgram(lr.program) gl.BindBuffer(gl.ARRAY_BUFFER, lr.buffer) gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, lr.indexBuffer) gl.EnableVertexAttribArray(lr.positionLoc) gl.EnableVertexAttribArray(lr.normalLoc) gl.EnableVertexAttribArray(lr.miterLoc) gl.VertexAttribPointer(lr.positionLoc, 2, gl.FLOAT, false, lr.stride, lr.offPosition) gl.VertexAttribPointer(lr.normalLoc, 2, gl.FLOAT, false, lr.stride, lr.offNormal) gl.VertexAttribPointer(lr.miterLoc, 1, gl.FLOAT, false, lr.stride, lr.offMiter) gl.UniformMatrix4fv(lr.projectionLoc, 1, false, &lr.Renderer.Camera.Projection[0]) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func ForceCheck() { switch gl.GetError() { case gl.INVALID_ENUM: tlog.Panic("OpenGL Error: GL_INVALID_ENUM") case gl.INVALID_VALUE: tlog.Panic("OpenGL Error: GL_INVALID_VALUE") case gl.INVALID_OPERATION: tlog.Panic("OpenGL Error: GL_INVALID_OPERATION") case gl.STACK_OVERFLOW: tlog.Panic("OpenGL Error: GL_STACK_OVERFLOW") case gl.STACK_UNDERFLOW: tlog.Panic("OpenGL Error: GL_STACK_UNDERFLOW") case gl.OUT_OF_MEMORY: tlog.Panic("OpenGL Error: GL_OUT_OF_MEMORY") } }
func GetGLTexture(img image.Image, smoothing TextureSmoothing) (t uint32, err error) { var ( data *bytes.Buffer bounds image.Rectangle width int height int ) if data, err = imageBytes(img); err != nil { return } bounds = img.Bounds() width = bounds.Max.X - bounds.Min.X height = bounds.Max.Y - bounds.Min.Y gl.GenTextures(1, &t) if e := gl.GetError(); e != 0 { fmt.Printf("ggt1 ERROR: %s\n", e) } gl.BindTexture(gl.TEXTURE_2D, t) if e := gl.GetError(); e != 0 { fmt.Printf("ggt2 ERROR: %s\n", e) } gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, int32(smoothing)) if e := gl.GetError(); e != 0 { fmt.Printf("ggt3 ERROR: %s\n", e) } gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, int32(smoothing)) if e := gl.GetError(); e != 0 { fmt.Printf("ggt4 ERROR: %s\n", e) } gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(width), int32(height), 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, gl.Ptr(data.Bytes())) if e := gl.GetError(); e != 0 { fmt.Printf("ggt5 ERROR: %s\n", e) } gl.GenerateMipmap(gl.TEXTURE_2D) if e := gl.GetError(); e != 0 { fmt.Printf("ggt6 ERROR: %s\n", e) } gl.BindTexture(gl.TEXTURE_2D, 0) if e := gl.GetError(); e != 0 { fmt.Printf("ggt7 ERROR: %s\n", e) } return }
func NewBatchRenderer(camera *Camera) (tr *BatchRenderer, err error) { var ( program uint32 ) if program, err = BuildProgram(BATCH_VERTEX, BATCH_FRAGMENT); err != nil { return } tr = &BatchRenderer{ Renderer: NewRenderer(camera), Program: program, PositionLoc: uint32(gl.GetAttribLocation(program, gl.Str("a_Position\x00"))), TextureLoc: uint32(gl.GetAttribLocation(program, gl.Str("a_TextureCoordinates\x00"))), TextureUnitLoc: gl.GetUniformLocation(program, gl.Str("u_TextureUnit\x00")), ModelViewLoc: gl.GetUniformLocation(program, gl.Str("m_ModelViewMatrix\x00")), ProjectionLoc: gl.GetUniformLocation(program, gl.Str("m_ProjectionMatrix\x00")), TexOffsetLoc: gl.GetUniformLocation(program, gl.Str("u_TextureOffset\x00")), } if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
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 (r *EffectsRenderer) GetError() error { if e := gl.GetError(); e != 0 { return fmt.Errorf("OpenGL error: %X", e) } var status = gl.CheckFramebufferStatus(gl.DRAW_FRAMEBUFFER) switch status { case gl.FRAMEBUFFER_COMPLETE: return nil case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: return fmt.Errorf("Attachment point unconnected") case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: return fmt.Errorf("Missing attachment") case gl.FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: return fmt.Errorf("Draw buffer") case gl.FRAMEBUFFER_INCOMPLETE_READ_BUFFER: return fmt.Errorf("Read buffer") case gl.FRAMEBUFFER_UNSUPPORTED: return fmt.Errorf("Unsupported config") default: return fmt.Errorf("Unknown framebuffer error: %X", status) } }
func (p *Program) linkProgram(vertex uint32, fragment uint32) (program uint32, err error) { program = gl.CreateProgram() gl.AttachShader(program, vertex) gl.AttachShader(program, fragment) gl.BindFragDataLocation(program, 0, gl.Str("v_FragData\x00")) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR program.BindFragDataLocation %X", e) return } gl.LinkProgram(program) var status int32 if gl.GetProgramiv(program, gl.LINK_STATUS, &status); status == gl.FALSE { var length int32 gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &length) log := strings.Repeat("\x00", int(length+1)) gl.GetProgramInfoLog(program, length, nil, gl.Str(log)) err = fmt.Errorf("ERROR program link:\n%s", log) } gl.DeleteShader(vertex) gl.DeleteShader(fragment) return }
func MakeProgram(vert, frag string) (uint32, error) { vertexShader, err := compileShader(vert, gl.VERTEX_SHADER) if err != nil { return 0, err } fragmentShader, err := compileShader(frag, gl.FRAGMENT_SHADER) if err != nil { return 0, err } program := gl.CreateProgram() gl.AttachShader(program, vertexShader) gl.AttachShader(program, fragmentShader) gl.LinkProgram(program) var status int32 gl.GetProgramiv(program, gl.LINK_STATUS, &status) if status == gl.FALSE { var logLength int32 gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &logLength) log := strings.Repeat("\x00", int(logLength+1)) gl.GetProgramInfoLog(program, logLength, nil, gl.Str(log)) return 0, errors.New(fmt.Sprintf("failed to link program: %v", log)) } gl.DeleteShader(vertexShader) gl.DeleteShader(fragmentShader) if ok := gl.GetError(); ok != gl.NO_ERROR { return 0, errors.New("Error in Make Program : " + string(ok)) } return program, nil }
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 }
func (r *Framerate) Render(camera *core.Camera) (err error) { r.data.Sample() var ( modelView = mgl32.Ident4() dataBytes int = int(r.data.Count) * int(r.stride) ) gl.Uniform4f(r.locColor, 255.0/255.0, 0, 0, 255.0/255.0) gl.UniformMatrix4fv(r.locModelView, 1, false, &modelView[0]) gl.UniformMatrix4fv(r.locProjection, 1, false, &camera.Projection[0]) if dataBytes > r.vboBytes { r.vboBytes = dataBytes gl.BufferData(gl.ARRAY_BUFFER, dataBytes, gl.Ptr(r.data.Points), gl.STREAM_DRAW) } else { gl.BufferSubData(gl.ARRAY_BUFFER, 0, dataBytes, gl.Ptr(r.data.Points)) } gl.DrawArrays(gl.POINTS, 0, r.data.Count) if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func NewSpriteRenderer(camera *Camera) (tr *SpriteRenderer, err error) { var ( program uint32 vbos = make([]uint32, 1) sprite SpriteConfig frameOffset = int(unsafe.Offsetof(sprite.Frame)) viewOffset = int(unsafe.Offsetof(sprite.View)) ) if program, err = BuildProgram(SPRITE_VERTEX, SPRITE_FRAGMENT); err != nil { return } gl.GenBuffers(1, &vbos[0]) tr = &SpriteRenderer{ Renderer: NewRenderer(camera), program: program, instanceVBO: vbos[0], instanceBytes: 0, translationLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Translation\x00"))), rotationLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Rotation\x00"))), scaleLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Scale\x00"))), pointAdjLoc: uint32(gl.GetAttribLocation(program, gl.Str("m_PointAdjustment\x00"))), textureAdjLoc: uint32(gl.GetAttribLocation(program, gl.Str("m_TextureAdjustment\x00"))), colorLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Color\x00"))), textureUnitLoc: gl.GetUniformLocation(program, gl.Str("TextureUnit\x00")), projectionLoc: gl.GetUniformLocation(program, gl.Str("m_ProjectionMatrix\x00")), offAttrX: gl.PtrOffset(viewOffset + int(unsafe.Offsetof(sprite.View.X))), offAttrRotationX: gl.PtrOffset(viewOffset + int(unsafe.Offsetof(sprite.View.RotationX))), offAttrColor: gl.PtrOffset(int(unsafe.Offsetof(sprite.Color))), offAttrScaleX: gl.PtrOffset(viewOffset + int(unsafe.Offsetof(sprite.View.ScaleX))), offAttrPointAdj: frameOffset + int(unsafe.Offsetof(sprite.Frame.PointAdjustment)), offAttrTextureAdj: frameOffset + int(unsafe.Offsetof(sprite.Frame.TextureAdjustment)), } if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func NewTextRenderer(camera *Camera) (tr *TextRenderer, err error) { var ( rect []float32 program uint32 vbo uint32 ) rect = []float32{ 0, 0, 0.0, 0.0, 0.0, 0, 1, 0.0, 0.0, 1.0, 1, 0, 0.0, 1.0, 0.0, 1, 1, 0.0, 1.0, 1.0, } if program, err = BuildProgram(TEXT_VERTEX, TEXT_FRAGMENT); err != nil { return } if vbo, err = CreateVBO(len(rect)*4, rect, gl.STATIC_DRAW); err != nil { return } tr = &TextRenderer{ Renderer: NewRenderer(camera), VBO: vbo, Program: program, PositionLoc: uint32(gl.GetAttribLocation(program, gl.Str("a_Position\x00"))), TextureLoc: uint32(gl.GetAttribLocation(program, gl.Str("a_TextureCoordinates\x00"))), TextureUnitLoc: gl.GetUniformLocation(program, gl.Str("u_TextureUnit\x00")), TransLoc: gl.GetUniformLocation(program, gl.Str("v_Trans\x00")), ScaleLoc: gl.GetUniformLocation(program, gl.Str("v_Scale\x00")), ProjectionLoc: gl.GetUniformLocation(program, gl.Str("m_ProjectionMatrix\x00")), Width: camera.ScreenBounds.Max.X() - camera.ScreenBounds.Min.X(), Height: camera.ScreenBounds.Max.Y() - camera.ScreenBounds.Min.Y(), } if e := gl.GetError(); e != 0 { err = fmt.Errorf("ERROR: OpenGL error %X", e) } return }
func bindAggregateImage(img image.Image, idx int) uint32 { newIdx := idx if rgba, ok := img.(*image.RGBA); ok { gl.GenTextures(1, &textures[newIdx]) gl.ActiveTexture(gl.TEXTURE0 + uint32(newIdx)) gl.BindTexture(gl.TEXTURE_2D, textures[newIdx]) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE) gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(rgba.Rect.Size().X), int32(rgba.Rect.Size().Y), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(rgba.Pix)) gl.GenerateMipmap(gl.TEXTURE_2D) idxS := strconv.Itoa(newIdx) fmt.Println("idx: ", int32(newIdx), "myTextureSampler["+idxS+"]\x00") gl.Uniform1i(gl.GetUniformLocation(program, gl.Str("myTextureSampler["+idxS+"]\x00")), int32(newIdx)) if ok := gl.GetError(); ok != gl.NO_ERROR { fmt.Println("1- Cannot load Image in location: ./: ", ok) os.Exit(-1) } return textures[newIdx] } else { fmt.Println("Image not RGBA at location: ./") os.Exit(-1) } return 0 }
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 }
// LoadDictionary reads a gobbed Dictionary object from r, registers its atlas texture with opengl, // and returns a Dictionary that is ready to render text. func LoadDictionary(r io.Reader) (*Dictionary, error) { errChan := make(chan error) initOnce.Do(func() { render.Queue(func() { // errChan <- render.RegisterShader("glop.font", []byte(font_vertex_shader), []byte(font_fragment_shader)) errChan <- render.RegisterShader("glop.font", []byte(font_vshader), []byte(font_fshader)) }) }) err := <-errChan if err != nil { return nil, err } var dict Dictionary dec := gob.NewDecoder(r) err = dec.Decode(&dict) if err != nil { return nil, err } render.Queue(func() { // Create the gl texture for the atlas gl.GenTextures(1, &dict.atlas.texture) glerr := gl.GetError() if glerr != 0 { errChan <- fmt.Errorf("Gl Error on gl.GenTextures: %v", glerr) return } // Send the atlas to opengl gl.BindTexture(gl.TEXTURE_2D, dict.atlas.texture) gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1) gl.TexImage2D( gl.TEXTURE_2D, 0, gl.RED, dict.Dx, dict.Dy, 0, gl.RED, gl.UNSIGNED_BYTE, gl.Ptr(&dict.Pix[0])) glerr = gl.GetError() if glerr != 0 { errChan <- fmt.Errorf("Gl Error on creating texture: %v", glerr) return } // Create the atlas sampler and set the parameters we want for it gl.GenSamplers(1, &dict.atlas.sampler) gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_MIN_FILTER, gl.LINEAR) gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_MAG_FILTER, gl.LINEAR) gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_WRAP_S, gl.REPEAT) gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_WRAP_T, gl.REPEAT) glerr = gl.GetError() if glerr != 0 { errChan <- fmt.Errorf("Gl Error on creating sampler: %v", glerr) return } errChan <- nil }) err = <-errChan if err != nil { return nil, err } return &dict, nil }
// 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 }