maxloader.java

world wind java sdk load 3D model

/*
 * MaxLoader.java
 *
 * Created on February 12, 2008, 10:19 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package model;

import java.awt.Color;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
 *
 * @author RodgersGB
 * modifications made by Brian Wood
 */
class MaxLoader implements MaxConstants {
    private File file;
    private String baseDir;
    private boolean loaded = false;
    private FileInputStream fileInputStream;
    private DataInputStream dataInputStream;
    private Model3D.BoundingBox boundingBox = null;
    private float minx, maxx, miny, maxy, minz, maxz;
    
// Global chunks
    private Chunk currentChunk, tempChunk;
    
// the model
    private Model3D model = null;
    
    // Constructor
    public MaxLoader() {
        currentChunk = new Chunk();
        tempChunk = new Chunk();
        model = new Model3D();
    }
    
    // Verified
    public Model3D load(String path) throws IOException {
        String strMessage;
        
        String tokens[] = path.split("/");
        baseDir = "/";
        for(int i = 0; i < tokens.length - 1; i++) {
            baseDir += tokens[i] + "/";
        }
        
        dataInputStream = new DataInputStream(MaxLoader.class.getResourceAsStream("/" + path));
        
        if(dataInputStream == null){
            return null;
        }
        
        readChunkHeader(currentChunk);
        
        if (currentChunk.id != TYPE_3DS_FILE) {
            System.err.println("Unable to load PRIMARY chuck from file!");
            return null;
        }
        
        processNextChunk(currentChunk);
        
        //computeNormals();
        
        model.setBoundingBox(new Model3D.BoundingBox(minx, maxx, miny, maxy, minz, maxz));
        
        dataInputStream.close();
        
        return model;
    }
    
    private void processNextChunk(Chunk root) throws IOException {
        int version = 0;
        byte buffer[] = null;
        
        currentChunk = new Chunk();
        
        while (root.bytesRead < root.length) {
            readChunkHeader(currentChunk);
            
            switch (currentChunk.id) {
                case TYPE_3DS_VERSION:
                    version = readInt(currentChunk);
                    
                    if (version > 0x03)
                        System.err.println("This 3DS file is over version 3 so it may load incorrectly");
                    break;
                    
                case TYPE_MESH_DATA:
                    readChunkHeader(tempChunk);
                    readBytes(tempChunk, tempChunk.length - tempChunk.bytesRead);
                    currentChunk.bytesRead += tempChunk.bytesRead;
                    processNextChunk(currentChunk);
                    break;
                    
                case TYPE_MATERIAL:
                    Model3D.Material m = new Model3D.Material();
                    processMaterial(m, currentChunk);
                    model.addMaterial(m);
                    break;
                    
                case TYPE_NAMED_OBJECT:
                    Model3D.ModelObject obj = new Model3D.ModelObject();
                    obj.name = readString(currentChunk);
                    getObjectChunk(obj, currentChunk);
                    model.addObject(obj);
                    break;
                    
                case TYPE_KEY_FRAME:
                    processKeyFrame(currentChunk);
                    break;
                    
                default:
                    readBytes(currentChunk, currentChunk.length - currentChunk.bytesRead);
                    break;
            }
            root.bytesRead += currentChunk.bytesRead;
        }
        
        currentChunk = root;
    }
    
    private void processKeyFrame(Chunk root) throws IOException {
        currentChunk = new Chunk();
        
        while (root.bytesRead < root.length) {
            readChunkHeader(currentChunk);
            
            switch (currentChunk.id) {
                default:
                    readBytes(currentChunk, currentChunk.length - currentChunk.bytesRead);
                    break;
            }
            root.bytesRead += currentChunk.bytesRead;
        }
        currentChunk = root;
    }
    
    private void readChunkHeader(Chunk c) throws IOException {
        c.bytesRead = 0;
        c.id = this.readShort(c);
        c.length = this.readInt(c);
    }
    
    private void getObjectChunk(Model3D.ModelObject object, Chunk root) throws IOException {
        currentChunk = new Chunk();
        
        while (root.bytesRead < root.length) {
            readChunkHeader(currentChunk);
            
            switch (currentChunk.id) {
                case TYPE_TRIANGLE_OBJECT:
                    getObjectChunk(object, currentChunk);
                    break;
                    
                case TYPE_DIRECT_LIGHT:
                    readBytes(currentChunk, currentChunk.length - currentChunk.bytesRead);
                    break;
                    
                case TYPE_POINT_LIST:
                    readVertices(object, currentChunk);
                    break;
                    
                case TYPE_FACE_LIST:
                    readFaceList(object, currentChunk);
                    break;
                    
                case TYPE_MAT_FACE_LIST:
                    readObjectMaterial(object, currentChunk);
                    readBytes(currentChunk, currentChunk.length - currentChunk.bytesRead);
                    break;
                    
                case TYPE_MAT_UV:
                    object.hasTexture = true;
                    model.addMaterial(new Model3D.Material());
                    object.materialID = 0;
                    readUVCoordinates(object, currentChunk);
                    break;
                    
                default:
                    readBytes(currentChunk, currentChunk.length - currentChunk.bytesRead);
                    break;
            }
            root.bytesRead += currentChunk.bytesRead;
        }
        
        currentChunk = root;
    }
    
    private void processMaterial(Model3D.Material material, Chunk root) throws IOException {
        byte buffer[] = null;
        
        currentChunk = new Chunk();
        
        while (root.bytesRead < root.length) {
            readChunkHeader(currentChunk);
            
            switch (currentChunk.id) {
                case TYPE_MATERIAL_NAME:
                    material.name = readString(currentChunk);
                    readBytes(currentChunk, currentChunk.length - currentChunk.bytesRead);
                    break;
                    
                case TYPE_MAT_AMBIENT:
                    material.setAmbientColor(readColor(currentChunk));
                    break;
                    
                case TYPE_MAT_SPECULAR:
                    material.setSpecularColor(readColor(currentChunk));
                    break;
                    
                case TYPE_MAT_DIFFUSE:
                    material.setDiffuseColor(readColor(currentChunk));
                    break;
                    
                case TYPE_MAT_SHININESS:
                    float shin = 1.0f+127.0f*readPercentage(currentChunk);
                    material.setShininess(shin);
                    break;
                    
                case TYPE_MAT_SHININESS2:
                    float shin2 = 1.0f+127.0f*readPercentage(currentChunk);
                    break;
                    
                case TYPE_MAT_TRANSPARENCY:
                    float trans = readPercentage(currentChunk);
                    break;
                    
                case TYPE_MAT_2_SIDED:
                    readBytes(currentChunk, currentChunk.length - currentChunk.bytesRead);
                    break;