func programLoop(window *glfw.Window) {
// the linked shader program determines how the data will be rendered
shaders := compileShaders()
shaderProgram := linkShaders(shaders)
// VAO contains all the information about the data to be rendered
VAO := createTriangleVAO()
for !window.ShouldClose() {
// poll events and call their registered callbacks
glfw.PollEvents()
// perform rendering
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT)
// draw loop
gl.UseProgram(shaderProgram) // ensure the right shader program is being used
gl.BindVertexArray(VAO) // bind data
gl.DrawArrays(gl.TRIANGLES, 0, 3) // perform draw call
gl.BindVertexArray(0) // unbind data (so we don't mistakenly use/modify it)
// end of draw loop
// swap in the rendered buffer
window.SwapBuffers()
}
}
/*
* 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
}
// Render renders the model
func (m *Model) Render() {
gl.UseProgram(m.currentProgram)
gl.UniformMatrix4fv(m.modelUniform, 1, false, &m.model[0])
gl.BindVertexArray(m.vao)
gl.ActiveTexture(gl.TEXTURE0)
texture, isLoaded := m.textures.GetTexture(m.data.TextureFile)
if isLoaded {
gl.BindTexture(gl.TEXTURE_2D, texture)
} else {
if m.data.TextureFile != "" {
go fmt.Printf("Unable to load texture %s", m.data.TextureFile)
}
}
if m.data.Indexed {
gl.DrawElements(gl.TRIANGLE_FAN, int32(len(m.data.Indices)), gl.UNSIGNED_INT, gl.PtrOffset(0))
} else {
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(m.data.Verts))/m.data.VertSize)
}
gl.BindVertexArray(0)
}
/*
* 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
}
// 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 (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
}
func (me *GlObj) Draw(c *Core) {
gl.UseProgram(c.Progs[me.Prog])
gl.BindVertexArray(c.Vao[me.Vao])
// shoud check if texture has been set for current object
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, c.Textures[me.Texture])
gl.DrawArrays(gl.TRIANGLES, 0, me.nbTriangles)
}
func (me *GlObj) Draw(c *Core) {
gl.UseProgram(c.Progs[me.Prog])
gl.BindVertexArray(c.Vao[me.Vao])
// shoud check if texture has been set for current object
// no need to be set again, if only one texture has been loaded
// already binded/actived in new texture
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, c.Textures[me.Texture])
gl.DrawArrays(gl.TRIANGLES, 0, me.nbTriangles)
}
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
}
func drawLoop(win *glfw.Window, vao uint32, shader uint32) {
for !win.ShouldClose() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.BindVertexArray(vao)
gl.UseProgram(shader)
gl.DrawArrays(gl.TRIANGLES, 0, 3)
glfw.PollEvents()
win.SwapBuffers()
}
}
func Run() {
if err := glfw.Init(); err != nil {
glog.Fatalln("failed to initialize glfw", err)
}
defer glfw.Terminate()
setupWindowOptions()
window, err := glfw.CreateWindow(WindowWidth, WindowHeight, "Game", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
//initilize Glow
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
fmt.Println("OpenGL version", version)
shaderSource, err := ReadShaders("colorShader")
if err != nil {
panic(err)
}
program, err := NewProgram(shaderSource)
if err != nil {
panic(err)
}
program.Use()
sprite := &SpriteComponent{-.5, -.5, 1, 1}
sprite.ReloadGraphics()
vertAttrib := uint32(gl.GetAttribLocation(program.program, CStr("vertPosition")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 0, gl.PtrOffset(0))
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)
program.Use()
gl.BindVertexArray(sprite.vaoID)
gl.DrawArrays(gl.TRIANGLES, 0, 2*3)
window.SwapBuffers()
glfw.PollEvents()
}
}
// 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
}
// 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 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
}
// Draw will draw the billvboard in the x,y and z
func (billboard *Billboard) Draw(x float32, y float32, z float32) {
model := mgl32.Translate3D(x, y, z)
if shader := shader.GetActive(); shader != nil {
gl.UniformMatrix4fv(shader.Model, 1, false, &model[0])
}
gl.BindVertexArray(billboard.vao)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, billboard.image)
gl.DrawArrays(gl.TRIANGLES, 0, 1*2*3)
}
// DrawFrame will draw the sprite in the x,y and z with the specified frame from a spritesheet
func (sprite *Sprite) DrawFrame(x float32, y float32, z float32, scale float32, frame int) {
model := mgl32.Translate3D(x, y, z)
model = model.Mul4(mgl32.Scale3D(scale, scale, 1))
// remember this is in radians!
// model = model.Mul4(mgl32.HomogRotate3D(mgl32.DegToRad(90), mgl32.Vec3{0, 0, 1}))
if shader := shader.GetActive(); shader != nil {
gl.UniformMatrix4fv(shader.Model, 1, false, &model[0])
}
gl.BindVertexArray(sprite.vao)
sprite.image.Bind()
gl.DrawArrays(gl.TRIANGLES, int32(frame*6), 6)
}
func (v *VBO) Load(verts *float32, vsize int, indices *uint32, isize int) {
// calculate the memory size of floats used to calculate total memory size of float arrays
var floatSize int = int(unsafe.Sizeof(float32(1.0)))
var intSize int = int(unsafe.Sizeof(uint32(1)))
gl.BindBuffer(gl.ARRAY_BUFFER, v.vboVerts)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, v.vboIndices)
// load our data up and bind it to the 'position' shader attribute
gl.BufferData(gl.ARRAY_BUFFER, floatSize*vsize, unsafe.Pointer(verts), gl.STATIC_DRAW)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, intSize*isize, unsafe.Pointer(indices), gl.STATIC_DRAW)
gl.VertexAttribPointer(gPosition_attr, 3, gl.FLOAT, false, 20, gl.PtrOffset(0))
gl.VertexAttribPointer(gUVs_attr, 2, gl.FLOAT, false, 20, gl.PtrOffset(12))
gl.BindBuffer(gl.ARRAY_BUFFER, 0)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
gl.BindVertexArray(0)
}
func programLoop(window *win.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/phong.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/phong.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
program, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer program.Delete()
lightFragShader, err := gfx.NewShaderFromFile("shaders/light.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
// special shader program so that lights themselves are not affected by lighting
lightProgram, err := gfx.NewProgram(vertShader, lightFragShader)
if err != nil {
return err
}
VAO := createVAO(cubeVertices, nil)
lightVAO := createVAO(cubeVertices, nil)
// ensure that triangles that are "behind" others do not draw over top of them
gl.Enable(gl.DEPTH_TEST)
camera := cam.NewFpsCamera(mgl32.Vec3{0, 0, 3}, mgl32.Vec3{0, 1, 0}, -90, 0, window.InputManager())
for !window.ShouldClose() {
// swaps in last buffer, polls for window events, and generally sets up for a new render frame
window.StartFrame()
// update camera position and direction from input evevnts
camera.Update(window.SinceLastFrame())
// background color
gl.ClearColor(0, 0, 0, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // depth buffer needed for DEPTH_TEST
// cube rotation matrices
rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-45 * float32(glfw.GetTime()))))
rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-45 * float32(glfw.GetTime()))))
rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-45 * float32(glfw.GetTime()))))
// creates perspective
fov := float32(60.0)
projectTransform := mgl32.Perspective(mgl32.DegToRad(fov),
float32(window.Width())/float32(window.Height()),
0.1,
100.0)
camTransform := camera.GetTransform()
lightPos := mgl32.Vec3{0.6, 1, 0.1}
lightTransform := mgl32.Translate3D(lightPos.X(), lightPos.Y(), lightPos.Z()).Mul4(
mgl32.Scale3D(0.2, 0.2, 0.2))
program.Use()
gl.UniformMatrix4fv(program.GetUniformLocation("view"), 1, false, &camTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false,
&projectTransform[0])
gl.BindVertexArray(VAO)
// draw each cube after all coordinate system transforms are bound
// obj is colored, light is white
gl.Uniform3f(program.GetUniformLocation("material.ambient"), 1.0, 0.5, 0.31)
gl.Uniform3f(program.GetUniformLocation("material.diffuse"), 1.0, 0.5, 0.31)
gl.Uniform3f(program.GetUniformLocation("material.specular"), 0.5, 0.5, 0.5)
gl.Uniform1f(program.GetUniformLocation("material.shininess"), 32.0)
lightColor := mgl32.Vec3{
float32(math.Sin(glfw.GetTime() * 1)),
float32(math.Sin(glfw.GetTime() * 0.35)),
float32(math.Sin(glfw.GetTime() * 0.65)),
}
diffuseColor := mgl32.Vec3{
0.5 * lightColor[0],
0.5 * lightColor[1],
0.5 * lightColor[2],
}
ambientColor := mgl32.Vec3{
0.2 * lightColor[0],
0.2 * lightColor[1],
0.2 * lightColor[2],
}
gl.Uniform3f(program.GetUniformLocation("light.ambient"),
ambientColor[0], ambientColor[1], ambientColor[2])
gl.Uniform3f(program.GetUniformLocation("light.diffuse"),
diffuseColor[0], diffuseColor[1], diffuseColor[2])
gl.Uniform3f(program.GetUniformLocation("light.specular"), 1.0, 1.0, 1.0)
gl.Uniform3f(program.GetUniformLocation("light.position"), lightPos.X(), lightPos.Y(), lightPos.Z())
for _, pos := range cubePositions {
// turn the cubes into rectangular prisms for more fun
worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2])
worldTransform := worldTranslate.Mul4(
rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4(),
)
gl.UniformMatrix4fv(program.GetUniformLocation("model"), 1, false,
&worldTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
}
gl.BindVertexArray(0)
// Draw the light obj after the other boxes using its separate shader program
// this means that we must re-bind any uniforms
lightProgram.Use()
gl.BindVertexArray(lightVAO)
gl.UniformMatrix4fv(lightProgram.GetUniformLocation("model"), 1, false, &lightTransform[0])
gl.UniformMatrix4fv(lightProgram.GetUniformLocation("view"), 1, false, &camTransform[0])
gl.UniformMatrix4fv(lightProgram.GetUniformLocation("project"), 1, false, &projectTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
gl.BindVertexArray(0)
// end of draw loop
}
return nil
}
func programLoop(window *glfw.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
program, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer program.Delete()
vertices := []float32{
// position // texture position
-0.5, -0.5, -0.5, 0.0, 0.0,
0.5, -0.5, -0.5, 1.0, 0.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, 0.5, -0.5, 1.0, 1.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 0.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 1.0,
0.5, 0.5, 0.5, 1.0, 1.0,
-0.5, 0.5, 0.5, 0.0, 1.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, 0.5, -0.5, 1.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, 0.5, 0.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, -0.5, 1.0, 1.0,
0.5, -0.5, 0.5, 1.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, 0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
}
indices := []uint32{}
VAO := createVAO(vertices, indices)
texture0, err := gfx.NewTextureFromFile("../images/RTS_Crate.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
texture1, err := gfx.NewTextureFromFile("../images/trollface-transparent.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
cubePositions := [][]float32{
[]float32{0.0, 0.0, -3.0},
[]float32{2.0, 5.0, -15.0},
[]float32{-1.5, -2.2, -2.5},
[]float32{-3.8, -2.0, -12.3},
[]float32{2.4, -0.4, -3.5},
[]float32{-1.7, 3.0, -7.5},
[]float32{1.3, -2.0, -2.5},
[]float32{1.5, 2.0, -2.5},
[]float32{1.5, 0.2, -1.5},
[]float32{-1.3, 1.0, -1.5},
}
gl.Enable(gl.DEPTH_TEST)
for !window.ShouldClose() {
// poll events and call their registered callbacks
glfw.PollEvents()
// background color
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// draw vertices
program.Use()
// set texture0 to uniform0 in the fragment shader
texture0.Bind(gl.TEXTURE0)
texture0.SetUniform(program.GetUniformLocation("ourTexture0"))
// set texture1 to uniform1 in the fragment shader
texture1.Bind(gl.TEXTURE1)
texture1.SetUniform(program.GetUniformLocation("ourTexture1"))
// update shader transform matrices
// Create transformation matrices
rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
viewTransform := mgl32.Translate3D(0, 0, -3)
projectTransform := mgl32.Perspective(mgl32.DegToRad(60), windowWidth/windowHeight, 0.1, 100.0)
gl.UniformMatrix4fv(program.GetUniformLocation("view"), 1, false,
&viewTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false,
&projectTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateX"), 1, false,
&rotateX[0])
gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateY"), 1, false,
&rotateY[0])
gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateZ"), 1, false,
&rotateZ[0])
gl.BindVertexArray(VAO)
for _, pos := range cubePositions {
worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2])
worldTransform := (worldTranslate.Mul4(rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4()))
gl.UniformMatrix4fv(program.GetUniformLocation("world"), 1, false,
&worldTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
}
// gl.DrawElements(gl.TRIANGLES, 36, gl.UNSIGNED_INT, unsafe.Pointer(nil))
gl.BindVertexArray(0)
texture0.UnBind()
texture1.UnBind()
// end of draw loop
// swap in the rendered buffer
window.SwapBuffers()
}
return nil
}
func programLoop(window *glfw.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
shaderProgram, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer shaderProgram.Delete()
vertices := []float32{
// top left
-0.75, 0.75, 0.0, // position
1.0, 0.0, 0.0, // Color
1.0, 0.0, // texture coordinates
// top right
0.75, 0.75, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0,
// bottom right
0.75, -0.75, 0.0,
0.0, 0.0, 1.0,
0.0, 1.0,
// bottom left
-0.75, -0.75, 0.0,
1.0, 1.0, 1.0,
1.0, 1.0,
}
indices := []uint32{
// rectangle
0, 1, 2, // top triangle
0, 2, 3, // bottom triangle
}
VAO := createVAO(vertices, indices)
texture0, err := gfx.NewTextureFromFile("../images/RTS_Crate.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
texture1, err := gfx.NewTextureFromFile("../images/trollface.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
for !window.ShouldClose() {
// poll events and call their registered callbacks
glfw.PollEvents()
// background color
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT)
// draw vertices
shaderProgram.Use()
// set texture0 to uniform0 in the fragment shader
texture0.Bind(gl.TEXTURE0)
texture0.SetUniform(shaderProgram.GetUniformLocation("ourTexture0"))
// set texture1 to uniform1 in the fragment shader
texture1.Bind(gl.TEXTURE1)
texture1.SetUniform(shaderProgram.GetUniformLocation("ourTexture1"))
gl.BindVertexArray(VAO)
gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, unsafe.Pointer(nil))
gl.BindVertexArray(0)
texture0.UnBind()
texture1.UnBind()
// end of draw loop
// swap in the rendered buffer
window.SwapBuffers()
}
return nil
}
func programLoop(window *win.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
program, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer program.Delete()
VAO := createVAO(cubeVertices, nil)
texture0, err := gfx.NewTextureFromFile("../images/RTS_Crate.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
texture1, err := gfx.NewTextureFromFile("../images/trollface-transparent.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
// ensure that triangles that are "behind" others do not draw over top of them
gl.Enable(gl.DEPTH_TEST)
camera := cam.NewFpsCamera(mgl32.Vec3{0, 0, 3}, mgl32.Vec3{0, 1, 0}, -90, 0, window.InputManager())
for !window.ShouldClose() {
// swaps in last buffer, polls for window events, and generally sets up for a new render frame
window.StartFrame()
// update camera position and direction from input evevnts
camera.Update(window.SinceLastFrame())
// background color
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // depth buffer needed for DEPTH_TEST
program.Use()
// bind textures
texture0.Bind(gl.TEXTURE0)
texture0.SetUniform(program.GetUniformLocation("ourTexture0"))
texture1.Bind(gl.TEXTURE1)
texture1.SetUniform(program.GetUniformLocation("ourTexture1"))
// cube rotation matrices
rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
// creates perspective
fov := float32(60.0)
projectTransform := mgl32.Perspective(mgl32.DegToRad(fov),
float32(window.Width())/float32(window.Height()),
0.1,
100.0)
camTransform := camera.GetTransform()
gl.UniformMatrix4fv(program.GetUniformLocation("camera"), 1, false, &camTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false,
&projectTransform[0])
gl.BindVertexArray(VAO)
// draw each cube after all coordinate system transforms are bound
for _, pos := range cubePositions {
worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2])
worldTransform := (worldTranslate.Mul4(rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4()))
gl.UniformMatrix4fv(program.GetUniformLocation("world"), 1, false,
&worldTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
}
gl.BindVertexArray(0)
texture0.UnBind()
texture1.UnBind()
// end of draw loop
}
return nil
}
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
}
func (v *VBO) Unbind() {
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
gl.DisableVertexAttribArray(gPosition_attr)
gl.DisableVertexAttribArray(gUVs_attr)
gl.BindVertexArray(0)
}
func (v *VBO) Bind() {
gl.BindVertexArray(v.vao)
gl.EnableVertexAttribArray(gPosition_attr)
gl.EnableVertexAttribArray(gUVs_attr)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, v.vboIndices)
}
func programLoop(window *glfw.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
shaderProgram, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer shaderProgram.Delete()
vertices := []float32{
// top
0.0, 0.5, 0.0, // position
1.0, 0.0, 0.0, // Color
// bottom right
0.5, -0.5, 0.0,
0.0, 1.0, 0.0,
// bottom left
-0.5, -0.5, 0.0,
0.0, 0.0, 1.0,
}
indices := []uint32{
0, 1, 2, // only triangle
}
VAO := createTriangleVAO(vertices, indices)
for !window.ShouldClose() {
// poll events and call their registered callbacks
glfw.PollEvents()
// perform rendering
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT)
// draw loop
// draw triangle
shaderProgram.Use()
gl.BindVertexArray(VAO)
gl.DrawElements(gl.TRIANGLES, 3, gl.UNSIGNED_INT, unsafe.Pointer(nil))
gl.BindVertexArray(0)
// end of draw loop
// swap in the rendered buffer
window.SwapBuffers()
}
return nil
}
func programLoop(window *glfw.Window) {
// the linked shader program determines how the data will be rendered
vertexShader := compileShader(vertexShaderSource, gl.VERTEX_SHADER)
fragmentShaderBlue := compileShader(fragmentShaderBlueSource, gl.FRAGMENT_SHADER)
shaderProgramBlue := linkShaders([]uint32{vertexShader, fragmentShaderBlue})
fragmentShaderRed := compileShader(fragmentShaderRedSource, gl.FRAGMENT_SHADER)
shaderProgramRed := linkShaders([]uint32{vertexShader, fragmentShaderRed})
// shader objects are not needed after they are linked into a program object
gl.DeleteShader(vertexShader)
gl.DeleteShader(fragmentShaderBlue)
gl.DeleteShader(fragmentShaderRed)
vertices1 := []float32{
0.2, 0.2, 0.0, // top right
0.2, -0.8, 0.0, // bottom right
-0.8, -0.8, 0.0, // bottom left
-0.8, 0.2, 0.0, // top left
}
indices1 := []uint32{
0, 1, 3, // first triangle
1, 2, 3, // second triangle
}
VAO1 := createTriangleVAO(vertices1, indices1)
vertices2 := []float32{
0.2, 0.6, 0.0, // top
0.6, -0.2, 0.0, // bottom right
-0.2, -0.2, 0.0, // bottom left
}
indices2 := []uint32{
0, 1, 2, // only triangle
}
VAO2 := createTriangleVAO(vertices2, indices2)
for !window.ShouldClose() {
// poll events and call their registered callbacks
glfw.PollEvents()
// perform rendering
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT)
// draw loop
// draw rectangle
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
gl.UseProgram(shaderProgramRed)
gl.BindVertexArray(VAO1)
gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, unsafe.Pointer(nil))
gl.BindVertexArray(0)
// draw triangle
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
gl.UseProgram(shaderProgramBlue)
gl.BindVertexArray(VAO2)
gl.DrawElements(gl.TRIANGLES, 3, gl.UNSIGNED_INT, unsafe.Pointer(nil))
gl.BindVertexArray(0)
// end of draw loop
// swap in the rendered buffer
window.SwapBuffers()
}
}
func (vao *VertexArray) Bind() {
gl.BindVertexArray(vao.Id)
}
