Wireframed Shader

/** SPHERE RENDER & UPDATE **/
def override render ( alpha_stage : bool, view : array of GLfloat,
                            projection : array of GLfloat)
        if alpha_stage is not self._material.translucent
            return

        i : int = 0
        offset : int = 0

        // Lock against changes during render
        mutex.lock()

        // get model matrix
        model : array of GLfloat = self.model_matrix()

        model_view : array of GLfloat = self.calculate_model_view(model, view)

        // Update ebo/vbo as needed
        if _updated
            _update_sphere()
        // Re-bind buffers when not updating
        else
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo)
            glBindBuffer(GL_ARRAY_BUFFER, _vbo)

        // calculate tslvs
        if _material.needsTSLVs
            calculateTSLV(_vercache)
            offset = (int) (tslvs.length * sizeof(GLfloat) * 11/3)
            glBufferSubData(GL_ARRAY_BUFFER, (GLsizei) offset,
                            (GLsizei) (tslvs.length * sizeof(GLfloat)), tslvs)

        // Render
        self._material.enable(model_view, projection,
                    (GLvoid*) (_offset))

        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
                              (GLsizei) (sizeof(GLfloat) * 11),
                              null)
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
                              (GLsizei) (sizeof(GLfloat) * 11),
                              (GLvoid*) (sizeof(GLfloat) * 3))
        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE,
                              (GLsizei) (sizeof(GLfloat) * 11),
                              (GLvoid*) (sizeof(GLfloat) * 6))
        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE,
                              (GLsizei) (sizeof(GLfloat) * 11),
                              (GLvoid*) (sizeof(GLfloat) * 8))

        glEnableVertexAttribArray(0)
        glEnableVertexAttribArray(1)
        glEnableVertexAttribArray(2)
        glEnableVertexAttribArray(3)

        var sub = (int) ceil(radius * 8)
        glDrawElements(GL_TRIANGLES, (GLsizei) (3*24*sub*sub),
                       GL_UNSIGNED_SHORT, (GLvoid*) 0)

        glDisableVertexAttribArray(0)
        glDisableVertexAttribArray(1)
        glDisableVertexAttribArray(2)
        glDisableVertexAttribArray(3)

        // Render axis
        //renderAxis()

        // Release lock
        mutex.unlock()


    // TODO: textures, buffer it better
    def _update_sphere()
        if _ebo == 0
            buffers : array of GLuint = {0, 0}
            glGenBuffers(buffers)
            _ebo = buffers[0]
            _vbo = buffers[1]

        // dimensional subdivisions
        sub : int = (int) ceil(radius*8)

        // elements: 4*(total subdivided squares)
        //
        // _____
        // |\ /|
        // | X | for each square
        // |/_\|
        //
        var elenum = (int) (24*sub*sub)

        // vertices: (vertices on corners of squares)+
        //                                  (total subdivided squares [centers])
        var vernum = (int) (6*(sub+1)*(sub+1)+elenum/4)

        elements : array of GLushort = new array of GLushort[elenum*3]
        position : array of GLfloat = new array of GLfloat[vernum*3]
        normal : array of GLfloat = new array of GLfloat[vernum*3]
        texcoord : array of GLfloat = new array of GLfloat[vernum*2]
        tangent : array of GLfloat = new array of GLfloat[vernum*3]

        var radius = _radius

        // generate faces
        //
        // order:
        //
        // top
        // bottom
        // front
        // back
        // right
        // left
        //
        var voffset = 0
        var eoffset = 0
        _gen_face(radius, radius, radius, 0.625f, 0.25f, eoffset, voffset, 0, 2,
                  elements, position, normal, texcoord, tangent)
        voffset += (int) ((sub+1)*(sub+1)+sub*sub)
        eoffset += (int) (4*sub*sub)
        _gen_face(radius, -radius, -radius, 0.625f, 0.75f, eoffset, voffset, 0,
                  2, elements, position, normal, texcoord, tangent)
        voffset += (int) ((sub+1)*(sub+1)+sub*sub)
        eoffset += (int) (4*sub*sub)
        _gen_face(-radius, radius, radius, 0.125f, 0.5f, eoffset, voffset, 0, 1,
                  elements, position, normal, texcoord, tangent)
        voffset += (int) ((sub+1)*(sub+1)+sub*sub)
        eoffset += (int) (4*sub*sub)
        _gen_face(radius, radius, -radius, 0.625f, 0.5f, eoffset, voffset, 0, 1,
                  elements, position, normal, texcoord, tangent)
        voffset += (int) ((sub+1)*(sub+1)+sub*sub)
        eoffset += (int) (4*sub*sub)
        _gen_face(radius, radius, radius, 0.375f, 0.5f, eoffset, voffset, 2, 1,
                  elements, position, normal, texcoord, tangent)
        voffset += (int) ((sub+1)*(sub+1)+sub*sub)
        eoffset += (int) (4*sub*sub)
        _gen_face(-radius, radius, -radius, 0.875f, 0.5f, eoffset, voffset, 2,
                  1, elements, position, normal, texcoord, tangent)
        var vertices = packArrays(position, normal, texcoord, tangent)

        _vercache = vertices

        // bind elements
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo)
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizei) (3 * elenum * sizeof(
                     GLushort)), elements, GL_STATIC_DRAW)

        // bind vertices
        glBindBuffer(GL_ARRAY_BUFFER, _vbo)
        var offset = 14 * vernum * sizeof(GLfloat)
        var extra = self._material.get_extra_space_vbo(vernum, elenum)
        glBufferData(GL_ARRAY_BUFFER, (GLsizei) (offset+extra),
                     vertices, GL_STATIC_DRAW)

        // add material-specific changes
        self._material.update_model(position, elements, _vbo, _ebo, (GLsizei) offset)

        _offset = (GLsizei)offset

        // Reset updated flag
        _updated = false

/** WIREFRAMED CLASS **/

class soy.materials.Wireframed : soy.materials.Material

    _m_size : GLsizei
    _m_offset : GLsizei

    def override enable (mv : array of GLfloat, p : array of GLfloat,
                        tslvs : GLvoid*, texmatrix : ode.Matrix3? = null)
        if _program is 0
            status : GLint
            vertex_shader : array of string = {"
                precision lowp float;
                varying vec3 vBC;
                attribute vec3 vertex, normal;
                attribute vec3 barycentric;
                uniform mat4 mv_matrix, p_matrix;
                void main()
                {
                    vBC = barycentric;
                    gl_Position = p_matrix*mv_matrix*vec4(vertex,1.0);
                }
            "}
            fragment_shader : array of string = {"
                #extension GL_OES_standard_derivatives : enable
                precision lowp float;
                varying vec3 vBC;
                float edgeFactor(){
                    vec3 d = fwidth(vBC);
                    vec3 a3 = smoothstep(vec3(0.0), d*1.5, vBC);
                    return min(min(a3.x, a3.y), a3.z);
                }
                void main()
                {
                    //if(any(lessThan(vBC, vec3(0.02)))){
                    //    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
                    //} else{
                    //    gl_FragColor = vec4(0.5, 0.5, 0.5, 1.0);
                    //}
                    gl_FragColor.rgb = vBC.xyz; //mix(vec3(0.0), vec3(0.5), edgeFactor());
                    gl_FragColor.a = 1.0;
                    // gl_FragColor = vec4(0.0, 0.0, 0.0, (1.0-edgeFactor())*0.95);
                }
            "}
            // initialize vertex shader
            _vertex_shader = glCreateShader(GL_VERTEX_SHADER)
            glShaderSource(_vertex_shader, 1, vertex_shader, {-1})
            glCompileShader(_vertex_shader)

            j:int
            log:string = ""
            glGetShaderInfoLog(_vertex_shader, 1000, out j, log)
            print log

            // check compile status
            glGetShaderiv(_vertex_shader, GL_COMPILE_STATUS, out status)
            assert status is not (GLint) GL_FALSE

            // initialize fragment shader
            _fragment_shader = glCreateShader(GL_FRAGMENT_SHADER)
            glShaderSource(_fragment_shader, 1, fragment_shader, {-1})
            glCompileShader(_fragment_shader)

            glGetShaderInfoLog(_fragment_shader, 1000, out j, log)
            print log

            // check compile status
            glGetShaderiv(_fragment_shader, GL_COMPILE_STATUS, out status)

            assert status is not (GLint) GL_FALSE

            // initialize program
            _program = glCreateProgram()
            glAttachShader(_program, _vertex_shader)
            glAttachShader(_program, _fragment_shader)
            glBindAttribLocation(_program, 0, "vertex")
            glBindAttribLocation(_program, 1, "normal")
            glLinkProgram(_program)

            // check link status
            glGetProgramiv(_program, GL_LINK_STATUS, out status)
            glGetProgramInfoLog(_program, 1000, out j, log)
            print log

            assert status is not (GLint) GL_FALSE

            // cleanup
            glDetachShader(_program, _vertex_shader)
            glDeleteShader(_vertex_shader)
            glDetachShader(_program, _fragment_shader)
            glDeleteShader(_fragment_shader)
        glUseProgram(_program)
        mv_loc : GLint = glGetUniformLocation(_program, "mv_matrix")
        glUniformMatrix4fv(mv_loc, 1, GL_FALSE, mv)
        p_loc : GLint = glGetUniformLocation(_program, "p_matrix")
        glUniformMatrix4fv(p_loc, 1, GL_FALSE, p)
        bc_loc : GLint = glGetAttribLocation(_program, "barycentric")
        glVertexAttribPointer(bc_loc, 3, GL_FLOAT, GL_TRUE, 3, (GLvoid*)_m_offset)
        glEnableVertexAttribArray(bc_loc)


    def override get_extra_space_vbo (numVerts: GLsizei,
                                    numElements: GLsizei) : GLsizei
        _m_size = numVerts*3
        return (GLsizei)(3*numVerts*sizeof(GLfloat))

    def override update_model (vertBuffer : array of GLfloat,
                                elemBuffer : array of GLushort,
                                vbo : GLuint, ebo : GLuint,
                                offset : GLsizei)
        print "Updating model with offset=%d", offset
        var adding = new array of GLfloat [_m_size]
        var count = 0
        for var i = 0 to (elemBuffer.length/3)
            count++
            var v0 = elemBuffer[i*3]
            var v1 = elemBuffer[i*3+1]
            var v2 = elemBuffer[i*3+2]
            adding[v0*3]   = 1
            adding[v0*3+1] = 0
            adding[v0*3+2] = 0
            adding[v1*3]   = 0
            adding[v1*3+1] = 1
            adding[v1*3+2] = 0
            adding[v2*3]   = 0
            adding[v2*3+1] = 0
            adding[v2*3+2] = 1
        print "     array size = %d", adding.length*(int)sizeof(GLfloat)
        glBindBuffer(GL_ARRAY_BUFFER, vbo)
        glBufferSubData(GL_ARRAY_BUFFER, offset,
              (GLsizei)(sizeof(GLfloat)*adding.length), adding)
        _m_offset = offset

    ////////////////////////////////////////////////////////////////////////
    // Static

    _vertex_shader : static GLuint
    _fragment_shader : static GLuint
    _program : static GLuint