readerobj.java

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

            if ( lineOfText.startsWith("o ") || lineOfText.startsWith("g ") ) {
                if ( vertexPositionsArray.size() > 0 ) {
                    addMeshToGroup(meshGroup,
                                   nextGeometricObjectName,
                                   vertexPositionsArray,
                                   vertexNormalsArray,
                                   vertexTextureCoordinatesArray,
                                   triangleDatasetsArray,
                                   nextTexturesArray,
                                   texture_span_triangleRange_table,
                                   nextMaterialsArray,
                                   material_triangleRange_table);
                }

                // Process next object name
                StringTokenizer auxStringTokenizer;
                auxStringTokenizer = new StringTokenizer(lineOfText, " ");
                auxStringTokenizer.nextToken();
                nextGeometricObjectName = auxStringTokenizer.nextToken();

                // Clear accumulated states variables
                if ( vertexPositionsArray.size() > 0 ) {
                    nextTexturesArray = new ArrayList<RGBAImage>();
                    nextMaterialsArray = new ArrayList<Material>();
                    triangleDatasetsArray = new ArrayList<_ReaderObjVertex[]>();
                    material_triangleRange_table = new ArrayList<int[]>();
                    texture_span_triangleRange_table =
                        new ArrayList<ArrayList<int[]>>();
                    auxInitialTextureMapping = new ArrayList<int[]>();
                    int[] auxInitialRange = new int[2];
                    auxInitialRange[0] = auxInitialRange[1] = 0;
                    auxInitialTextureMapping.add(auxInitialRange);
                    texture_span_triangleRange_table.add(auxInitialTextureMapping);
                    textureIndex = 0;
                }
            }
        }

        // Build the last mesh from remaining vertexes, if any
        if ( vertexPositionsArray.size() > 0 ) {
            addMeshToGroup(meshGroup,
                           nextGeometricObjectName,
                           vertexPositionsArray,
                           vertexNormalsArray,
                           vertexTextureCoordinatesArray,
                           triangleDatasetsArray,
                           nextTexturesArray, texture_span_triangleRange_table,
                           nextMaterialsArray, material_triangleRange_table);
        }

        //-----------------------------------------------------------------
        TriangleMeshGroup finalTriangleMeshGroup = new TriangleMeshGroup();
        for( TriangleMesh auxTriangleMesh:meshGroup ) {
            Vertex[] auxTriangleMeshVertexArray;
            auxTriangleMeshVertexArray = auxTriangleMesh.getVertexes();
            if ( auxTriangleMeshVertexArray.length > 0 ) {
                finalTriangleMeshGroup.addMesh(auxTriangleMesh);
            }
        }
        return finalTriangleMeshGroup;
    }

    private static void
    addMeshToGroup(
        ArrayList<TriangleMesh> meshGroup,
        String nextGeometricObjectName,
        ArrayList<Vector3D> vertexPositionsArray,
        ArrayList<Vector3D> vertexNormalsArray,
        ArrayList<Vector3D> vertexTextureCoordinatesArray,
        ArrayList<_ReaderObjVertex[]> triangleDatasetsArray,
        ArrayList<RGBAImage> nextTexturesArray,
        ArrayList<ArrayList<int[]>> texture_span_triangleRange_table,
        ArrayList<Material> nextMaterialsArray,
        ArrayList<int[]> material_triangleRange_table
    )
    {
        int i;
        TriangleMesh newTriangleMesh;
        newTriangleMesh = new TriangleMesh();

        //- If there are no specified materials, add a default one --------
        if ( nextMaterialsArray.size() == 0 ) {
            Material m;
            m = new Material();
            m.setName("default obj material");
            nextMaterialsArray.add(m);
        }

        //- Convert vertex data from obj format to VSDK format ------------
        ArrayList<_ReaderObjVertex> finalVertexes;        
        HashMap<_ReaderObjVertex, Integer> usedCombinedVertexes;

        finalVertexes = new ArrayList<_ReaderObjVertex>();
        usedCombinedVertexes = new HashMap<_ReaderObjVertex, Integer>();
        int combinedVertexCount = 0;

        for( i = 0; i < triangleDatasetsArray.size(); i++ ) {
            _ReaderObjVertex p1 = triangleDatasetsArray.get(i)[0];
            _ReaderObjVertex p2 = triangleDatasetsArray.get(i)[1];
            _ReaderObjVertex p3 = triangleDatasetsArray.get(i)[2];

            if ( !usedCombinedVertexes.containsKey(p1) ) {
                usedCombinedVertexes.put(p1, combinedVertexCount);
                combinedVertexCount++;
                finalVertexes.add(new _ReaderObjVertex(p1));
            }
            p1.vertexPositionIndex = usedCombinedVertexes.get(p1);

            if ( !usedCombinedVertexes.containsKey(p2) ) {
                usedCombinedVertexes.put(p2, combinedVertexCount);
                combinedVertexCount++;
                finalVertexes.add(new _ReaderObjVertex(p2));
            }
            p2.vertexPositionIndex = usedCombinedVertexes.get(p2);
            
            if ( !usedCombinedVertexes.containsKey(p3) ) {
                usedCombinedVertexes.put(p3, combinedVertexCount);
                combinedVertexCount++;
                finalVertexes.add(new _ReaderObjVertex(p3));
            }
            p3.vertexPositionIndex = usedCombinedVertexes.get(p3);
        }

        //- Build the mesh vertexes ---------------------------------------
        Vertex newVertexArray[];
        int ti, ni;
        Vector3D p, n;
        Matrix4x4 R = new Matrix4x4();

        R.axisRotation(Math.toRadians(90), new Vector3D(1, 0, 0));
        newVertexArray = new Vertex[finalVertexes.size()];
        for ( i = 0; i < finalVertexes.size(); i++ ) {
            // Position
            p = vertexPositionsArray.get(
                finalVertexes.get(i).vertexPositionIndex-1);
            p = R.multiply(p);
            newVertexArray[i] = new Vertex(p);
            // Texture coordinates
            ti = finalVertexes.get(i).vertexTextureCoordinateIndex - 1;
            if ( ti >= 0 ) {
                newVertexArray[i].u = vertexTextureCoordinatesArray.get(ti).x;
                newVertexArray[i].v = vertexTextureCoordinatesArray.get(ti).y;
            }
            else {
                newVertexArray[i].u = newVertexArray[i].v = 0.0;
            }
            // Normals
            ni = finalVertexes.get(i).vertexNormalIndex - 1;
            if ( ni >= 0 && ni < vertexNormalsArray.size() ) {
                n = vertexNormalsArray.get(ni);
                n = R.multiply(n);
                newVertexArray[i].setNormal(n);
            }
            else {
                newVertexArray[i].setNormal(new Vector3D(0, 0, 0));
            }
        }
        newTriangleMesh.setVertexes(newVertexArray);
        
        //- Build the mesh triangles --------------------------------------
        Triangle newTriangleArray[];

        newTriangleArray = new Triangle[triangleDatasetsArray.size()];
        for ( i = 0; i < newTriangleArray.length; i++ ) {
            newTriangleArray[i] = new Triangle();
            newTriangleArray[i].p0 =
               triangleDatasetsArray.get(i)[0].vertexPositionIndex;
            newTriangleArray[i].p1 =
               triangleDatasetsArray.get(i)[1].vertexPositionIndex;
            newTriangleArray[i].p2 =
               triangleDatasetsArray.get(i)[2].vertexPositionIndex;
        }
        newTriangleMesh.setTriangles(newTriangleArray);
        
        //- Process materials ---------------------------------------------
        Material materials[];
        materials = new Material[nextMaterialsArray.size()];

        for ( i = 0; i < materials.length; i++ ) {
            materials[i] = nextMaterialsArray.get(i);
            if ( materials[i] == null ) {
                materials[i] = new Material();
            }
        }
        newTriangleMesh.setMaterials(materials);

        //- Process material ranges ---------------------------------------
        int auxMaterialRange[];
        auxMaterialRange = new int[2];
        auxMaterialRange[0] = triangleDatasetsArray.size();
        auxMaterialRange[1] = nextMaterialsArray.size()-1;
        material_triangleRange_table.add(auxMaterialRange);

        int materialRanges[][];

        materialRanges = new int[material_triangleRange_table.size()][2];
        for ( i = 1; i < material_triangleRange_table.size(); i++ ) {
            materialRanges[i][0] = material_triangleRange_table.get(i)[0];
            materialRanges[i][1] = material_triangleRange_table.get(i-1)[1];
        }
        newTriangleMesh.setMaterialRanges(materialRanges);

        //- Process textures ----------------------------------------------
        RGBAImage newTextureArray[];

        newTextureArray = new RGBAImage[nextTexturesArray.size()];
        for ( i = 0; i < newTextureArray.length; i++ ) {
            newTextureArray[i]=nextTexturesArray.get(i);
        }
        newTriangleMesh.setTextures(newTextureArray);

        //- Process texture ranges ----------------------------------------
        int numTextureSpans = 0;
        for ( int textureIndex = 0;
              textureIndex < texture_span_triangleRange_table.size();
              textureIndex++ ) {
            for( int j = 0;
                 j < texture_span_triangleRange_table.get(textureIndex).size();
                 j++ ) {
                numTextureSpans++;
            }
        }        

        int textureRanges[][] = new int[numTextureSpans][2];
        i = 0;
        for ( int textureIndex = 0;
              textureIndex < texture_span_triangleRange_table.size();
              textureIndex++ ) {
            for( int j = 0;
                 j < texture_span_triangleRange_table.get(textureIndex).size();
                 j++ ) {
                textureRanges[i][0] =
                  texture_span_triangleRange_table.get(textureIndex).get(j)[1];
                textureRanges[i][1] = textureIndex;
                i++;
            }
        }
        quickSortTriangleRange(textureRanges, 0, textureRanges.length-1);
        newTriangleMesh.setTextureRanges(textureRanges);

        //- Finalize mesh and add to group --------------------------------
        if ( vertexNormalsArray.size() < 0 ) {
            newTriangleMesh.calculateNormals();
        }
        newTriangleMesh.reorientateNormals();
        newTriangleMesh.setName(nextGeometricObjectName);
        meshGroup.add(newTriangleMesh);
    }

    private static void quickSortTriangleRange(int a[][], int izq, int der)
    {
        int i = izq;
        int j = der;
        int pivote = a[(izq+der)/2][0];
        int aux0;
        int aux1;
        do {
            while ( a[i][0] < pivote ) i++;
            while ( a[j][0] > pivote ) j--;
            if ( i <= j ) {
                aux0 = a[i][0];
                a[i][0] = a[j][0];
                a[j][0] = aux0;
                aux1 = a[i][1];
                a[i][1] = a[j][1];
                a[j][1] = aux1;
                i++;
                j--;
            }
        } while ( i <= j );
        if ( izq < j ) quickSortTriangleRange(a, izq, j);
        if ( i < der ) quickSortTriangleRange(a, i, der);
    }

    private static RGBAImage
    obtainTextureFromFile(String lineOfText, String fileName)
    {
        StringTokenizer st = new StringTokenizer(lineOfText, " ");
        st.nextToken(); //usemap
        String dirObj = new File(fileName).getParentFile().getAbsolutePath();
        String nomImage = st.nextToken();
        if ( nomImage.equals("(null)") ) {
            return null;
        }
        try