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()
}
}
