// 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 compileShader(sourceFile string, shaderType uint32) (uint32, error) {
// read shader source from file
sourceBytes, err := ioutil.ReadFile(sourceFile)
if err != nil {
return 0, err
}
// allow use as a C string
csource := gl.Str(string(sourceBytes) + "\x00")
// load into OpenGL
shader := gl.CreateShader(shaderType)
gl.ShaderSource(shader, 1, &csource, nil)
gl.CompileShader(shader)
// error handling
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
return 0, fmt.Errorf("failed to compile %v: %v", sourceFile, log)
}
return shader, nil
}
// Creating a RenderObject with a given shaderProgram, texture, and set of
// vertices.
func CreateRenderObject(shaderProgram ShaderProgram, texture Texture, vertices []float32) *RenderObject {
renderObject := new(RenderObject)
// Creating the basic information.
renderObject.shaderProgram = uint32(shaderProgram)
renderObject.texture = uint32(texture)
gl.GenVertexArrays(1, &renderObject.vao)
gl.GenBuffers(1, &renderObject.vbo)
gl.GenBuffers(1, &renderObject.ebo)
// Filling the RenderObject with information.
gl.BindVertexArray(renderObject.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, renderObject.vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, renderObject.ebo)
vertOrder := []uint32{
0, 1, 2,
2, 3, 0,
}
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertOrder)*4, gl.Ptr(vertOrder), gl.STATIC_DRAW)
// Loading up vertex attributes.
vertAttrib := uint32(gl.GetAttribLocation(renderObject.shaderProgram, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 2, gl.FLOAT, false, 4*4, gl.PtrOffset(0))
// Loading up texture attributes.
texAttrib := uint32(gl.GetAttribLocation(renderObject.shaderProgram, gl.Str("vertTexCoord\x00")))
gl.EnableVertexAttribArray(texAttrib)
gl.VertexAttribPointer(texAttrib, 2, gl.FLOAT, false, 4*4, gl.PtrOffset(2*4))
return renderObject
}
func NewEffectsRenderer(w, h int) (r *EffectsRenderer, err error) {
r = &EffectsRenderer{
width: w,
height: h,
Color: mgl32.Vec3{0.0, 0.0, 0.0},
}
_, _, r.oldwidth, r.oldheight = twodee.GetInteger4(gl.VIEWPORT)
if r.shader, err = twodee.BuildProgram(EFFECTS_VERTEX, EFFECTS_FRAGMENT); err != nil {
return
}
r.positionLoc = uint32(gl.GetAttribLocation(r.shader, gl.Str("a_Position\x00")))
r.textureLoc = uint32(gl.GetAttribLocation(r.shader, gl.Str("a_TextureCoordinates\x00")))
r.textureUnitLoc = gl.GetUniformLocation(r.shader, gl.Str("u_TextureUnit\x00"))
r.colorLoc = gl.GetUniformLocation(r.shader, gl.Str("v_Color\x00"))
gl.BindFragDataLocation(r.shader, 0, gl.Str("v_FragData\x00"))
var size float32 = 1.0
var rect = []float32{
-size, -size, 0.0, 0, 0,
-size, size, 0.0, 0, 1,
size, -size, 0.0, 1, 0,
size, size, 0.0, 1, 1,
}
if r.coords, err = twodee.CreateVBO(len(rect)*4, rect, gl.STATIC_DRAW); err != nil {
return
}
if r.framebuffer, r.texture, err = r.initFramebuffer(w, h); err != nil {
return
}
return
}
// Attempting to load a single shader.
func LoadShader(path string, shaderType uint32) (Shader, error, bool) {
// Loading in the file contents.
file, err := os.Open(path)
if err != nil {
return 0, err, false
}
defer file.Close()
contentBytes, err := ioutil.ReadAll(file)
if err != nil {
return 0, err, false
}
content := gl.Str(string(contentBytes) + "\x00")
// Creating and compiling the shader.
shader := gl.CreateShader(shaderType)
gl.ShaderSource(shader, 1, &content, nil)
gl.CompileShader(shader)
var compiled int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &compiled)
if compiled == gl.FALSE {
var length int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &length)
log := strings.Repeat("\x00", int(length+1))
gl.GetShaderInfoLog(shader, length, nil, gl.Str(log))
return 0, errors.New("Shader failed to compile: " + log), true
}
return Shader(shader), nil, false
}
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 NewLinesRenderer(camera *Camera) (lr *LinesRenderer, err error) {
var (
program uint32
vbos = make([]uint32, 2)
point TexturedPoint
)
if program, err = BuildProgram(LINES_VERTEX, LINES_FRAGMENT); err != nil {
return
}
gl.GenBuffers(2, &vbos[0])
lr = &LinesRenderer{
Renderer: NewRenderer(camera),
program: program,
buffer: vbos[0],
indexBuffer: vbos[1],
bufferBytes: 0,
positionLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Position\x00"))),
normalLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Normal\x00"))),
miterLoc: uint32(gl.GetAttribLocation(program, gl.Str("f_Miter\x00"))),
modelviewLoc: gl.GetUniformLocation(program, gl.Str("m_ModelView\x00")),
projectionLoc: gl.GetUniformLocation(program, gl.Str("m_Projection\x00")),
thicknessLoc: gl.GetUniformLocation(program, gl.Str("f_Thickness\x00")),
colorLoc: gl.GetUniformLocation(program, gl.Str("v_Color\x00")),
innerLoc: gl.GetUniformLocation(program, gl.Str("f_Inner\x00")),
offPosition: gl.PtrOffset(int(unsafe.Offsetof(point.X))),
offNormal: gl.PtrOffset(int(unsafe.Offsetof(point.TextureX))),
offMiter: gl.PtrOffset(int(unsafe.Offsetof(point.Z))),
stride: int32(unsafe.Sizeof(point)),
}
if e := gl.GetError(); e != 0 {
err = fmt.Errorf("ERROR: OpenGL error %X", e)
}
return
}
func CompileShader(stype uint32, source string) (shader uint32, err error) {
csource := gl.Str(source)
shader = gl.CreateShader(stype)
gl.ShaderSource(shader, 1, &csource, nil)
gl.CompileShader(shader)
var status int32
if gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status); status == gl.FALSE {
var length int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &length)
log := strings.Repeat("\x00", int(length+1))
gl.GetShaderInfoLog(shader, length, nil, gl.Str(log))
err = fmt.Errorf("ERROR shader compile:\n%s", log)
}
return
}
func getUniformLocation(program uint32, name string) (int32, error) {
u := gl.GetUniformLocation(program, gl.Str(name+"\x00"))
if u == -1 {
return 0, fmt.Errorf("couldn't get uniform location: %q", name)
}
return u, nil
}
func NewParticleSystem(position, direction glm.Vec3, size int) *ParticleSystem {
ps := ParticleSystem{}
ps.root = position
ps.direction = direction
ps.transformfeedbacks = gl2.GenTransformFeedbacks(2)
MustNotGLError()
ps.buffers = gl2.GenBuffers(2)
MustNotGLError()
ps.particles = make([]Particle, size)
ps.isFirst = true
ps.program = gl2.CreateProgram()
vss, err := CompileShader(vs, gl2.VERTEX_SHADER)
if err != nil {
D(err)
}
ps.program.AttachShader(vss.Loc)
gss, err := CompileShader(gs, gl2.GEOMETRY_SHADER)
if err != nil {
D(err)
}
ps.program.AttachShader(gss.Loc)
fss, err := CompileShader(fs, gl2.FRAGMENT_SHADER)
if err != nil {
D(err)
}
ps.program.AttachShader(fss.Loc)
ps.program.Link()
if !ps.program.GetLinkStatus() {
var logLength int32
gl.GetProgramiv(uint32(ps.program), gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetProgramInfoLog(uint32(ps.program), logLength, nil, gl.Str(log))
}
ps.gDeltaTimeMillis = ps.program.GetUniformLocation("gDeltaTimeMillis")
ps.gTime = ps.program.GetUniformLocation("gTime")
ps.gRandomTexture = ps.program.GetUniformLocation("gRandomTexture")
ps.gLauncherLifetime = ps.program.GetUniformLocation("gLauncherLifetime")
ps.gShellLifetime = ps.program.GetUniformLocation("gShellLifetime")
ps.gSecondaryShellLifetime = ps.program.GetUniformLocation("gSecondaryShellLifetime")
ps.particles[0].Lifetime = 0
ps.particles[0].Position = position
ps.particles[0].Velocity = glm.Vec3{0, 0, 0}
ps.particles[0].Type = Launcher
for i := 0; i < len(ps.buffers); i++ {
ps.transformfeedbacks[i].Bind()
MustNotGLError()
ps.buffers[i].Bind(gl2.ARRAY_BUFFER)
MustNotGLError()
ps.buffers[i].Data(gl2.ARRAY_BUFFER, int(unsafe.Sizeof(Particle{}))*len(ps.particles), unsafe.Pointer(&ps.particles[0]), gl2.DYNAMIC_DRAW)
MustNotGLError()
ps.transformfeedbacks[i].BindBufferBase(gl2.TRANSFORM_FEEDBACK_BUFFER, 0, ps.buffers[i])
MustNotGLError()
}
return &ps
}
func GetUniformLocation(shaderName, uniformName string) (int32, error) {
prog, ok := shader_progs[shaderName]
if !ok {
return -1, fmt.Errorf("No shader named '%s'", shaderName)
}
return gl.GetUniformLocation(prog, gl.Str(fmt.Sprintf("%s\x00", uniformName))), nil
}
func newProgram(vertexShaderSource, fragmentShaderSource string) (uint32, error) {
vertexShader, err := compileShader(vertexShaderSource, gl.VERTEX_SHADER)
if err != nil {
return 0, err
}
fragmentShader, err := compileShader(fragmentShaderSource, gl.FRAGMENT_SHADER)
if err != nil {
return 0, err
}
program := gl.CreateProgram()
gl.AttachShader(program, vertexShader)
gl.AttachShader(program, fragmentShader)
gl.LinkProgram(program)
var status int32
gl.GetProgramiv(program, gl.LINK_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetProgramInfoLog(program, logLength, nil, gl.Str(log))
return 0, fmt.Errorf("failed to link program: %v", log)
}
gl.DeleteShader(vertexShader)
gl.DeleteShader(fragmentShader)
return program, nil
}
func (p *Program) Attrib(name string, stride uintptr) *VertexAttribute {
var nameStr = gl.Str(fmt.Sprintf("%v\x00", name))
return &VertexAttribute{
location: uint32(gl.GetAttribLocation(p.program, nameStr)),
stride: stride,
}
}
func getAttribLocation(program uint32, name string) (uint32, error) {
a := gl.GetAttribLocation(program, gl.Str(name+"\x00"))
if a == -1 {
return 0, fmt.Errorf("couldn't get attrib location: %q", name)
}
// Cast to uint32 for EnableVertexAttribArray and VertexAttribPointer better.
return uint32(a), nil
}
func (shader *MVCShader) initMVC() error {
uniform := gl.GetUniformLocation(shader.Handle, gl.Str("mvc\x00"))
if uniform == -1 {
return errors.New("GetUniformLocation Failed")
}
shader.mVCHandle = uniform
return nil
}
func (p *Program) UniformBlock(name string, binding uint32) *UniformBlock {
var (
nameStr = gl.Str(fmt.Sprintf("%v\x00", name))
index = uint32(gl.GetUniformBlockIndex(p.program, nameStr))
)
gl.UniformBlockBinding(p.program, index, binding)
return &UniformBlock{
binding: binding,
}
}
func compileShader(source string, shaderType uint32) (uint32, error) {
shader := gl.CreateShader(shaderType)
csource := gl.Str(source)
gl.ShaderSource(shader, 1, &csource, nil)
gl.CompileShader(shader)
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
return 0, fmt.Errorf("failed to compile %v: %v", source, log)
}
return shader, nil
}
func getInfoLog(getLenFn GetLenFn, getLogFn GetInfoLogFn) func(object uint32) string {
return func(object uint32) string {
var logLength int32
getLenFn(object, gl.INFO_LOG_LENGTH, &logLength)
tlog.Println("infologlen: ", logLength)
log := strings.Repeat("\x00", int(logLength+1))
getLogFn(object, logLength, nil, gl.Str(log))
tlog.Println("infolog: ", log)
return log
}
}
// Attempting to load a ShaderProgram from a given location on the disk. It
// looks for file starting at the path, and then with the respective suffixes of
// .vert, .frag, and .geom.
func LoadShaderProgram(path string) (ShaderProgram, error) {
loaded := 0
// Loading the vertex shader.
vert, err, major := LoadShader(path+".vert", gl.VERTEX_SHADER)
handleShaderLoad("vert", err, major, &loaded)
// Loading the fragment shader.
frag, err, major := LoadShader(path+".frag", gl.FRAGMENT_SHADER)
handleShaderLoad("frag", err, major, &loaded)
// Loading the geometry shader.
geom, err, major := LoadShader(path+".geom", gl.GEOMETRY_SHADER)
handleShaderLoad("geom", err, major, &loaded)
// Making sure we've loaded any shaders.
if loaded == 0 {
return 0, errors.New("Cannot make a shader program without any shaders.")
}
// Creating a loopable structure of the shaders.
shaders := []uint32{
uint32(vert),
uint32(frag),
uint32(geom),
}
program := gl.CreateProgram()
for _, shader := range shaders {
gl.AttachShader(program, shader)
}
gl.LinkProgram(program)
// Destroying the shaders after linking.
for _, shader := range shaders {
gl.DeleteShader(shader)
}
// Checking that it linked correctly.
var linked int32
gl.GetProgramiv(program, gl.LINK_STATUS, &linked)
if linked == gl.FALSE {
var length int32
gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &length)
log := strings.Repeat("\x00", int(length+1))
gl.GetProgramInfoLog(program, length, nil, gl.Str(log))
return 0, errors.New("Shader program failed to link: " + log)
}
return ShaderProgram(program), nil
}
func (p *Program) linkProgram(vertex uint32, fragment uint32) (program uint32, err error) {
program = gl.CreateProgram()
gl.AttachShader(program, vertex)
gl.AttachShader(program, fragment)
gl.BindFragDataLocation(program, 0, gl.Str("v_FragData\x00"))
if e := gl.GetError(); e != 0 {
err = fmt.Errorf("ERROR program.BindFragDataLocation %X", e)
return
}
gl.LinkProgram(program)
var status int32
if gl.GetProgramiv(program, gl.LINK_STATUS, &status); status == gl.FALSE {
var length int32
gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &length)
log := strings.Repeat("\x00", int(length+1))
gl.GetProgramInfoLog(program, length, nil, gl.Str(log))
err = fmt.Errorf("ERROR program link:\n%s", log)
}
gl.DeleteShader(vertex)
gl.DeleteShader(fragment)
return
}
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 getUniformLocation(prog uint32, name string) int32 {
// attempt to get it from the cache first
ul, found := uniCache[name]
if found {
return ul
}
// pull the location from the shader and cache it
uniGLName := name + "\x00"
ul = gl.GetUniformLocation(prog, gl.Str(uniGLName))
// cache even if it returns -1 so that it doesn't repeatedly check
uniCache[name] = ul
return ul
}
func getAttribLocation(prog uint32, name string) int32 {
// attempt to get it from the cache first
al, found := attrCache[name]
if found {
return al
}
// pull the location from the shader and cache it
attrGLName := name + "\x00"
al = gl.GetAttribLocation(prog, gl.Str(attrGLName))
// cache even if it returns -1 so that it doesn't repeatedly check
attrCache[name] = al
return al
}
func NewFramerateRenderer() (r *Framerate, err error) {
r = &Framerate{
shader: core.NewProgram(),
data: newFramerateData(120),
}
if err = r.shader.Load(FRAMERATE_VERTEX, FRAMERATE_FRAGMENT); err != nil {
return
}
r.shader.Bind()
gl.GenBuffers(1, &r.vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, r.vbo)
var (
point framerateDataPoint
locPosition = uint32(gl.GetAttribLocation(r.shader.ID(), gl.Str("v_Position\x00")))
offPosition = gl.PtrOffset(int(unsafe.Offsetof(point.pos)))
)
r.stride = int32(unsafe.Sizeof(point))
r.locColor = gl.GetUniformLocation(r.shader.ID(), gl.Str("v_Color\x00"))
r.locModelView = gl.GetUniformLocation(r.shader.ID(), gl.Str("m_ModelView\x00"))
r.locProjection = gl.GetUniformLocation(r.shader.ID(), gl.Str("m_Projection\x00"))
gl.EnableVertexAttribArray(locPosition)
gl.VertexAttribPointer(locPosition, 2, gl.FLOAT, false, r.stride, offPosition)
return
}
func NewGlowRenderer(w, h int, blur int, strength float32, scale float32) (r *GlowRenderer, err error) {
r = &GlowRenderer{
width: w,
height: h,
blur: blur,
strength: strength,
scale: scale,
}
_, _, r.oldwidth, r.oldheight = GetInteger4(gl.VIEWPORT)
if r.shader, err = BuildProgram(GLOW_VERTEX, GLOW_FRAGMENT); err != nil {
return
}
r.orientationLoc = gl.GetUniformLocation(r.shader, gl.Str("Orientation\x00"))
r.blurAmountLoc = gl.GetUniformLocation(r.shader, gl.Str("BlurAmount\x00"))
r.blurScaleLoc = gl.GetUniformLocation(r.shader, gl.Str("BlurScale\x00"))
r.blurStrengthLoc = gl.GetUniformLocation(r.shader, gl.Str("BlurStrength\x00"))
r.bufferDimensionsLoc = gl.GetUniformLocation(r.shader, gl.Str("BufferDimensions\x00"))
r.positionLoc = uint32(gl.GetAttribLocation(r.shader, gl.Str("a_Position\x00")))
r.textureLoc = uint32(gl.GetAttribLocation(r.shader, gl.Str("a_TextureCoordinates\x00")))
r.textureUnitLoc = gl.GetUniformLocation(r.shader, gl.Str("u_TextureUnit\x00"))
gl.BindFragDataLocation(r.shader, 0, gl.Str("v_FragData\x00"))
var size float32 = 1.0
var rect = []float32{
-size, -size, 0.0, 0, 0,
-size, size, 0.0, 0, 1,
size, -size, 0.0, 1, 0,
size, size, 0.0, 1, 1,
}
if r.coords, err = CreateVBO(len(rect)*4, rect, gl.STATIC_DRAW); err != nil {
return
}
if r.GlowFb, r.GlowTex, err = r.initFramebuffer(w, h); err != nil {
return
}
if r.BlurFb, r.BlurTex, err = r.initFramebuffer(w, h); err != nil {
return
}
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 BindBuffers() { //vertexData *OpenGLVertexInfo) {
vertexData := &vertexDataTest
// check to see if there are any vertices at all to bind
if len(vertexData.vertexData) == 0 {
return
}
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(vertexData.vertexData)*4, gl.Ptr(vertexData.vertexData), gl.DYNAMIC_DRAW)
positionAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertexPosition_modelspace\x00")))
gl.EnableVertexAttribArray(positionAttrib)
gl.VertexAttribPointer(positionAttrib, 3, gl.FLOAT, false, 4*NUM_ATTRIBUTES, gl.PtrOffset(0))
colorAttrib := uint32(gl.GetAttribLocation(program, gl.Str("diffuse\x00")))
gl.EnableVertexAttribArray(colorAttrib)
gl.VertexAttribPointer(colorAttrib, 4, gl.FLOAT, false, 4*NUM_ATTRIBUTES, gl.PtrOffset(3*4))
uvAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertexUV\x00")))
gl.EnableVertexAttribArray(uvAttrib)
gl.VertexAttribPointer(uvAttrib, 2, gl.FLOAT, false, 4*NUM_ATTRIBUTES, gl.PtrOffset(7*4))
mNormAttrib := uint32(gl.GetAttribLocation(program, gl.Str("mNorm\x00")))
gl.EnableVertexAttribArray(mNormAttrib)
gl.VertexAttribPointer(mNormAttrib, 3, gl.FLOAT, false, 4*NUM_ATTRIBUTES, gl.PtrOffset(9*4))
wNormAttrib := uint32(gl.GetAttribLocation(program, gl.Str("wNorm\x00")))
gl.EnableVertexAttribArray(wNormAttrib)
gl.VertexAttribPointer(wNormAttrib, 3, gl.FLOAT, false, 4*NUM_ATTRIBUTES, gl.PtrOffset(12*4))
shaderMode := uint32(gl.GetAttribLocation(program, gl.Str("mode\x00")))
gl.EnableVertexAttribArray(shaderMode)
gl.VertexAttribPointer(shaderMode, 1, gl.FLOAT, false, 4*NUM_ATTRIBUTES, gl.PtrOffset(15*4))
samplerIdx := uint32(gl.GetAttribLocation(program, gl.Str("samplerIdx\x00")))
gl.EnableVertexAttribArray(samplerIdx)
gl.VertexAttribPointer(samplerIdx, 1, gl.FLOAT, false, 4*NUM_ATTRIBUTES, gl.PtrOffset(16*4))
// gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementvbo)
// gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertexData.Elements)*4, gl.Ptr(vertexData.Elements), gl.STATIC_DRAW)
// gl.ActiveTexture(gl.TEXTURE0)
// gl.BindTexture(gl.TEXTURE_2D, 1)
}
func NewSpriteRenderer(camera *Camera) (tr *SpriteRenderer, err error) {
var (
program uint32
vbos = make([]uint32, 1)
sprite SpriteConfig
frameOffset = int(unsafe.Offsetof(sprite.Frame))
viewOffset = int(unsafe.Offsetof(sprite.View))
)
if program, err = BuildProgram(SPRITE_VERTEX, SPRITE_FRAGMENT); err != nil {
return
}
gl.GenBuffers(1, &vbos[0])
tr = &SpriteRenderer{
Renderer: NewRenderer(camera),
program: program,
instanceVBO: vbos[0],
instanceBytes: 0,
translationLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Translation\x00"))),
rotationLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Rotation\x00"))),
scaleLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Scale\x00"))),
pointAdjLoc: uint32(gl.GetAttribLocation(program, gl.Str("m_PointAdjustment\x00"))),
textureAdjLoc: uint32(gl.GetAttribLocation(program, gl.Str("m_TextureAdjustment\x00"))),
colorLoc: uint32(gl.GetAttribLocation(program, gl.Str("v_Color\x00"))),
textureUnitLoc: gl.GetUniformLocation(program, gl.Str("TextureUnit\x00")),
projectionLoc: gl.GetUniformLocation(program, gl.Str("m_ProjectionMatrix\x00")),
offAttrX: gl.PtrOffset(viewOffset + int(unsafe.Offsetof(sprite.View.X))),
offAttrRotationX: gl.PtrOffset(viewOffset + int(unsafe.Offsetof(sprite.View.RotationX))),
offAttrColor: gl.PtrOffset(int(unsafe.Offsetof(sprite.Color))),
offAttrScaleX: gl.PtrOffset(viewOffset + int(unsafe.Offsetof(sprite.View.ScaleX))),
offAttrPointAdj: frameOffset + int(unsafe.Offsetof(sprite.Frame.PointAdjustment)),
offAttrTextureAdj: frameOffset + int(unsafe.Offsetof(sprite.Frame.TextureAdjustment)),
}
if e := gl.GetError(); e != 0 {
err = fmt.Errorf("ERROR: OpenGL error %X", e)
}
return
}
func MakeProgram(vert, frag string) (uint32, error) {
vertexShader, err := compileShader(vert, gl.VERTEX_SHADER)
if err != nil {
return 0, err
}
fragmentShader, err := compileShader(frag, gl.FRAGMENT_SHADER)
if err != nil {
return 0, err
}
program := gl.CreateProgram()
gl.AttachShader(program, vertexShader)
gl.AttachShader(program, fragmentShader)
gl.LinkProgram(program)
var status int32
gl.GetProgramiv(program, gl.LINK_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetProgramInfoLog(program, logLength, nil, gl.Str(log))
return 0, errors.New(fmt.Sprintf("failed to link program: %v", log))
}
gl.DeleteShader(vertexShader)
gl.DeleteShader(fragmentShader)
if ok := gl.GetError(); ok != gl.NO_ERROR {
return 0, errors.New("Error in Make Program : " + string(ok))
}
return program, nil
}
func bindAggregateImage(img image.Image, idx int) uint32 {
newIdx := idx
if rgba, ok := img.(*image.RGBA); ok {
gl.GenTextures(1, &textures[newIdx])
gl.ActiveTexture(gl.TEXTURE0 + uint32(newIdx))
gl.BindTexture(gl.TEXTURE_2D, textures[newIdx])
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(rgba.Rect.Size().X), int32(rgba.Rect.Size().Y), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(rgba.Pix))
gl.GenerateMipmap(gl.TEXTURE_2D)
idxS := strconv.Itoa(newIdx)
fmt.Println("idx: ", int32(newIdx), "myTextureSampler["+idxS+"]\x00")
gl.Uniform1i(gl.GetUniformLocation(program, gl.Str("myTextureSampler["+idxS+"]\x00")), int32(newIdx))
if ok := gl.GetError(); ok != gl.NO_ERROR {
fmt.Println("1- Cannot load Image in location: ./: ", ok)
os.Exit(-1)
}
return textures[newIdx]
} else {
fmt.Println("Image not RGBA at location: ./")
os.Exit(-1)
}
return 0
}