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 Draw() {
// if len(layers) == 0 {
// fmt.Println("layers empty!!!")
// return
// }
// for _, layer := range layers {
// vertexData := textureHash[layer]
vertexData := &vertexDataTest
// check to see if there are any vertices at all to draw
if len(vertexData.vertexData) == 0 {
return
}
// vertexData.Print()
// vertexData := vertexDataTest
//vertexData.Print()
// BindBuffers(vertexData)
// vertexData.Print()
//gl.BufferSubData(gl.ARRAY_BUFFER, 0, len(vertexData.VertexData)*4, gl.Ptr(vertexData.VertexData))
// gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(vertexData.vertexData)*4, gl.Ptr(vertexData.vertexData), gl.DYNAMIC_DRAW)
// gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementvbo)
// gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertexData.Elements)*4, gl.Ptr(vertexData.Elements), gl.DYNAMIC_DRAW)
MVP := projectionM.Mul4(viewM) //.Mul4(Model)
gl.UniformMatrix4fv(MVPid, 1, false, &MVP[0])
lightPos := mathgl.Vec3{0, 3, 10}
lightintensities := mathgl.Vec3{1, .4, .2}
gl.Uniform3f(lightpositionID, lightPos[0], lightPos[1], lightPos[2])
gl.Uniform3f(lightintensitiesID, lightintensities[0], lightintensities[1], lightintensities[2])
gl.Uniform3f(cameraPositionID, 0.0, 1.0, -1.0)
// vertexData.Print()
// gl.DrawElements(gl.TRIANGLES, int32(len(vertexData.Elements)), gl.UNSIGNED_INT, nil)
// }
numTriVerts := int32((len(vertexData.vertexData) / (int(NUM_ATTRIBUTES) * 2)) * 3)
gl.DrawArrays(gl.TRIANGLES, 0, numTriVerts)
ClearVertexData()
}
// RenderString must be called on the render thread. x and y are the initial position of the pen,
// in screen coordinates, and height is the height of a full line of text, in screen coordinates.
func (d *Dictionary) RenderString(str string, x, y, height float64) {
if str == "" {
return
}
// No synchronization necessary because everything is run serially on the render thread anyway.
if d.strs == nil {
d.strs = make(map[string]strData)
}
data, ok := d.strs[str]
if !ok {
data = d.bindString(str)
d.strs[str] = data
}
render.EnableShader("glop.font")
defer render.EnableShader("")
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, d.atlas.texture)
location, _ := render.GetUniformLocation("glop.font", "tex")
gl.Uniform1i(location, 0)
gl.BindSampler(0, d.atlas.sampler)
location, _ = render.GetUniformLocation("glop.font", "height")
gl.Uniform1f(location, float32(height))
var viewport [4]int32
gl.GetIntegerv(gl.VIEWPORT, &viewport[0])
location, _ = render.GetUniformLocation("glop.font", "screen")
gl.Uniform2f(location, float32(viewport[2]), float32(viewport[3]))
location, _ = render.GetUniformLocation("glop.font", "pen")
gl.Uniform2f(location, float32(x)+float32(viewport[0]), float32(y)+float32(viewport[1]))
location, _ = render.GetUniformLocation("glop.font", "textColor")
gl.Uniform3f(location, d.color[0], d.color[1], d.color[2])
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.BindVertexArray(data.varrays[0])
gl.DrawArrays(gl.TRIANGLES, 0, data.count)
}
func (r *EffectsRenderer) Draw() (err error) {
gl.UseProgram(r.shader)
gl.Uniform1i(r.textureUnitLoc, 0)
gl.Uniform3f(r.colorLoc, r.Color[0], r.Color[1], r.Color[2])
gl.BindBuffer(gl.ARRAY_BUFFER, r.coords)
gl.EnableVertexAttribArray(r.positionLoc)
gl.VertexAttribPointer(r.positionLoc, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0))
gl.EnableVertexAttribArray(r.textureLoc)
gl.VertexAttribPointer(r.textureLoc, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4))
gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
gl.Viewport(0, 0, int32(r.oldwidth), int32(r.oldheight))
gl.BlendFunc(gl.ONE, gl.ONE)
gl.BindTexture(gl.TEXTURE_2D, r.texture)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4)
gl.BindBuffer(gl.ARRAY_BUFFER, 0)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
return nil
}
func main() {
vertices, normals := obj.Parse(os.Args[1])
// initialize GLFW
if err := glfw.Init(); err != nil {
panic(err)
}
defer glfw.Terminate()
// set opengl core profile 3.3
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(640, 480, "GOpenGL", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
// initialise OpenGL library
if err := gl.Init(); err != nil {
panic(err)
}
// link program from shaders
program, err := newProgram("vertex.glsl", "fragment.glsl")
if err != nil {
panic(err)
}
gl.UseProgram(program)
// vertex attribute object holds links between attributes and vbo
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
// vertex buffer with per-vertex data
var vbo [2]uint32
gl.GenBuffers(2, &vbo[0])
// position data
gl.BindBuffer(gl.ARRAY_BUFFER, vbo[0])
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
// set up position attribute with layout of vertices
posAttrib := uint32(gl.GetAttribLocation(program, gl.Str("position\x00")))
gl.VertexAttribPointer(posAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0))
gl.EnableVertexAttribArray(posAttrib)
// normal data
gl.BindBuffer(gl.ARRAY_BUFFER, vbo[1])
gl.BufferData(gl.ARRAY_BUFFER, len(normals)*4, gl.Ptr(normals), gl.STATIC_DRAW)
normAttrib := uint32(gl.GetAttribLocation(program, gl.Str("normal\x00")))
gl.VertexAttribPointer(normAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0))
gl.EnableVertexAttribArray(normAttrib)
uniModel := gl.GetUniformLocation(program, gl.Str("model\x00"))
uniView := gl.GetUniformLocation(program, gl.Str("view\x00"))
uniProj := gl.GetUniformLocation(program, gl.Str("proj\x00"))
matView := mgl32.LookAt(2.0, 2.0, 2.0,
0.0, 0.0, 0.0,
0.0, 0.0, 1.0)
gl.UniformMatrix4fv(uniView, 1, false, &matView[0])
matProj := mgl32.Perspective(mgl32.DegToRad(45.0), 640.0/480.0, 1.0, 10.0)
gl.UniformMatrix4fv(uniProj, 1, false, &matProj[0])
uniLightDir := gl.GetUniformLocation(program, gl.Str("lightDir\x00"))
uniLightCol := gl.GetUniformLocation(program, gl.Str("lightCol\x00"))
gl.Uniform3f(uniLightDir, -0.5, 0.0, -1.0)
gl.Uniform3f(uniLightCol, 0.0, 0.5, 0.5)
startTime := glfw.GetTime()
gl.Enable(gl.DEPTH_TEST)
gl.ClearColor(1.0, 1.0, 1.0, 1.0)
for !window.ShouldClose() {
// clear buffer
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
matRot := mgl32.HomogRotate3DZ(float32(glfw.GetTime() - startTime))
gl.UniformMatrix4fv(uniModel, 1, false, &matRot[0])
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(vertices)))
window.SwapBuffers()
glfw.PollEvents()
}
}
func (r *Renderable) Draw(perspective mgl.Mat4, view mgl.Mat4) {
gl.UseProgram(r.Shader)
gl.BindVertexArray(r.Vao)
model := r.GetTransformMat4()
var mvp mgl.Mat4
shaderMvp := getUniformLocation(r.Shader, "MVP_MATRIX")
if shaderMvp >= 0 {
mvp = perspective.Mul4(view).Mul4(model)
gl.UniformMatrix4fv(shaderMvp, 1, false, &mvp[0])
}
shaderMv := getUniformLocation(r.Shader, "MV_MATRIX")
if shaderMv >= 0 {
mv := view.Mul4(model)
gl.UniformMatrix4fv(shaderMv, 1, false, &mv[0])
}
shaderTex0 := getUniformLocation(r.Shader, "DIFFUSE_TEX")
if shaderTex0 >= 0 {
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, r.Tex0)
gl.Uniform1i(shaderTex0, 0)
}
shaderColor := getUniformLocation(r.Shader, "MATERIAL_DIFFUSE")
if shaderColor >= 0 {
gl.Uniform4f(shaderColor, r.Color[0], r.Color[1], r.Color[2], r.Color[3])
}
shaderTex1 := getUniformLocation(r.Shader, "MATERIAL_TEX_0")
if shaderTex1 >= 0 {
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, r.Tex0)
gl.Uniform1i(shaderTex1, 0)
}
shaderCameraWorldPos := getUniformLocation(r.Shader, "CAMERA_WORLD_POSITION")
if shaderCameraWorldPos >= 0 {
gl.Uniform3f(shaderCameraWorldPos, -view[12], -view[13], -view[14])
}
shaderPosition := getAttribLocation(r.Shader, "VERTEX_POSITION")
if shaderPosition >= 0 {
gl.BindBuffer(gl.ARRAY_BUFFER, r.VertVBO)
gl.EnableVertexAttribArray(uint32(shaderPosition))
gl.VertexAttribPointer(uint32(shaderPosition), 3, gl.FLOAT, false, 0, gl.PtrOffset(0))
}
shaderNormal := getAttribLocation(r.Shader, "VERTEX_NORMAL")
if shaderNormal >= 0 {
gl.BindBuffer(gl.ARRAY_BUFFER, r.NormsVBO)
gl.EnableVertexAttribArray(uint32(shaderNormal))
gl.VertexAttribPointer(uint32(shaderNormal), 3, gl.FLOAT, false, 0, gl.PtrOffset(0))
}
shaderVertUv := getAttribLocation(r.Shader, "VERTEX_UV_0")
if shaderVertUv >= 0 {
gl.BindBuffer(gl.ARRAY_BUFFER, r.UvVBO)
gl.EnableVertexAttribArray(uint32(shaderVertUv))
gl.VertexAttribPointer(uint32(shaderVertUv), 2, gl.FLOAT, false, 0, gl.PtrOffset(0))
}
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.ElementsVBO)
gl.DrawElements(gl.TRIANGLES, int32(r.FaceCount*3), gl.UNSIGNED_INT, gl.PtrOffset(0))
gl.BindVertexArray(0)
}
