renderer.java

NeHe用java与OpenGL结合教程源码

        gl.glNormal3f(0f, 0f, 1f);
        for (i = 0; i < 4; i++) {
            gl.glTexCoord2f(data[5 * i], data[5 * i + 1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Back Face
        gl.glNormal3f(0f, 0f, -1f);
        for (i = 4; i < 8; i++) {
            gl.glTexCoord2f(data[5 * i], data[5 * i + 1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Top Face
        gl.glNormal3f(0f, 1f, 0f);
        for (i = 8; i < 12; i++) {
            gl.glTexCoord2f(data[5 * i], data[5 * i + 1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Bottom Face
        gl.glNormal3f(0f, -1f, 0f);
        for (i = 12; i < 16; i++) {
            gl.glTexCoord2f(data[5 * i], data[5 * i + 1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Right face
        gl.glNormal3f(1f, 0f, 0f);
        for (i = 16; i < 20; i++) {
            gl.glTexCoord2f(data[5 * i], data[5 * i + 1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Left Face
        gl.glNormal3f(-1.0f, 0.0f, 0.0f);
        for (i = 20; i < 24; i++) {
            gl.glTexCoord2f(data[5 * i], data[5 * i + 1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        gl.glEnd();
    }

    void VMatMult(float[] M, float[] v) {

        float res[] = new float[3];

        res[0] = M[0] * v[0] + M[1] * v[1] + M[2] * v[2] + M[3] * v[3];
        res[1] = M[4] * v[0] + M[5] * v[1] + M[6] * v[2] + M[7] * v[3];
        res[2] = M[8] * v[0] + M[9] * v[1] + M[10] * v[2] + M[11] * v[3];

        v[0] = res[0];
        v[1] = res[1];
        v[2] = res[2];
        v[3] = M[15]; // Homogenous Coordinate
    }

    void SetUpBumps(float[] n, float[] c, float[] l, float[] s, float[] t) {

        float v[] = new float[3],  // Vertex From Current Position To Light
                lenQ;                // Used To Normalize

        // Calculate v From Current Vector c To Lightposition And Normalize v
        v[0] = l[0] - c[0];
        v[1] = l[1] - c[1];
        v[2] = l[2] - c[2];

        lenQ = (float) Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
        v[0] /= lenQ;
        v[1] /= lenQ;
        v[2] /= lenQ;

        // Project v Such That We Get Two Values Along Each Texture-Coordinat Axis.
        c[0] = (s[0] * v[0] + s[1] * v[1] + s[2] * v[2]) * MAX_EMBOSS;
        c[1] = (t[0] * v[0] + t[1] * v[1] + t[2] * v[2]) * MAX_EMBOSS;
    }

    void doLogo(GL gl) {// MUST CALL THIS LAST!!!, Billboards The Two Logos.

        gl.glDepthFunc(GL.GL_ALWAYS);
        gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
        gl.glEnable(GL.GL_BLEND);
        gl.glDisable(GL.GL_LIGHTING);
        gl.glLoadIdentity();
        gl.glBindTexture(GL.GL_TEXTURE_2D, glLogo[0]);

        gl.glBegin(GL.GL_QUADS);
        gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(0.23f, -0.4f, -1.0f);
        gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(0.53f, -0.4f, -1.0f);
        gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(0.53f, -0.25f, -1.0f);
        gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(0.23f, -0.25f, -1.0f);
        gl.glEnd();

        if (multitextureEnabled) {
            gl.glBindTexture(GL.GL_TEXTURE_2D, multiLogo[0]);
            gl.glBegin(GL.GL_QUADS);
            gl.glTexCoord2f(0.0f, 0.0f);
            gl.glVertex3f(-0.53f, -0.4f, -1.0f);
            gl.glTexCoord2f(1.0f, 0.0f);
            gl.glVertex3f(-0.33f, -0.4f, -1.0f);
            gl.glTexCoord2f(1.0f, 1.0f);
            gl.glVertex3f(-0.33f, -0.3f, -1.0f);
            gl.glTexCoord2f(0.0f, 1.0f);
            gl.glVertex3f(-0.53f, -0.3f, -1.0f);
            gl.glEnd();
        }
        gl.glDepthFunc(GL.GL_LEQUAL);
    }

    void doMesh1TexelUnits(GL gl) {

        float c[] = {0f, 0f, 0f, 1f},     // Holds Current Vertex
                n[] = {0f, 0f, 0f, 1f},     // Normalized Normal Of Current Surface
                s[] = {0f, 0f, 0f, 1f},     // s-Texture Coordinate Direction, Normalized
                t[] = {0f, 0f, 0f, 1f},     // t-Texture Coordinate Direction, Normalized
                l[] = {0f, 0f, 0f, 0f},     // Holds Our Lightposition To Be Transformed Into Object Space
                Minv[] = new float[16];        // Holds The Inverted Modelview Matrix To Do So.
        int i;

        // Build Inverse Modelview Matrix First. This Substitutes One Push/Pop With One glLoadIdentity();
        // Simply Build It By Doing All Transformations Negated And In Reverse Order.
        gl.glLoadIdentity();
        gl.glRotatef(-yrot, 0.0f, 1.0f, 0.0f);
        gl.glRotatef(-xrot, 1.0f, 0.0f, 0.0f);
        gl.glTranslatef(0.0f, 0.0f, -z);
        gl.glGetFloatv(GL.GL_MODELVIEW_MATRIX, Minv, 0);
        gl.glLoadIdentity();
        gl.glTranslatef(0.0f, 0.0f, z);

        gl.glRotatef(xrot, 1.0f, 0.0f, 0.0f);
        gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);

        // Transform The Lightposition Into Object Coordinates:
        l[0] = lightPosition[0];
        l[1] = lightPosition[1];
        l[2] = lightPosition[2];
        l[3] = 1.0f;                           // Homogenous Coordinate
        VMatMult(Minv, l);

        /*  PASS#1: Use Texture "Bump"
            No Blend
            No Lighting
            No Offset Texture-Coordinates
        */

        gl.glBindTexture(GL.GL_TEXTURE_2D, bump[filter]);
        gl.glDisable(GL.GL_BLEND);
        gl.glDisable(GL.GL_LIGHTING);
        doCube(gl);

        /* PASS#2:  Use Texture "Invbump"
            Blend GL_ONE To GL_ONE
            No Lighting
            Offset Texture Coordinates
        */

        gl.glBindTexture(GL.GL_TEXTURE_2D, invbump[filter]);
        gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE);
        gl.glDepthFunc(GL.GL_LEQUAL);
        gl.glEnable(GL.GL_BLEND);

        gl.glBegin(GL.GL_QUADS);
        // Front Face
        n[0] = 0.0f;
        n[1] = 0.0f;
        n[2] = 1.0f;
        s[0] = 1.0f;
        s[1] = 0.0f;
        s[2] = 0.0f;
        t[0] = 0.0f;
        t[1] = 1.0f;
        t[2] = 0.0f;

        for (i = 0; i < 4; i++) {
            c[0] = data[5 * i + 2];
            c[1] = data[5 * i + 3];
            c[2] = data[5 * i + 4];
            SetUpBumps(n, c, l, s, t);
            gl.glTexCoord2f(data[5 * i] + c[0], data[5 * i + 1] + c[1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }

        // Back Face
        n[0] = 0.0f;
        n[1] = 0.0f;
        n[2] = -1.0f;
        s[0] = -1f;
        s[1] = 0.0f;
        s[2] = 0.0f;
        t[0] = 0.0f;
        t[1] = 1.0f;
        t[2] = 0.0f;

        for (i = 4; i < 8; i++) {
            c[0] = data[5 * i + 2];
            c[1] = data[5 * i + 3];
            c[2] = data[5 * i + 4];
            SetUpBumps(n, c, l, s, t);
            gl.glTexCoord2f(data[5 * i] + c[0], data[5 * i + 1] + c[1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }

        // Top Face
        n[0] = 0.0f;
        n[1] = 1.0f;
        n[2] = 0.0f;
        s[0] = 1.0f;
        s[1] = 0.0f;
        s[2] = 0.0f;
        t[0] = 0.0f;
        t[1] = 0.0f;
        t[2] = -1.0f;

        for (i = 8; i < 12; i++) {
            c[0] = data[5 * i + 2];
            c[1] = data[5 * i + 3];
            c[2] = data[5 * i + 4];
            SetUpBumps(n, c, l, s, t);
            gl.glTexCoord2f(data[5 * i] + c[0], data[5 * i + 1] + c[1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Bottom Face
        n[0] = 0f;
        n[1] = -1f;
        n[2] = 0f;
        s[0] = -1f;
        s[1] = 0f;
        s[2] = 0f;
        t[0] = 0f;
        t[1] = 0f;
        t[2] = -1f;

        for (i = 12; i < 16; i++) {
            c[0] = data[5 * i + 2];
            c[1] = data[5 * i + 3];
            c[2] = data[5 * i + 4];
            SetUpBumps(n, c, l, s, t);
            gl.glTexCoord2f(data[5 * i] + c[0], data[5 * i + 1] + c[1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Right Face
        n[0] = 1.0f;
        n[1] = 0.0f;
        n[2] = 0.0f;
        s[0] = 0.0f;
        s[1] = 0.0f;
        s[2] = -1.0f;
        t[0] = 0.0f;
        t[1] = 1.0f;
        t[2] = 0.0f;

        for (i = 16; i < 20; i++) {
            c[0] = data[5 * i + 2];
            c[1] = data[5 * i + 3];
            c[2] = data[5 * i + 4];
            SetUpBumps(n, c, l, s, t);
            gl.glTexCoord2f(data[5 * i] + c[0], data[5 * i + 1] + c[1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        // Left Face
        n[0] = -1.0f;
        n[1] = 0.0f;
        n[2] = 0.0f;
        s[0] = 0.0f;
        s[1] = 0.0f;
        s[2] = 1.0f;
        t[0] = 0.0f;
        t[1] = 1.0f;
        t[2] = 0.0f;

        for (i = 20; i < 24; i++) {
            c[0] = data[5 * i + 2];
            c[1] = data[5 * i + 3];
            c[2] = data[5 * i + 4];
            SetUpBumps(n, c, l, s, t);
            gl.glTexCoord2f(data[5 * i] + c[0], data[5 * i + 1] + c[1]);
            gl.glVertex3f(data[5 * i + 2], data[5 * i + 3], data[5 * i + 4]);
        }
        gl.glEnd();

        /* PASS#3:	Use Texture "Base"
           Blend GL_DST_COLOR To GL_SRC_COLOR (Multiplies By 2)
           Lighting Enabled
           No Offset Texture-Coordinates
         */

        if (!embossEnabled) {
            gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE);
            gl.glBindTexture(GL.GL_TEXTURE_2D, textures[filter]);
            gl.glBlendFunc(GL.GL_DST_COLOR, GL.GL_SRC_COLOR);
            gl.glEnable(GL.GL_LIGHTING);
            doCube(gl);
        }

        xrot += xspeed;
        yrot += yspeed;
        if (xrot > 360.0f) xrot -= 360.0f;
        if (xrot < 0.0f) xrot += 360.0f;
        if (yrot > 360.0f) yrot -= 360.0f;
        if (yrot < 0.0f) yrot += 360.0f;