The New Source Code Town

IN YOUR HEADER FILE
{
    GLuint posSlot;        // pointer to the shader position array
    GLuint textSlot;    // pointer to the texture coord array
    GLuint textId;        // pointer to the texture id
    GLuint colId;        // colour multiplier
    GLuint mvpm;        // position matrix
    GLuint texture;        // the texture

}

IN YOUR INIT FUNCTION
{
    // load shader program - see shader loading section
    shaderProgram = loadShaderProgram( "myvertex.vsh" , "myfragment.fsh" );    

    float Verts[] = {     0, 0, 0, tx1, ty2, 0, 0, 0, //
                 0, sy, 0, tx1, ty1, 0, 0, 0, //
                sx, 0, 0, tx2, ty2, 0, 0, 0, //
                sx, sy, 0, tx2, ty1, 0, 0, 0 };

    glGenBuffers(1, &buffer);
    glBindBuffer(GL_ARRAY_BUFFER, buffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Verts), Verts, GL_DYNAMIC_DRAW);
    posSlot = glGetAttribLocation(shaderProgram, "Position");
    textSlot = glGetAttribLocation(shaderProgram, "TexCoordIn");
    textId = glGetUniformLocation(shaderProgram, "Texture");
    colId = glGetUniformLocation(shaderProgram, "color");
    mvpm = glGetUniformLocation(shaderProgram, "modelViewProjectionMatrix");
}

IN YOUR DRAW FUNCTION
{
    float x = 0;    // x position
    float y = 0;    // y position

    glDisable (GL_DEPTH_TEST);
    glDisable (GL_CULL_FACE);
    glBindBuffer(GL_ARRAY_BUFFER, buffer);
    glUseProgram(shaderProgram);
    glEnableVertexAttribArray(posSlot);
    glEnableVertexAttribArray(textSlot);
    glBindTexture(GL_TEXTURE_2D, texture);
    glUniform1i(textId, 0);
    glVertexAttribPointer(posSlot, 3, GL_FLOAT, GL_FALSE, 32, 0);
    glVertexAttribPointer(textSlot, 2, GL_FLOAT, GL_FALSE, 32, (GLvoid*) (sizeof(float) * 3));
    GLKMatrix4 matrix = GLKMatrix4MakeTranslation(x, y, 0);
    glUniformMatrix4fv(mvpm, 1, 0, matrix.m);
    glUniform4f(colId, 1, 1, 1, 1);         // you can change the colour of the sprite here
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    glDisableVertexAttribArray(textSlot);
    glDisableVertexAttribArray(posSlot);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
}

varying lowp vec2 TexCoordOut;
uniform sampler2D Texture;
uniform highp vec4 color;

void main(void)
{
highp vec4 textcol = texture2D(Texture, TexCoordOut);
gl_FragColor = textcol*color;
}

attribute vec4 Position;
attribute vec2 TexCoordIn;
varying vec2 TexCoordOut;
uniform mat4 modelViewProjectionMatrix;

void main(void)
{
gl_Position = modelViewProjectionMatrix *Position;
TexCoordOut = TexCoordIn;
}

GLuint shader = loadShader("Shader.vsh","Shader.fsh");

GLuint loadShader(const char* vpath,const char* fpath)
{
    GLint logLength;

    GLuint program = glCreateProgram();

    char *vs = readFile(vpath);
    char *fs = readFile(fpath);

    GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

    const char* vv = vs, *ff = fs;

    glShaderSource(vertShader , 1, &vv, NULL);
    glShaderSource(fragShader, 1, &ff, NULL);

    glCompileShader(vertShader);

    glGetShaderiv(vertShader, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 0)
    {
        GLchar *log = (GLchar *)malloc(logLength);
        glGetShaderInfoLog(vertShader, logLength, &logLength, log);
        NSLog(@"Shader compile log:\n%s", log);
        free(log);
        exit(1);
    }

    glCompileShader(fragShader);

    glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 0)
    {
        GLchar *log = (GLchar *)malloc(logLength);
        glGetShaderInfoLog(fragShader, logLength, &logLength, log);
        NSLog(@"Shader compile log:\n%s", log);
        exit(1);
        free(log);
    }

    glAttachShader(program, vertShader);
    glAttachShader(program, fragShader);
    glLinkProgram(program);

    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 0)
    {
        GLchar *log = (GLchar *)malloc(logLength);
        glGetProgramInfoLog(program, logLength, &logLength, log);
        NSLog(@"Program link log:\n%s", log);
        free(log);
        exit(1);
    }
    delete(vs);
    delete(fs);
    return program;
}

    
// create a new shader object that we can reference later to activate it.
shader = new ShaderControl();
shader.fsrc = shader.loadShader("f.txt"); // fragment GLSL Code
shader.vsrc = shader.loadShader("v.txt"); // vertex GLSL Code
shader.init(gl);

// The shader control class.
// loads and starts/stops shaders.
Public class ShaderControl
{
    private int vertexShaderProgram;
    private int fragmentShaderProgram;
    private int shaderprogram;
    public String[] vsrc;
    public String[] fsrc;

    // this will attach the shaders
    public void init( GL gl )
    {
        try
        {
            attachShaders(gl);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    // loads the shaders
    // in this example we assume that the shader is a file located in the applications JAR file.
    //
    public String[] loadShader( String name )
    {
        StringBuilder sb = new StringBuilder();
        try
        {
            InputStream is = getClass().getResourceAsStream(name);
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String line;
            while ((line = br.readLine()) != null)
            {
                sb.append(line);
                sb.append('\n');
            }
            is.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        System.out.println("Shader is " + sb.toString());
        return new String[]
        { sb.toString() };
    }

    // This compiles and loads the shader to the video card.
    // if there is a problem with the source the program will exit at this point.
    //
    private void attachShaders( GL gl ) throws Exception
    {
        vertexShaderProgram = gl.glCreateShader(GL.GL_VERTEX_SHADER);
        fragmentShaderProgram = gl.glCreateShader(GL.GL_FRAGMENT_SHADER);
        gl.glShaderSource(vertexShaderProgram, 1, vsrc, null, 0);
        gl.glCompileShader(vertexShaderProgram);
        gl.glShaderSource(fragmentShaderProgram, 1, fsrc, null, 0);
        gl.glCompileShader(fragmentShaderProgram);
        shaderprogram = gl.glCreateProgram();
        //
        gl.glAttachShader(shaderprogram, vertexShaderProgram);
        gl.glAttachShader(shaderprogram, fragmentShaderProgram);
        gl.glLinkProgram(shaderprogram);
        gl.glValidateProgram(shaderprogram);
        IntBuffer intBuffer = IntBuffer.allocate(1);
        gl.glGetProgramiv(shaderprogram, GL.GL_LINK_STATUS, intBuffer);
        
        if (intBuffer.get(0) != 1)
        {
            gl.glGetProgramiv(shaderprogram, GL.GL_INFO_LOG_LENGTH, intBuffer);
            int size = intBuffer.get(0);
            System.err.println("Program link error: ");
            if (size > 0)
            {
                ByteBuffer byteBuffer = ByteBuffer.allocate(size);
                gl.glGetProgramInfoLog(shaderprogram, size, intBuffer, byteBuffer);
                for (byte b : byteBuffer.array())
                {
                    System.err.print((char) b);
                }
            }
            else
            {
                System.out.println("Unknown");
            }
            System.exit(1);
        }
    }
    
    // this function is called when you want to activate the shader.
    // Once activated, it will be applied to anything that you draw from here on
    // until you call the dontUseShader(GL) function.
    public int useShader( GL gl )
    {
        gl.glUseProgram(shaderprogram);
        return shaderprogram;
    }

    // when you have finished drawing everything that you want using the shaders,
    // call this to stop further shader interactions.
    public void dontUseShader( GL gl )
    {
        gl.glUseProgram(0);
    }
}

// Turn on the shader
useShader();
    ... Drawing code here that uses the shader    
// turn off the shader
dontUseShader();

< FILE :: f.txt >
uniform sampler2D fish_y_offset;
uniform float alphavalue;
void main()
{
    gl_FragColor = texture2D(fish_y_offset, gl_TexCoord[0].st);
    gl_FragColor.a=alphavalue;

}

< FILE :: v.txt >
uniform float waveTime;
uniform float waveWidth;
uniform float waveHeight;
void main(void)
{
    vec4 v = vec4(gl_Vertex);
    v.y = 11 + sin(waveWidth * v.x + waveTime) * cos(waveWidth * v.z + waveTime) * waveHeight;
    gl_Position = gl_ModelViewProjectionMatrix * v;
    gl_TexCoord[0] = gl_MultiTexCoord0;
}

int waveWidthLoc = gl.glGetUniformLocation(sp, "waveWidth");
gl.glUniform1f(waveWidthLoc, waveWidth);

Texture text = TextureIO.newTexture(new File(filename), false);

Texture text = TextureIO.newTexture(new File(filename), true);

gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_GENERATE_MIPMAP, GL.GL_TRUE);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_BASE_LEVEL, 0);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_LEVEL, 5);

texture = AWTTextureIO.newTexture(<GLProfile>gp, myBufferedImage, <Use Mipmaps>true);

gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_BASE_LEVEL, 0);
gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_MAX_LEVEL, 5);
gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2ES1.GL_GENERATE_MIPMAP, GL2.GL_TRUE);

float[] lightPos = { 2000,3000,2000,1 };        // light position
float[] noAmbient = { 0.2f, 0.2f, 0.2f, 1f };     // low ambient light
float[] diffuse = { 1f, 1f, 1f, 1f };        // full diffuse colour

gl.glEnable(GL.GL_LIGHTING);
gl.glEnable(GL.GL_LIGHT0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, noAmbient, 0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuse, 0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION,lightPos, 0);

private void doLighting( GL2 gl )
    {
        GlobalData.lightPos[0] = 50005;
        GlobalData.lightPos[1] = 30000;
        GlobalData.lightPos[2] = 50000;// -256 * 3;
        GlobalData.lightPos[3] = 1;
        gl.glEnable(GL2.GL_LIGHTING);
        gl.glEnable(GL2.GL_LIGHT0);
        float[] noAmbient =
        { 0.1f, 0.1f, 0.1f, 1f }; // low ambient light
        float[] spec =
        { 1f, 0.6f, 0f, 1f }; // low ambient light
        float[] diffuse =
        { 1f, 1f, 1f, 1f };
        // properties of the light
        gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_AMBIENT, noAmbient, 0);
        gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_SPECULAR, spec, 0);
        gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_DIFFUSE, diffuse, 0);
        gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_POSITION, GlobalData.lightPos, 0);
    }

private void doLighting( GL2 gl )
{
    GlobalData.lightPos[0] = 50005;
    GlobalData.lightPos[1] = 30000;
    GlobalData.lightPos[2] = 50000;
    GlobalData.lightPos[3] = 1;
    gl.glEnable(GLLightingFunc.GL_LIGHTING);
    gl.glEnable(GLLightingFunc.GL_LIGHT0);
    float[] noAmbient ={ 0.1f, 0.1f, 0.1f, 1f }; // low ambient light
    float[] spec =    { 1f, 0.6f, 0f, 1f }; // low ambient light
    float[] diffuse ={ 1f, 1f, 1f, 1f };
    // properties of the light
    gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_AMBIENT, noAmbient, 0);
    gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_SPECULAR, spec, 0);
    gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_DIFFUSE, diffuse, 0);
    gl.glLightfv(GLLightingFunc.GL_LIGHT0, GLLightingFunc.GL_POSITION, GlobalData.lightPos, 0);
}

public void setOrtho()
{
    gl.glLoadIdentity();
    gl.glMatrixMode(GL.GL_PROJECTION);
    gl.glLoadIdentity();
    gl.glOrtho(0, getWidth(), getHeight(), 0, 0, 2000);
    gl.glMatrixMode(GL.GL_MODELVIEW);
    gl.glViewport(0, 0, getWidth(), getHeight());
    gl.glDisable(GL.GL_CULL_FACE); // Disable Culling
    gl.glDisable(GL.GL_DEPTH_TEST); // Disable Depth Testing
    gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
    gl.glDisable(GL.GL_LIGHTING);
    gl.glColor4f(1, 1, 1, 1);
}

public void setOrtho(GL2 gl)
{
    gl.glLoadIdentity();
    gl.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
    gl.glLoadIdentity();
    gl.glOrtho(0, getWidth(), getHeight(), 0, 0, 2000);
    gl.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
    gl.glViewport(0, 0, getWidth(), getHeight());
    gl.glDisable(GL2.GL_CULL_FACE); // Enable Culling
    gl.glDisable(GL2.GL_DEPTH_TEST); // Enable Culling
    gl.glHint(GL2ES1.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
    gl.glDisable(GLLightingFunc.GL_LIGHTING);
    gl.glColor4f(1, 1, 1, 1);
}

gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_BASE_LEVEL, 0);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_LEVEL, 5);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_GENERATE_MIPMAP, GL.GL_TRUE);
gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST_MIPMAP_NEAREST);

texture = TextureIO.newTexture(ABufferedImage, true);

public void setupTextures( GL2 gl)
{
    gl.glTexEnvf(GL2ES1.GL_TEXTURE_ENV, GL2ES1.GL_TEXTURE_ENV_MODE, GL2ES1.GL_MODULATE);
    gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_BASE_LEVEL, 0);
    gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_MAX_LEVEL, 5);
    gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2ES1.GL_GENERATE_MIPMAP, GL2.GL_TRUE);
    gl.glTexParameterf(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST);
    gl.glTexParameterf(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MIN_FILTER,GL2.GL_NEAREST_MIPMAP_NEAREST);
}

texture = AWTTextureIO.newTexture(<GLProfile>gp, ABufferedImage, <MipMapped Flag>true);

public static Texture createFromMemory( BufferedImage img )
{
    if (img == null) return null;
    Texture text = TextureIO.newTexture(img, true); // mipmap on
    return text;
}

public Texture load(BufferedImage img,GLProfile gp)
{
    if (img == null) return null;
    return AWTTextureIO.newTexture(gp, img, true);
}

public void DoFog( GL gl )
{
    FOG_DISTANCE = 90;
    
    float[] fogcol = { 0, 0, 0, 0 };
    
    gl.glEnable(GL.GL_FOG);                // Enable FOG
    gl.glFogi(GL.GL_FOG_MODE, GL.GL_LINEAR);    // Set the FOG Type
    gl.glFogf(GL.GL_FOG_DENSITY, 0f);        // Set Density
    gl.glFogfv(GL.GL_FOG_COLOR, fogcol, 0);        // Set Fog Color
    gl.glFogf(GL.GL_FOG_START, FOG_DISTANCE - 30);    // Start FOG
    gl.glFogf(GL.GL_FOG_END, FOG_DISTANCE);        // End of FOG
    gl.glHint(GL.GL_FOG_HINT, GL.GL_NICEST);    // NICE!
}

public void DoFog( GL2 gl )
    {
        FOG_DISTANCE = 90;
        
        float[] fogcol =    { 0, 0, 0, 0 };
        
        gl.glEnable(GL2ES1.GL_FOG);
        gl.glFogi(GL2ES1.GL_FOG_MODE, GL.GL_LINEAR);
        gl.glFogf(GL2ES1.GL_FOG_DENSITY, 0f);
        gl.glFogfv(GL2ES1.GL_FOG_COLOR, fogcol, 0);
        gl.glFogf(GL2ES1.GL_FOG_START, FOG_DISTANCE - 30);
        gl.glFogf(GL2ES1.GL_FOG_END, FOG_DISTANCE);
        gl.glHint(GL2ES1.GL_FOG_HINT, GL.GL_NICEST);
    }