func EnableShader(name string) error {
if name == "" {
gl.UseProgram(0)
return nil
}
prog_obj, ok := shader_progs[name]
if !ok {
return fmt.Errorf("Tried to use unknown shader '%s'", name)
}
gl.UseProgram(prog_obj)
return nil
}
func (tr *TextRenderer) Bind() error {
gl.UseProgram(tr.Program)
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR: %X", e)
}
gl.Uniform1i(tr.TextureUnitLoc, 0)
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR: %X", e)
}
gl.BindBuffer(gl.ARRAY_BUFFER, tr.VBO)
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR: %X", e)
}
gl.EnableVertexAttribArray(tr.PositionLoc)
gl.VertexAttribPointer(tr.PositionLoc, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0))
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR: %X", e)
}
gl.EnableVertexAttribArray(tr.TextureLoc)
gl.VertexAttribPointer(tr.TextureLoc, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4))
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR: %X", e)
}
gl.UniformMatrix4fv(tr.ProjectionLoc, 1, false, &tr.Renderer.Camera.Projection[0])
if e := gl.GetError(); e != 0 {
return fmt.Errorf("ERROR: %X", e)
}
return nil
}
func (r *BatchRenderer) Bind() error {
gl.UseProgram(r.Program)
gl.ActiveTexture(gl.TEXTURE0)
gl.Uniform1i(r.TextureUnitLoc, 0)
gl.UniformMatrix4fv(r.ProjectionLoc, 1, false, &r.Camera.Projection[0])
return nil
}
// Rendering this LineRender.
func (lr *LineRender) Render() {
// Binding the appropriate information.
gl.BindVertexArray(lr.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, lr.vbo)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, lr.ebo)
gl.UseProgram(lr.shaderProgram)
// Loading up vertex attributes.
vertAttrib := uint32(gl.GetAttribLocation(lr.shaderProgram, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 2, gl.FLOAT, false, 2*4, gl.PtrOffset(0))
// Line thickness information.
gl.Uniform1f(
gl.GetUniformLocation(lr.shaderProgram, gl.Str("in_thickness\x00")),
lr.weight)
// Fragment shader color information.
gl.Uniform4f(
gl.GetUniformLocation(lr.shaderProgram, gl.Str("in_color\x00")),
lr.color.Red,
lr.color.Green,
lr.color.Blue,
lr.color.Alpha)
gl.BindFragDataLocation(lr.shaderProgram, 0, gl.Str("out_color\x00"))
// Performing the render.
gl.DrawElements(gl.LINE_STRIP, lr.points, gl.UNSIGNED_INT, nil)
}
func (r *GlowRenderer) Draw() (err error) {
gl.UseProgram(r.shader)
gl.Uniform1i(r.textureUnitLoc, 0)
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.Uniform1i(r.blurAmountLoc, int32(r.blur))
gl.Uniform1f(r.blurScaleLoc, r.scale)
gl.Uniform1f(r.blurStrengthLoc, r.strength)
gl.Uniform2f(r.bufferDimensionsLoc, float32(r.width), float32(r.height))
gl.BindFramebuffer(gl.FRAMEBUFFER, r.BlurFb)
gl.Viewport(0, 0, int32(r.width), int32(r.height))
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, r.GlowTex)
gl.Uniform1i(r.orientationLoc, 0)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 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.BlurTex)
gl.Uniform1i(r.orientationLoc, 1)
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 (t *Text) Draw() {
if t.IsDebug {
t.BoundingBox.Draw()
}
gl.UseProgram(t.font.program)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, t.font.textureID)
// uniforms
gl.Uniform1i(t.font.fragmentTextureUniform, 0)
gl.Uniform4fv(t.font.colorUniform, 1, &t.color[0])
gl.Uniform2fv(t.font.finalPositionUniform, 1, &t.finalPosition[0])
gl.UniformMatrix4fv(t.font.orthographicMatrixUniform, 1, false, &t.font.OrthographicMatrix[0])
gl.UniformMatrix4fv(t.font.scaleMatrixUniform, 1, false, &t.scaleMatrix[0])
// draw
drawCount := int32(t.RuneCount * 6)
if drawCount > int32(t.eboIndexCount) {
drawCount = int32(t.eboIndexCount)
}
if drawCount < 0 {
drawCount = 0
}
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.BindVertexArray(t.vao)
gl.DrawElements(gl.TRIANGLES, drawCount, gl.UNSIGNED_INT, nil)
gl.BindVertexArray(0)
gl.Disable(gl.BLEND)
}
func (b *BoundingBox) Draw() {
gl.UseProgram(b.program)
// uniforms
gl.Uniform2fv(b.finalPositionUniform, 1, &b.finalPosition[0])
gl.UniformMatrix4fv(b.orthographicMatrixUniform, 1, false, &b.font.OrthographicMatrix[0])
// draw
gl.BindVertexArray(b.vao)
gl.DrawElements(gl.TRIANGLES, int32(b.eboIndexCount), gl.UNSIGNED_INT, nil)
gl.BindVertexArray(0)
}
func (renderObject *RenderObject) Render() {
gl.BindVertexArray(renderObject.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, renderObject.vbo)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, renderObject.ebo)
gl.UseProgram(renderObject.shaderProgram)
// Binding the texture.
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, renderObject.texture)
gl.BindFragDataLocation(renderObject.shaderProgram, 0, gl.Str("outputColor\x00"))
// Drawing the object.
gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, nil)
}
func (c Context) DrawRectangle(x, y, w, h float32, color Color) {
gl.UseProgram(c.program)
model := mgl32.Translate3D(x, y, 0).Mul4(mgl32.Scale3D(w, h, 0))
modelUniform := gl.GetUniformLocation(c.program, gl.Str("model\x00"))
gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])
colorArray := []float32{color.B, color.G, color.R}
colorUniform := gl.GetUniformLocation(c.program, gl.Str("color\x00"))
gl.Uniform4fv(colorUniform, 1, &colorArray[0])
gl.DrawArrays(gl.TRIANGLES, 0, 6)
}
func (lr *LinesRenderer) Bind() (err error) {
gl.UseProgram(lr.program)
gl.BindBuffer(gl.ARRAY_BUFFER, lr.buffer)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, lr.indexBuffer)
gl.EnableVertexAttribArray(lr.positionLoc)
gl.EnableVertexAttribArray(lr.normalLoc)
gl.EnableVertexAttribArray(lr.miterLoc)
gl.VertexAttribPointer(lr.positionLoc, 2, gl.FLOAT, false, lr.stride, lr.offPosition)
gl.VertexAttribPointer(lr.normalLoc, 2, gl.FLOAT, false, lr.stride, lr.offNormal)
gl.VertexAttribPointer(lr.miterLoc, 1, gl.FLOAT, false, lr.stride, lr.offMiter)
gl.UniformMatrix4fv(lr.projectionLoc, 1, false, &lr.Renderer.Camera.Projection[0])
if e := gl.GetError(); e != 0 {
err = fmt.Errorf("ERROR: OpenGL error %X", e)
}
return
}
func CreateBuffers() {
var err error
program, err = MakeProgram(VertexShader(), FragmentShader())
// defer program.Delete()
if err != nil {
fmt.Println("Error loading shaders: " + err.Error())
panic("error loading shaders")
}
gl.BindFragDataLocation(program, 0, gl.Str("color\x00"))
MVPid = gl.GetUniformLocation(program, gl.Str("MVP\x00"))
lightpositionID = gl.GetUniformLocation(program, gl.Str("light.position\x00"))
lightintensitiesID = gl.GetUniformLocation(program, gl.Str("light.intensities\x00"))
lightattenuationID = gl.GetUniformLocation(program, gl.Str("light.attenuation\x00"))
lightambientCoeficientID = gl.GetUniformLocation(program, gl.Str("light.ambientCoeficient\x00"))
cameraPositionID = gl.GetUniformLocation(program, gl.Str("cameraPosition\x00"))
// View := mathgl.LookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
// viewM = View
gl.DepthFunc(gl.LEQUAL)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
// var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
// var vbo uint32
gl.GenBuffers(1, &vbo)
// gl.GenBuffers(1, &elementvbo)
// fmt.Println(program)
gl.UseProgram(program)
for idx, img := range aggregateImages {
bindAggregateImage(img, idx)
}
}
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 (p *Program) Bind() {
gl.BindVertexArray(p.vao)
gl.UseProgram(p.program)
}
func CreateContext(width, height int) Context {
vertexShader := `
#version 330
uniform mat4 projection;
uniform mat4 camera;
uniform mat4 model;
in vec3 vert;
void main() {
gl_Position = projection * camera * model * vec4(vert, 1);
}
` + "\x00"
fragmentShader := `
#version 330
uniform vec4 color;
out vec4 outputColor;
void main() {
outputColor = color;
}
` + "\x00"
vertices := []float32{
0.0, 0.0, 0.0,
1.0, 0.0, 0.0,
1.0, 1.0, 0.0,
1.0, 1.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 0.0,
}
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, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(width, height, "OpenGL", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
if err := gl.Init(); err != nil {
panic(err)
}
program, err := newProgram(vertexShader, fragmentShader)
if err != nil {
panic(err)
}
gl.UseProgram(program)
projection := mgl32.Ortho2D(0, 800, 0, 600)
projectionUniform := gl.GetUniformLocation(program, gl.Str("projection\x00"))
gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0])
camera := mgl32.LookAtV(mgl32.Vec3{0, 0, 0.5}, 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])
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(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0))
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
return Context{Window: window, program: program}
}
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 (shader MVCShader) Bind() {
gl.UseProgram(shader.Handle)
}
//Bind is the implementation of the opengl object interface. Makes this object current
//in the opengl state
func (shader BlankShader) Bind() {
gl.UseProgram(shader.Handle)
}
func main() {
// init glfw
if err := glfw.Init(); err != nil {
panic(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)
// make an application window
window, err := glfw.CreateWindow(windowWidth, windowHeight, "Hello", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
// init gl
if err := gl.Init(); err != nil {
panic(err)
}
fmt.Println("OpenGL version", gl.GoStr(gl.GetString(gl.VERSION)))
// create vertex & fragment shader
program, err := newProgram(vertexShader, fragmentShader)
if err != nil {
panic(err)
}
gl.UseProgram(program)
gl.BindFragDataLocation(program, 0, gl.Str("fc\x00"))
points := []float32{
-0.5, -0.5,
0.5, 0.5,
0.5, -0.5,
-0.5, 0.5,
}
vertices := []uint32{
0, 2, 1, 3,
}
// configure the vertex data
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
defer gl.BindVertexArray(0)
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(points)*4, gl.Ptr(points), gl.STATIC_DRAW)
var ibo uint32
gl.GenBuffers(1, &ibo)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("pv\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 2, gl.FLOAT, false, 2*4, gl.PtrOffset(0))
// global settings
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)
gl.UseProgram(program)
gl.BindVertexArray(vao)
gl.DrawElements(gl.LINE_LOOP, 4, gl.UNSIGNED_INT, gl.PtrOffset(0))
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)
}
func (tr *SpriteRenderer) Draw(instances []SpriteConfig) error {
var (
bytesNeeded int
byteoffset int
count int32
data unsafe.Pointer
float float32 = 0
floatSize uint32
i uint32
offset unsafe.Pointer
sprite SpriteConfig
stride int32
)
floatSize = uint32(unsafe.Sizeof(float))
stride = int32(unsafe.Sizeof(sprite))
gl.UseProgram(tr.program)
gl.Uniform1i(tr.textureUnitLoc, 0)
// Instance data binding
gl.BindBuffer(gl.ARRAY_BUFFER, tr.instanceVBO)
count = int32(len(instances))
bytesNeeded = int(stride * count)
data = gl.Ptr(instances)
if bytesNeeded > tr.instanceBytes {
gl.BufferData(gl.ARRAY_BUFFER, bytesNeeded, data, gl.STREAM_DRAW)
tr.instanceBytes = bytesNeeded
} else {
gl.BufferSubData(gl.ARRAY_BUFFER, 0, bytesNeeded, data)
}
gl.EnableVertexAttribArray(tr.translationLoc)
gl.VertexAttribPointer(tr.translationLoc, 3, gl.FLOAT, false, stride, tr.offAttrX)
gl.VertexAttribDivisor(tr.translationLoc, 1)
gl.EnableVertexAttribArray(tr.rotationLoc)
gl.VertexAttribPointer(tr.rotationLoc, 3, gl.FLOAT, false, stride, tr.offAttrRotationX)
gl.VertexAttribDivisor(tr.rotationLoc, 1)
gl.EnableVertexAttribArray(tr.scaleLoc)
gl.VertexAttribPointer(tr.scaleLoc, 3, gl.FLOAT, false, stride, tr.offAttrScaleX)
gl.VertexAttribDivisor(tr.scaleLoc, 1)
gl.EnableVertexAttribArray(tr.colorLoc)
gl.VertexAttribPointer(tr.colorLoc, 4, gl.FLOAT, false, stride, tr.offAttrColor)
gl.VertexAttribDivisor(tr.colorLoc, 1)
for i = 0; i < 4; i++ {
byteoffset = int(i * 4 * floatSize)
offset = gl.PtrOffset(tr.offAttrPointAdj + byteoffset)
gl.EnableVertexAttribArray(tr.pointAdjLoc + i)
gl.VertexAttribPointer(tr.pointAdjLoc+i, 4, gl.FLOAT, false, stride, offset)
gl.VertexAttribDivisor(tr.pointAdjLoc+i, 1)
offset = gl.PtrOffset(tr.offAttrTextureAdj + byteoffset)
gl.EnableVertexAttribArray(tr.textureAdjLoc + i)
gl.VertexAttribPointer(tr.textureAdjLoc+i, 4, gl.FLOAT, false, stride, offset)
gl.VertexAttribDivisor(tr.textureAdjLoc+i, 1)
}
// Projection
gl.UniformMatrix4fv(tr.projectionLoc, 1, false, &tr.Renderer.Camera.Projection[0])
// Actually draw.
gl.DrawArraysInstanced(gl.TRIANGLES, 0, 6, int32(len(instances)))
// Undo instance attr repetition.
gl.VertexAttribDivisor(tr.translationLoc, 0)
gl.VertexAttribDivisor(tr.rotationLoc, 0)
gl.VertexAttribDivisor(tr.scaleLoc, 0)
gl.VertexAttribDivisor(tr.colorLoc, 0)
for i = 0; i < 4; i++ {
gl.VertexAttribDivisor(tr.pointAdjLoc+i, 0)
gl.VertexAttribDivisor(tr.textureAdjLoc+i, 0)
}
gl.BindBuffer(gl.ARRAY_BUFFER, 0)
return nil
}
func Init() error {
if err := gl.Init(); err != nil {
return err
}
log.Printf("OpenGL version: %s", gl.GoStr(gl.GetString(gl.VERSION)))
vs, err := asset.String("shader.vert")
if err != nil {
return err
}
fs, err := asset.String("shader.frag")
if err != nil {
return err
}
program, err := createProgram(vs, fs)
if err != nil {
return err
}
gl.UseProgram(program)
var shaderErr error
uniform := func(name string) int32 {
var loc int32
loc, shaderErr = getUniformLocation(program, name)
return loc
}
projectionViewMatrixUniform = uniform("u_projectionViewMatrix")
modelMatrixUniform = uniform("u_modelMatrix")
normalMatrixUniform = uniform("u_normalMatrix")
ambientLightColorUniform = uniform("u_ambientLightColor")
directionalLightColorUniform = uniform("u_directionalLightColor")
directionalVectorUniform = uniform("u_directionalVector")
textureUniform = uniform("u_texture")
grayscaleUniform = uniform("u_grayscale")
brightnessUniform = uniform("u_brightness")
alphaUniform = uniform("u_alpha")
mixColorUniform = uniform("u_mixColor")
mixAmountUniform = uniform("u_mixAmount")
if shaderErr != nil {
return shaderErr
}
vm := newViewMatrix(cameraPosition, targetPosition, up)
nm := vm.inverse().transpose()
gl.UniformMatrix4fv(normalMatrixUniform, 1, false, &nm[0])
gl.Uniform3fv(ambientLightColorUniform, 1, &ambientLightColor[0])
gl.Uniform3fv(directionalLightColorUniform, 1, &directionalLightColor[0])
gl.Uniform3fv(directionalVectorUniform, 1, &directionalVector[0])
SizeCallback = func(width, height int) {
if winWidth == width && winHeight == height {
return
}
log.Printf("window size changed (%dx%d -> %dx%d)", int(winWidth), int(winHeight), width, height)
gl.Viewport(0, 0, int32(width), int32(height))
// Calculate new perspective projection view matrix.
winWidth, winHeight = width, height
fw, fh := float32(width), float32(height)
aspect := fw / fh
fovRadians := float32(math.Pi) / 3
perspectiveProjectionViewMatrix = vm.mult(newPerspectiveMatrix(fovRadians, aspect, 1, 2000))
// Calculate new ortho projection view matrix.
orthoProjectionViewMatrix = newOrthoMatrix(fw, fh, fw /* use width as depth */)
}
if err := initMeshes(); err != nil {
return err
}
if err := initTextures(); err != nil {
return err
}
gl.Enable(gl.CULL_FACE)
gl.CullFace(gl.BACK)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0, 0, 0, 0)
return nil
}
func main() {
// init glfw
if err := glfw.Init(); err != nil {
panic(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)
// make an application window
window, err := glfw.CreateWindow(windowWidth, windowHeight, "Transform", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
// init gl
if err := gl.Init(); err != nil {
panic(err)
}
fmt.Println("OpenGL version", gl.GoStr(gl.GetString(gl.VERSION)))
// create vertex & fragment shader
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])
gl.BindFragDataLocation(program, 0, gl.Str("vert\x00"))
points := []float32{
-0.9, -0.9, -0.9,
0.9, -0.9, -0.9,
0.9, -0.9, 0.9,
-0.9, -0.9, 0.9,
-0.9, 0.9, -0.9,
0.9, 0.9, -0.9,
0.9, 0.9, 0.9,
-0.9, 0.9, 0.9,
}
vertices := []uint32{
0, 1,
1, 2,
2, 3,
3, 0,
0, 4,
1, 5,
2, 6,
3, 7,
4, 5,
5, 6,
6, 7,
7, 4,
}
// configure the vertex data
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
defer gl.BindVertexArray(0)
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(points)*4, gl.Ptr(points), gl.STATIC_DRAW)
var ibo uint32
gl.GenBuffers(1, &ibo)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0))
// global settings
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
angleX := 0.0
angleY := 0.0
angleZ := 0.0
previousTime := glfw.GetTime()
for !window.ShouldClose() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
time := glfw.GetTime()
elapsed := time - previousTime
previousTime = time
angleX += math.Sin((elapsed / period) * math.Pi * 2.0)
angleY += math.Sin((elapsed / period) / 6.0 * math.Pi * 2.0)
angleZ += math.Sin((elapsed / period) / 3.0 * math.Pi * 2.0)
model = mgl32.HomogRotate3DY(float32(angleY)).Mul4(mgl32.HomogRotate3DX(float32(angleX))).Mul4(mgl32.HomogRotate3DZ(float32(angleZ)))
gl.UseProgram(program)
gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])
gl.BindVertexArray(vao)
gl.DrawElements(gl.LINES, int32(len(vertices)), gl.UNSIGNED_INT, gl.PtrOffset(0))
window.SwapBuffers()
glfw.PollEvents()
}
}
