// Draws the sphere form the previously defined vertex and index buffers
func (sphere *Sphere) Draw() {
// Adds the Sphere Model to the Active Shader
sphere.ShaderManager.SetUniformMatrix4fv(sphere.ShaderManager.ActiveShader, "model", 1, false, &sphere.Model[0])
/* Draw the vertices as GL_POINTS */
gl.BindBuffer(gl.ARRAY_BUFFER, sphere.sphereBufferObject)
gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, nil)
gl.EnableVertexAttribArray(0)
/* Bind the sphere colours */
gl.BindBuffer(gl.ARRAY_BUFFER, sphere.sphereColours)
gl.VertexAttribPointer(1, 4, gl.FLOAT, false, 0, nil)
gl.EnableVertexAttribArray(1)
/* Bind the sphere normals */
gl.BindBuffer(gl.ARRAY_BUFFER, sphere.sphereNormals)
gl.VertexAttribPointer(2, 3, gl.FLOAT, false, 0, nil)
gl.EnableVertexAttribArray(2)
gl.PointSize(3.0)
// Enable this line to show model in wireframe
if sphere.DrawMode == DRAW_LINES {
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
} else {
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
}
if sphere.DrawMode == DRAW_POINTS {
gl.DrawArrays(gl.POINTS, 0, int32(sphere.numSphereVertices))
} else {
/* Bind the indexed vertex buffer */
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, sphere.elementBuffer)
/* Draw the north pole regions as a triangle */
gl.DrawElements(gl.TRIANGLE_FAN, int32(sphere.numLongs+2), gl.UNSIGNED_INT, nil)
/* Calculate offsets into the indexed array. Note that we multiply offsets by 4
because it is a memory offset the indices are type GLuint which is 4-bytes */
var lat_offset_jump int = int((sphere.numLongs * 2) + 2)
var lat_offset_start int = int(sphere.numLongs + 2)
var lat_offset_current int = lat_offset_start * 4
var i uint32
/* Draw the triangle strips of latitudes */
for i = 0; i < sphere.numLats-2; i++ {
gl.DrawElements(gl.TRIANGLE_STRIP, int32(sphere.numLongs*2+2), gl.UNSIGNED_INT, gl.PtrOffset(lat_offset_current))
lat_offset_current += (lat_offset_jump * 4)
}
/* Draw the south pole as a triangle fan */
gl.DrawElements(gl.TRIANGLE_FAN, int32(sphere.numLongs+2), gl.UNSIGNED_INT, gl.PtrOffset(lat_offset_current))
}
}
func render(w *glfw.Window, r *gResources) {
/*
width, height := w.GetFramebufferSize()
gl.Viewport(0, 0, int32(width), int32(height))
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
*/
////////////////
gl.UseProgram(r.program)
gl.Uniform1f(r.uniforms.fadeFactor, r.fadeFactor)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, r.textures[0])
gl.Uniform1i(r.uniforms.textures[0], 0)
gl.ActiveTexture(gl.TEXTURE1)
gl.BindTexture(gl.TEXTURE_2D, r.textures[1])
gl.Uniform1i(r.uniforms.textures[1], 1)
gl.BindBuffer(gl.ARRAY_BUFFER, r.vertexBuffer)
gl.VertexAttribPointer(
uint32(r.attributes.position), /* attribute */
2, /* size */
gl.FLOAT, /* type */
false, /* normalized? */
8, /* stride */
gl.PtrOffset(0)) /* array buffer offset */
gl.EnableVertexAttribArray(uint32(r.attributes.position))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.elementBuffer)
gl.DrawElements(
gl.TRIANGLE_STRIP, /* mode */
4, /* count */
gl.UNSIGNED_INT, /* type */
gl.PtrOffset(0)) /* element array buffer offset */
gl.DisableVertexAttribArray(uint32(r.attributes.position))
}
func (glr *GlRenderer) initScreen() {
var err error
glr.program, err = createScreenShader()
if err != nil {
panic(err)
}
gl.UseProgram(glr.program)
projection := mgl32.Ortho2D(-1, 1, 1, -1)
projectionUniform := gl.GetUniformLocation(glr.program, gl.Str("projection\x00"))
gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0])
textureUniform := gl.GetUniformLocation(glr.program, gl.Str("tex\x00"))
gl.Uniform1i(textureUniform, 0)
glr.texture = createScreenTexture(glr.width, glr.height)
gl.GenVertexArrays(1, &glr.vao)
gl.BindVertexArray(glr.vao)
var quadVertices = []float32{
// X, Y, Z, U, V
1.0, -1.0, 0.0, 1.0, 0.0,
-1.0, -1.0, 0.0, 0.0, 0.0,
1.0, 1.0, 0.0, 1.0, 1.0,
-1.0, -1.0, 0.0, 0.0, 0.0,
-1.0, 1.0, 0.0, 0.0, 1.0,
1.0, 1.0, 0.0, 1.0, 1.0,
}
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(quadVertices)*4, gl.Ptr(quadVertices), gl.STATIC_DRAW)
vertAttrib := uint32(gl.GetAttribLocation(glr.program, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0))
texCoordAttrib := uint32(gl.GetAttribLocation(glr.program, gl.Str("vertTexCoord\x00")))
gl.EnableVertexAttribArray(texCoordAttrib)
gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4))
gl.Enable(gl.DEPTH_TEST)
gl.ClearColor(1.0, 1.0, 1.0, 1.0)
}
func CreateMesh(verticies []float32, texturePaths []string, shader *Shader) (*Mesh, error) {
modelView := mgl32.Ident4()
// // Load the texture
textures := make([]uint32, 0)
// fmt.Println(texturePaths)
for _, texturePath := range texturePaths {
// fmt.Println("Paths", texturePath, texturePaths[i])
texture, err := createTexture(texturePath)
if err != nil {
return nil, err
}
textures = append(textures, texture)
}
//
// // 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(verticies)*4, gl.Ptr(verticies), gl.STATIC_DRAW)
//
gl.EnableVertexAttribArray(shader.attributes["vert"])
gl.VertexAttribPointer(shader.attributes["vert"], 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0))
//
gl.EnableVertexAttribArray(shader.attributes["vertTexCoord"])
gl.VertexAttribPointer(shader.attributes["vertTexCoord"], 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4))
gl.BindVertexArray(0)
gl.BindBuffer(gl.ARRAY_BUFFER, 0)
return &Mesh{
modelView: modelView,
textures: textures,
verticies: verticies,
vao: vao,
vbo: vbo,
}, nil
}
// Draws the cog form the previously defined vertex and index buffers
func (cog *Cog) Draw() {
// Adds the Sphere Model to the Active Shader
cog.ShaderManager.SetUniformMatrix4fv(cog.ShaderManager.ActiveShader, "model", 1, false, &cog.Model[0])
/* Draw the vertices as GL_POINTS */
gl.BindBuffer(gl.ARRAY_BUFFER, cog.cogBufferObject)
gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, nil)
gl.EnableVertexAttribArray(0)
/* Bind the sphere colours */
gl.BindBuffer(gl.ARRAY_BUFFER, cog.cogColours)
gl.VertexAttribPointer(1, 4, gl.FLOAT, false, 0, nil)
gl.EnableVertexAttribArray(1)
/* Bind the sphere normals */
gl.BindBuffer(gl.ARRAY_BUFFER, cog.cogNormals)
gl.VertexAttribPointer(2, 3, gl.FLOAT, false, 0, nil)
gl.EnableVertexAttribArray(2)
gl.PointSize(3.0)
// Enable this line to show model in wireframe
if cog.DrawMode == DRAW_LINES {
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
} else {
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
}
if cog.DrawMode == DRAW_POINTS {
gl.DrawArrays(gl.POINTS, 0, int32(cog.numCogVertices))
} else {
// Bind the indexed vertex buffer
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, cog.elementBuffer)
// Draw the north pole regions as a triangle
gl.DrawElements(gl.TRIANGLE_FAN, int32(cog.VerticesPerDisk+2), gl.UNSIGNED_INT, nil)
// Calculate offsets into the indexed array. Note that we multiply offsets by 4
// because it is a memory offset the indices are type GLuint which is 4-bytes
var lat_offset_jump int = int((cog.VerticesPerDisk * 2) + 2)
var lat_offset_start int = int(cog.VerticesPerDisk + 2)
var lat_offset_current int = lat_offset_start * 4
// Draw the triangle strips of Sides
gl.DrawElements(gl.TRIANGLE_STRIP, int32(cog.VerticesPerDisk*2+2), gl.UNSIGNED_INT, gl.PtrOffset(lat_offset_current))
lat_offset_current += (lat_offset_jump * 4)
// Draw the south pole as a triangle fan
gl.DrawElements(gl.TRIANGLE_FAN, int32(cog.VerticesPerDisk+2), gl.UNSIGNED_INT, gl.PtrOffset(lat_offset_current))
}
}
func render(w *glfw.Window, r *gResources) {
width, height := w.GetFramebufferSize()
ratio := float32(width) / float32(height)
var xmul, ymul float32
if ratio > 1 {
xmul, ymul = ra/ratio, ra
} else {
xmul, ymul = ra, ra*ratio
}
d := time.Since(start).Seconds()
sin := float32(math.Sin(d))
cos := float32(math.Cos(d))
gl.Viewport(0, 0, int32(width), int32(height))
gl.Clear(gl.COLOR_BUFFER_BIT)
////////////////
// axes
gl.UseProgram(r.program1)
gl.BindBuffer(gl.ARRAY_BUFFER, r.vertexBuffer1)
gl.VertexAttribPointer(
uint32(r.attributes1.position), // attribute
2, // size
gl.FLOAT, // type
false, // normalized?
8, // stride
gl.PtrOffset(0)) // array buffer offset
gl.EnableVertexAttribArray(uint32(r.attributes1.position))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.elementBuffer1)
gl.LineWidth(1)
gl.DrawElements(
gl.LINES, // mode
4, // count
gl.UNSIGNED_INT, // type
gl.PtrOffset(0)) // element array buffer offset
gl.DisableVertexAttribArray(uint32(r.attributes1.position))
////////////////
// triangle
gl.UseProgram(r.program2)
gl.Uniform1f(r.uniforms2.xmul, xmul)
gl.Uniform1f(r.uniforms2.ymul, ymul)
gl.Uniform1f(r.uniforms2.sin, sin)
gl.Uniform1f(r.uniforms2.cos, cos)
gl.BindBuffer(gl.ARRAY_BUFFER, r.vertexBuffer2)
gl.VertexAttribPointer(
uint32(r.attributes2.position), // attribute
2, // size
gl.FLOAT, // type
false, // normalized?
8, // stride
gl.PtrOffset(0)) // array buffer offset
gl.EnableVertexAttribArray(uint32(r.attributes2.position))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.elementBuffer2)
gl.EnableVertexAttribArray(uint32(r.attributes2.color))
gl.BindBuffer(gl.ARRAY_BUFFER, r.colorBuffer2)
gl.VertexAttribPointer(
uint32(r.attributes2.color), // attribute
3, // size
gl.FLOAT, // type
false, // normalized?
0, // stride
gl.PtrOffset(0)) // array buffer offset
gl.DrawElements(
gl.TRIANGLES, // mode
3, // count
gl.UNSIGNED_INT, // type
gl.PtrOffset(0)) // element array buffer offset
////////////////
// circle
gl.BindBuffer(gl.ARRAY_BUFFER, r.vertexBuffer3)
gl.VertexAttribPointer(
uint32(r.attributes2.position), // attribute
2, // size
gl.FLOAT, // type
false, // normalized?
8, // stride
gl.PtrOffset(0)) // array buffer offset
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.elementBuffer3)
gl.BindBuffer(gl.ARRAY_BUFFER, r.colorBuffer3)
gl.VertexAttribPointer(
uint32(r.attributes2.color), // attribute
3, // size
gl.FLOAT, // type
false, // normalized?
0, // stride
gl.PtrOffset(0)) // array buffer offset
gl.LineWidth(5)
gl.DrawElements(
gl.LINE_LOOP, // mode
r.len3, // count
gl.UNSIGNED_INT, // type
gl.PtrOffset(0)) // element array buffer offset
gl.DisableVertexAttribArray(uint32(r.attributes2.color))
gl.DisableVertexAttribArray(uint32(r.attributes2.position))
}
/* Enable vertex attributes and draw object
Could improve efficiency by moving the vertex attribute pointer functions to the
create object but this method is more general
This code is almost untouched fomr the tutorial code except that I changed the
number of elements per vertex from 4 to 3*/
func (terrain *Terrain) DrawObject(shaderProgram uint32) {
toneUniform := gl.GetAttribLocation(shaderProgram, gl.Str("tone\x00"))
gl.Uniform4f(toneUniform, terrain.ColorTone.X(), terrain.ColorTone.Y(), terrain.ColorTone.Z(), terrain.ColorTone.W())
// gl.Uniform4f(toneUniform, 0.0, 1.0, 0.5, 1.0)
// gl.Uniform4fv(toneUniform, 1, &terrain.ColorTone[0])
// Reads the uniform Locations
modelUniform := gl.GetUniformLocation(shaderProgram, gl.Str("model\x00"))
// Send our uniforms variables to the currently bound shader
gl.UniformMatrix4fv(modelUniform, 1, false, &terrain.Model[0])
// Get the vertices uniform position
verticesUniform := uint32(gl.GetAttribLocation(shaderProgram, gl.Str("position\x00")))
normalsUniform := uint32(gl.GetAttribLocation(shaderProgram, gl.Str("normal\x00")))
colorsUniform := uint32(gl.GetAttribLocation(shaderProgram, gl.Str("colour\x00")))
// Describe our vertices array to OpenGL (it can't guess its format automatically)
gl.EnableVertexAttribArray(verticesUniform)
gl.BindBuffer(gl.ARRAY_BUFFER, terrain.VBOVertices)
gl.VertexAttribPointer(
verticesUniform, // attribute index
3, // number of elements per vertex, here (x,y,z)
gl.FLOAT, // the type of each element
false, // take our values as-is
0, // no extra data between each position
nil, // offset of first element
)
gl.EnableVertexAttribArray(normalsUniform)
gl.BindBuffer(gl.ARRAY_BUFFER, terrain.VBONormals)
gl.VertexAttribPointer(
normalsUniform, // attribute
3, // number of elements per vertex, here (x,y,z)
gl.FLOAT, // the type of each element
false, // take our values as-is
0, // no extra data between each position
nil, // offset of first element
)
gl.EnableVertexAttribArray(colorsUniform)
gl.BindBuffer(gl.ARRAY_BUFFER, terrain.VBOColors)
gl.VertexAttribPointer(
colorsUniform, // attribute
3, // number of elements per vertex, here (x,y,z)
gl.FLOAT, // the type of each element
false, // take our values as-is
0, // no extra data between each position
nil, // offset of first element
)
size := int32(len(terrain.Indices))
gl.PointSize(3.0)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, terrain.VBOIndices)
gl.GetBufferParameteriv(gl.ELEMENT_ARRAY_BUFFER, gl.BUFFER_SIZE, &size)
// Enable this line to show model in wireframe
switch terrain.DrawMode {
case 1:
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
case 2:
gl.DrawArrays(gl.POINTS, 0, int32(len(terrain.Vertices)))
// gl.DrawElements(gl.POINTS, int32(len(terrain.Indices)), gl.UNSIGNED_SHORT, nil)
return
default:
gl.PolygonMode(gl.FRONT_AND_BACK, gl.FILL)
}
var location int = 0
/* Draw the triangle strips */
for i := uint32(0); i < terrain.XSize-1; i++ {
location = SizeOfUint16 * int(i*terrain.ZSize*2)
gl.DrawElements(gl.TRIANGLE_STRIP, int32(terrain.ZSize*2), gl.UNSIGNED_SHORT, gl.PtrOffset(location))
}
// gl.DrawElements(
// gl.TRIANGLE_STRIP,
// len(terrain.Indices),
// gl.UNSIGNED_SHORT,
// nil,
// )
}