func CreateVertexArray() *VertexArray { vao := &VertexArray{ Type: gl.TRIANGLES, } gl.GenVertexArrays(1, &vao.Id) return vao }
/* * Creates the Vertex Array Object for a triangle. * indices is leftover from earlier samples and not used here. */ func createVAO(vertices []float32, indices []uint32) uint32 { var VAO uint32 gl.GenVertexArrays(1, &VAO) var VBO uint32 gl.GenBuffers(1, &VBO) var EBO uint32 gl.GenBuffers(1, &EBO) // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointers() gl.BindVertexArray(VAO) // copy vertices data into VBO (it needs to be bound first) gl.BindBuffer(gl.ARRAY_BUFFER, VBO) gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) // size of one whole vertex (sum of attrib sizes) var stride int32 = 3*4 + 2*4 var offset int = 0 // position gl.VertexAttribPointer(0, 3, gl.FLOAT, false, stride, gl.PtrOffset(offset)) gl.EnableVertexAttribArray(0) offset += 3 * 4 // unbind the VAO (safe practice so we don't accidentally (mis)configure it later) gl.BindVertexArray(0) return VAO }
/* * Creates the Vertex Array Object for a triangle. */ func createTriangleVAO() uint32 { vertices := []float32{ -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0, } var VAO uint32 gl.GenVertexArrays(1, &VAO) var VBO uint32 gl.GenBuffers(1, &VBO) // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointers() gl.BindVertexArray(VAO) // copy vertices data into VBO (it needs to be bound first) gl.BindBuffer(gl.ARRAY_BUFFER, VBO) gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) // specify the format of our vertex input // (shader) input 0 // vertex has size 3 // vertex items are of type FLOAT // do not normalize (already done) // stride of 3 * sizeof(float) (separation of vertices) // offset of where the position data starts (0 for the beginning) gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0)) gl.EnableVertexAttribArray(0) // unbind the VAO (safe practice so we don't accidentally (mis)configure it later) gl.BindVertexArray(0) return VAO }
/* * Creates the Vertex Array Object for a triangle. */ func createTriangleVAO(vertices []float32, indices []uint32) uint32 { var VAO uint32 gl.GenVertexArrays(1, &VAO) var VBO uint32 gl.GenBuffers(1, &VBO) var EBO uint32 gl.GenBuffers(1, &EBO) // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointers() gl.BindVertexArray(VAO) // copy vertices data into VBO (it needs to be bound first) gl.BindBuffer(gl.ARRAY_BUFFER, VBO) gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) // copy indices into element buffer gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, EBO) gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(indices)*4, gl.Ptr(indices), gl.STATIC_DRAW) // position gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 6*4, gl.PtrOffset(0)) gl.EnableVertexAttribArray(0) // color gl.VertexAttribPointer(1, 3, gl.FLOAT, false, 6*4, gl.PtrOffset(3*4)) gl.EnableVertexAttribArray(1) // unbind the VAO (safe practice so we don't accidentally (mis)configure it later) gl.BindVertexArray(0) return VAO }
func (self *Application) setup() error { gl.GenVertexArrays(1, &self.Triangles) gl.BindVertexArray(self.Triangles) trianglesVertices := []float32{ -0.9, -0.9, 0.85, -0.9, -0.9, 0.85, 0.9, -0.85, 0.9, 0.9, -0.85, 0.9, } gl.GenBuffers(1, &self.ArrayBuffer) gl.BindBuffer(gl.ARRAY_BUFFER, self.ArrayBuffer) gl.BufferData(gl.ARRAY_BUFFER, len(trianglesVertices)*4, gl.Ptr(trianglesVertices), gl.STATIC_DRAW) program, err := util.LoadShaders([]util.ShaderInfo{ util.ShaderInfo{gl.VERTEX_SHADER, "triangles.vert"}, util.ShaderInfo{gl.FRAGMENT_SHADER, "triangles.frag"}, }) if err != nil { return err } gl.UseProgram(program) gl.VertexAttribPointer(vPosition, 2, gl.FLOAT, false, 0, gl.Ptr(nil)) gl.EnableVertexAttribArray(vPosition) return nil }
// 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 createVao() uint32 { var vbo = createVbo(getPoints()) var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) gl.EnableVertexAttribArray(0) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, nil) return vao }
// NewBillboard creates a 2D billboard for rendering func (font *Font) NewBillboard(text string, maxWidth int, maxHeight int, size float64, dpi float64, color color.Color) *Billboard { b := &Billboard{} b.texWidth = maxWidth b.texHeight = maxHeight image, renderedWidth, renderedHeight := font.createTexture(text, b.texWidth, b.texHeight, size, dpi, color) b.size = size b.dpi = dpi b.text = text b.font = font b.rgba = color b.Width = renderedWidth b.Height = renderedHeight var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) w := float32(maxWidth) h := float32(maxHeight) billboardVertices := []float32{ w, h, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, h, 0.0, 0.0, 1.0, w, h, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, w, 0.0, 0.0, 1.0, 0.0, } gl.BufferData(gl.ARRAY_BUFFER, len(billboardVertices)*4, gl.Ptr(billboardVertices), gl.STATIC_DRAW) vertAttrib := uint32(0) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0)) texCoordAttrib := uint32(1) gl.EnableVertexAttribArray(texCoordAttrib) gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4)) b.vao = vao b.image = image return b }
func NewVBO() (vbo *VBO) { // create and bind the required VAO object var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) // create a VBO to hold the vertex data var vboVerts uint32 var vboIndices uint32 gl.GenBuffers(1, &vboVerts) gl.GenBuffers(1, &vboIndices) vbo = &VBO{vao, vboVerts, vboIndices} return vbo }
// word only for small file func (me *Core) AddGlObj(buf []float32, size, stride int32) *GlObj { n := me.nbObj var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) me.Vao[n] = vao var obj GlObj obj.Vao = n obj.nbTriangles = int32(len(buf)) / stride obj.AddProperty(VertLoc, buf, size, stride, 0) me.nbObj++ return &obj }
// allow only basic obj, no text or effect for now func (me *Core) AddGlObj(buf []float32, size int32) *GlObj { n := me.nbObj var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) me.Vao[n] = vao var obj GlObj obj.Vao = n obj.nbTriangles = int32(len(buf)) / 3 // 3 will most probably change obj.AddProperty(0, buf, size) me.nbObj++ return &obj }
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() } }
func (sprite *Sprite) create(file string, width int, height int, frames int, framesPerLine int) error { image, err := texture.New(file) if err != nil { return err } var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) var vbo uint32 gl.GenBuffers(1, &vbo) gl.BindBuffer(gl.ARRAY_BUFFER, vbo) w := float32(width) h := float32(height) frameWidth := float32(width) / float32(image.Width) frameHeight := float32(height) / float32(image.Height) var spriteVertices []float32 if frames == 0 { spriteVertices = []float32{ w, h, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, h, 0.0, 0.0, 1.0, w, h, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, w, 0.0, 0.0, 1.0, 0.0, } } else { for i := 0; i < frames; i++ { frameX := float32(i%framesPerLine) * frameWidth frameY := float32(i/framesPerLine) * frameHeight frameW := frameWidth + frameX frameH := frameHeight + frameY spriteVertices = append(spriteVertices, []float32{ w, h, 0.0, frameW, frameH, 0.0, 0.0, 0.0, frameX, frameY, 0.0, h, 0.0, frameX, frameH, w, h, 0.0, frameW, frameH, 0.0, 0.0, 0.0, frameX, frameY, w, 0.0, 0.0, frameW, frameY, }...) } } gl.BufferData(gl.ARRAY_BUFFER, len(spriteVertices)*4, gl.Ptr(spriteVertices), gl.STATIC_DRAW) vertAttrib := uint32(0) gl.EnableVertexAttribArray(vertAttrib) gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0)) texCoordAttrib := uint32(1) gl.EnableVertexAttribArray(texCoordAttrib) gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4)) sprite.vao = vao sprite.image = image return nil }
//Start - func (glRenderer *OpenglRenderer) Start() { 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) if glRenderer.FullScreen { glRenderer.WindowWidth = glfw.GetPrimaryMonitor().GetVideoMode().Width } else if glRenderer.WindowWidth == 0 { glRenderer.WindowWidth = glfw.GetPrimaryMonitor().GetVideoMode().Width * 95 / 100 } if glRenderer.FullScreen { glRenderer.WindowHeight = glfw.GetPrimaryMonitor().GetVideoMode().Height } else if glRenderer.WindowHeight == 0 { glRenderer.WindowHeight = glfw.GetPrimaryMonitor().GetVideoMode().Height * 95 / 100 } var monitor *glfw.Monitor if glRenderer.FullScreen { monitor = glfw.GetPrimaryMonitor() } window, err := glfw.CreateWindow(glRenderer.WindowWidth, glRenderer.WindowHeight, glRenderer.WindowTitle, monitor, nil) if err != nil { panic(err) } window.MakeContextCurrent() glRenderer.Window = window // Initialize Glow if err := gl.Init(); err != nil { panic(err) } var vao uint32 gl.GenVertexArrays(1, &vao) gl.BindVertexArray(vao) gl.Enable(gl.TEXTURE_CUBE_MAP_SEAMLESS) gl.Enable(gl.BLEND) gl.DepthFunc(gl.LEQUAL) gl.CullFace(gl.BACK) glRenderer.initPostEffects() glRenderer.onInit() window.SetRefreshCallback(func(w *glfw.Window) { glRenderer.mainLoop() window.SwapBuffers() }) //Main loop for !window.ShouldClose() { glRenderer.mainLoop() window.SwapBuffers() glfw.PollEvents() } }