jogltrianglemeshrenderer.java

基于java的3d开发库。对坐java3d的朋友有很大的帮助。

            return;
        }
        int materialRanges[][] = mesh.getMaterialRanges();

        if ( materialRanges == null ) {
            drawRangeWithoutTexture(gl, mesh,
                                   0, mesh.getTriangles().length, flipNormals);
            return;
        }

        int start = 0;
        int end = 0;
        int materialIndex;
        Material materialsArray[] = mesh.getMaterials();
        for ( int i = 0; i < materialRanges.length; i++ ) {
            end = materialRanges[i][0];
            materialIndex = materialRanges[i][1];
            if ( materialIndex >= 0 && materialIndex < materialsArray.length ) {
                JoglMaterialRenderer.activate(gl,
                    materialsArray[materialIndex]);
            }
            drawRangeWithoutTexture(gl, mesh, start, end, flipNormals);
            start = end;
        }
        if ( end <= mesh.getTriangles().length ) {
            Material m = new Material();
            JoglMaterialRenderer.activate(gl, m);
            drawRangeWithoutTexture(gl, mesh, start, mesh.getTriangles().length, flipNormals);
        }
    }

    /**
    Note that current implementation only works for a TriangleMesh that
    contains both getMaterials() and getMaterialRanges() defined!

    Main algorithm is a mixed iterative advanced over 
    texturesRanges and materialsRanges arrays.
    */
    private static void
    drawSurfacesWithTexture(GL gl, TriangleMesh mesh, boolean flip) {
        // Support variables
        Image[] texturesArray = mesh.getTextures();
        Material materialsArray[] = mesh.getMaterials();
        int texturesRanges[][] = mesh.getTextureRanges();
        int materialsRanges[][] = mesh.getMaterialRanges();

        // Main cycle variables / cycle initialization
        int start = 0;
        int end = 0;
        int it = 0;
        int im =  0;
        int currentTextureIndex;
        int currentMaterialIndex;
        int previousTextureIndex = -1;
        int previousMaterialIndex = -1;

        if ( materialsRanges == null ) {
            VSDK.reportMessage(null, VSDK.WARNING, 
                "JoglTriangleMeshRenderer.drawSurfacesWithTexture",
                "Non implemented support for null materialsRanges.");
            return;
        }

        do {
            //- Cycle body ----------------------------------------------------
            end = Math.min(texturesRanges[it][0], materialsRanges[im][0]);
            currentTextureIndex = texturesRanges[it][1]-1;
            currentMaterialIndex = materialsRanges[im][1];

            if ( currentMaterialIndex != previousMaterialIndex ) {
                if ( currentMaterialIndex >= 0 ) {
                    JoglMaterialRenderer.activate(gl,
                        materialsArray[currentMaterialIndex]);
                }
                previousMaterialIndex = currentMaterialIndex;
            }
            if ( currentTextureIndex != previousTextureIndex ) {
                if ( currentTextureIndex >= 0 ) {
                    gl.glEnable(gl.GL_TEXTURE_2D);
                    JoglImageRenderer.activate(gl,
                        texturesArray[currentTextureIndex]);
                    // Warning: Shoult this be here? or not ...
                    gl.glTexParameteri(gl.GL_TEXTURE_2D,
                        gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR);
                    gl.glTexParameteri(gl.GL_TEXTURE_2D,
                        gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR);
                    gl.glTexParameterf(gl.GL_TEXTURE_2D,
                        gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT);
                    gl.glTexParameterf(gl.GL_TEXTURE_2D,
                        gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT);
                    gl.glTexEnvf(gl.GL_TEXTURE_ENV,
                        gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
                }
                else {
                    gl.glDisable(gl.GL_TEXTURE_2D);
                }
                previousTextureIndex = currentTextureIndex;
            }

            if ( currentTextureIndex >= 0 ) {
                drawRangeWithTexture(gl, mesh, start, end, flip);
              }
              else {
                drawRangeWithoutTexture(gl, mesh, start, end, flip);
            }

            //- Cycle advancment ----------------------------------------------
            if ( texturesRanges[it][0] < materialsRanges[im][0] &&
                 it < texturesRanges.length ) {
                it++;
            }
            else if ( texturesRanges[it][0] > materialsRanges[im][0] &&
                 im < materialsRanges.length ) {
                im++;
            }
            else if ( texturesRanges[it][0] == materialsRanges[im][0] ) {
                if ( it < texturesRanges.length ) it++;
                if ( im < materialsRanges.length ) im++;
            }
            start = end;
        } while ( it < texturesRanges.length && im < materialsRanges.length );
    }

    private static void
    drawRangeWithTexture(GL gl, TriangleMesh mesh, 
                         int start, int end, boolean flipNormals) {
        Vertex v0, v1, v2;

        gl.glBegin(gl.GL_TRIANGLES);
        for ( int i = start; i < end; i++ ) {
            v0 = mesh.getVertexAt(mesh.getTriangleAt(i).p0);
            v1 = mesh.getVertexAt(mesh.getTriangleAt(i).p1);
            v2 = mesh.getVertexAt(mesh.getTriangleAt(i).p2);

            if ( !flipNormals ) {
                gl.glNormal3d(v0.normal.x, v0.normal.y, v0.normal.z);
              }
              else {
                gl.glNormal3d(-v0.normal.x, -v0.normal.y, -v0.normal.z);
            }

            gl.glTexCoord2d(v0.u, v0.v);
            gl.glVertex3d(v0.position.x, v0.position.y, v0.position.z);
            if ( !flipNormals ) {
                gl.glNormal3d(v1.normal.x, v1.normal.y, v1.normal.z);
            }
            else {
                gl.glNormal3d(-v1.normal.x, -v1.normal.y, -v1.normal.z);
            }

            gl.glTexCoord2d(v1.u, v1.v);
            gl.glVertex3d(v1.position.x, v1.position.y, v1.position.z);
            if ( !flipNormals ) {
                gl.glNormal3d(v2.normal.x, v2.normal.y, v2.normal.z);
              }
              else {
                gl.glNormal3d(-v2.normal.x, -v2.normal.y, -v2.normal.z);
            }
            gl.glTexCoord2d(v2.u, v2.v);

            gl.glVertex3d(v2.position.x, v2.position.y, v2.position.z);
        }
        gl.glEnd();
    }

    private static void
    drawRangeWithoutTexture(GL gl, TriangleMesh mesh, 
                            int start, int end, boolean flipNormals) {
        Vertex v0, v1, v2;

        gl.glBegin(gl.GL_TRIANGLES);
        for ( int i = start; i < end; i++ ) {
            v0 = mesh.getVertexAt(mesh.getTriangleAt(i).p0);
            v1 = mesh.getVertexAt(mesh.getTriangleAt(i).p1);
            v2 = mesh.getVertexAt(mesh.getTriangleAt(i).p2);

            //-----------------------------------------------------------------
            if ( !flipNormals ) {
                gl.glNormal3d(v0.normal.x, v0.normal.y, v0.normal.z);
              }
              else {
                gl.glNormal3d(-v0.normal.x, -v0.normal.y, -v0.normal.z);
            }
            gl.glTexCoord2d(v0.u, v0.v);
            gl.glVertex3d(v0.position.x, v0.position.y, v0.position.z);

            //-----------------------------------------------------------------
            if ( !flipNormals ) {
                gl.glNormal3d(v1.normal.x, v1.normal.y, v1.normal.z);
            }
            else {
                gl.glNormal3d(-v1.normal.x, -v1.normal.y, -v1.normal.z);
            }
            gl.glTexCoord2d(v1.u, v1.v);
            gl.glVertex3d(v1.position.x, v1.position.y, v1.position.z);

            //-----------------------------------------------------------------
            if ( !flipNormals ) {
                gl.glNormal3d(v2.normal.x, v2.normal.y, v2.normal.z);
              }
              else {
                gl.glNormal3d(-v2.normal.x, -v2.normal.y, -v2.normal.z);
            }
            gl.glTexCoord2d(v2.u, v2.v);
            gl.glVertex3d(v2.position.x, v2.position.y, v2.position.z);
        }
        gl.glEnd();
    }

}

//===========================================================================
//= EOF                                                                     =
//===========================================================================