/**
|
* Make a donation http://sourceforge.net/donate/index.php?group_id=98797
|
* Microcrowd.com
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2.1 of the License, or (at your option) any later version.
|
*
|
* This library is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
* Lesser General Public License for more details.
|
*
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
*
|
* Contact Josh DeFord jdeford@realvue.com
|
*/
|
|
package com.microcrowd.loader.java3d.max3ds;
|
|
import java.awt.Image;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.nio.BufferUnderflowException;
|
import java.nio.ByteBuffer;
|
import java.nio.ByteOrder;
|
import java.nio.channels.Channels;
|
import java.nio.channels.ReadableByteChannel;
|
import java.util.HashMap;
|
import java.util.logging.Level;
|
import java.util.logging.Logger;
|
import javax.media.j3d.Behavior;
|
import javax.media.j3d.BranchGroup;
|
import javax.media.j3d.Light;
|
import javax.media.j3d.Texture;
|
import javax.media.j3d.TransformGroup;
|
import javax.vecmath.Point3f;
|
import javax.vecmath.Vector3f;
|
import com.microcrowd.loader.java3d.max3ds.chunks.Chunk;
|
import com.microcrowd.loader.java3d.max3ds.data.KeyFramer;
|
import com.sun.j3d.loaders.SceneBase;
|
import com.sun.j3d.utils.image.TextureLoader;
|
|
/**
|
* A singleton flyweight factory responsible for chopping the
|
* data up and sending it to the corresponding
|
* chunks(which are flyweights ala the flyweight pattern)
|
* for processing.
|
* This will sequentially read a 3ds file, load or
|
* skip chunks and subchunks and initialize the data
|
* for the chunks.
|
* <p>
|
* Retrieved data may be stored as state in the ChunkChopper
|
* via {@link #pushData} for use by other chunks.
|
* <p>
|
* Features not supported; unknown chunks are skipped.
|
*/
|
public class ChunkChopper
|
{
|
private Logger logger = Logger.getLogger(ChunkChopper.class.getName());
|
|
private Loader3DS loader;
|
private BranchGroup sceneGroup;
|
private SceneBase base;
|
private HashMap dataMap;
|
private ByteBuffer chunkBuffer;
|
private Integer chunkID;
|
|
private TransformGroup currentGroup;
|
private String currentObjectName;
|
private ChunkTester chunkTester = new ChunkTester();
|
private Chunk mainChunk = new Chunk("MainChunk");
|
private ChunkMap chunkMap = new ChunkMap(mainChunk);
|
|
private KeyFramer keyFramer = new KeyFramer();
|
|
/** This should be turned on by Loader3DS to view debugging information. */
|
public static boolean debug;
|
|
/** Current chunk for which debugging info is viewed if debug == true */
|
public static Chunk debugChunk;
|
|
/**
|
* private singleton constructor.
|
*/
|
public ChunkChopper(){}
|
|
/**
|
* This sequentially parses the chunks out of the input stream and
|
* constructs the 3D entities represented within.
|
* A Chunk is a little endian data structure consists of a
|
* 6 byte header followed by subchunks and or data.
|
* The first short int(little endian) represent the id
|
* of the chunk. The next int represent the total
|
* length of the chunk(total of data, subchunks and chunk header).
|
* <p>
|
* The first chunk is the main chunk (id=4D4D) and its length
|
* is always the length of the file. It only contains sub chunks.
|
* Other chunks may contain data, subchunks or both. If the format
|
* of a chunk is unknown skipped.
|
* <p>
|
* Subclasses of chunk will all automagically load the subchunks.
|
* It is the programmers responsibility to ensure that the data
|
* preceeding the subchunks is loaded or skipped as
|
* required and that something useful is done with the data. If data from the
|
* subchunks is needed in order to initialize components then that code should be
|
* placed in {@link Chunk#initialize}. Otherwise the data may be dealt with in
|
* {@link Chunk#loadData}. Also, if a chunk has data preceeding its subchunks
|
* it communicates how many bytes long that data is by returning it from loadData.
|
* <p>
|
* This chopper reads a file in order from beginning to end
|
* @param inputStream the stream with the data to be parsed.
|
* @param loader the loader that will be configured from the data.
|
* @param modelName name of the model file for display purposes.
|
* @param modelSize size in bytes of the file to read.
|
*/
|
public synchronized SceneBase loadSceneBase(InputStream inputStream, Loader3DS loader, int modelSize)
|
{
|
this.loader = loader;
|
this.sceneGroup = new BranchGroup();
|
this.base = new SceneBase();
|
this.dataMap = new HashMap();
|
base.setSceneGroup(sceneGroup);
|
|
//FileChannel channel = null;
|
ReadableByteChannel channel = null;
|
try {
|
channel = Channels.newChannel(inputStream);
|
chunkBuffer = getByteBuffer(channel, modelSize);
|
//chunkBuffer = getDirectByteBuffer(channel, modelSize);
|
|
int mainChunkID = chunkBuffer.getShort();
|
long mainChunkLength = chunkBuffer.getInt();
|
|
long begin = System.currentTimeMillis();
|
logger.finest("\n\n\n STARTING SUBCUNKS " + (mainChunkLength - 61));
|
try {
|
loadSubChunks(mainChunk, 0);
|
}
|
catch(CannotChopException e){
|
|
}
|
logger.finest("FINISHED WITH THE SUBCHUNKS");
|
}
|
catch (Exception e) {
|
e.printStackTrace();
|
}
|
finally
|
{
|
try {
|
if(channel != null) {
|
channel.close();
|
}
|
} catch (Exception e){
|
//Just closing file.. don't care.
|
}
|
}
|
return base;
|
}
|
|
/**
|
* Allocates and loads a byte buffer from the channel
|
* @param channel the file channel to load the data from
|
* @return a direct byte buffer containing all the data of the channel at position 0
|
*/
|
public ByteBuffer getByteBuffer(ReadableByteChannel channel, int channelSize) throws IOException
|
{
|
ByteBuffer chunkBuffer = ByteBuffer.allocate(channelSize);
|
chunkBuffer.order(ByteOrder.LITTLE_ENDIAN);
|
channel.read(chunkBuffer);
|
chunkBuffer.position(0);
|
return chunkBuffer;
|
}
|
|
|
/**
|
* The base class Chunk takes care of loading subchunks for
|
* all chunks types. It occurs as follows:
|
* <ol>
|
* <li>The chunk id (short) is read
|
* <li>The chunk length(int) is read
|
* <li>A subchunk is looked up from the map of publish
|
* subchunk types of the current chunk.
|
* <li>If it isn't found during the lookup it is skipped.
|
* <li>Otherwise it is requested to {@link #pushData}
|
* <li>The return value, if there is one, is used to determine
|
* where its next subchunk is. A return value of 0 signifies
|
* that the next subchunk is nigh.
|
* <li>The chunk's subchunks are then loaded.
|
* <li>The chunks initialize method is called.
|
* </ol>
|
*/
|
protected void loadSubChunks(Chunk parentChunk, int level) throws CannotChopException
|
{
|
level++;
|
while(chunkBuffer.hasRemaining())//hasRemaining() evaluates limit - position.
|
{
|
chunkID = new Integer(chunkBuffer.getShort());
|
Chunk chunk = parentChunk.getSubChunk(chunkID);
|
|
int currentChunkLength = chunkBuffer.getInt() - 6; //length includes this 6 byte header.
|
int finishedPosition = chunkBuffer.position() + currentChunkLength;
|
int previousLimit = chunkBuffer.limit();
|
chunkBuffer.limit(chunkBuffer.position() + currentChunkLength);
|
|
if(debug) {
|
debug(parentChunk, level, chunkID, currentChunkLength, chunkBuffer.position(), chunkBuffer.limit());
|
}
|
if(chunk != null && currentChunkLength != 0) {
|
try {
|
chunk.loadData(this);
|
}
|
catch(BufferUnderflowException e){
|
chunkBuffer.position(finishedPosition);
|
chunkBuffer.limit(previousLimit);
|
throw new CannotChopException(" tried to read too much data from the buffer. Trying to recover.", e);
|
}
|
try {
|
if(chunkBuffer.hasRemaining()) {
|
loadSubChunks(chunk, level);
|
}
|
chunk.initialize(this);
|
}
|
catch(CannotChopException e){
|
logger.log(Level.SEVERE, chunk.toString() + "Trying to continue");
|
}
|
}
|
|
chunkBuffer.position(finishedPosition);
|
chunkBuffer.limit(previousLimit);
|
}
|
}
|
|
/**
|
* Gets the key framer chunk
|
* These should be their own objects instead of chunks.
|
*/
|
public KeyFramer getKeyFramer()
|
{
|
return keyFramer;
|
}
|
|
/**
|
* Adds a group to the choppers scene group
|
* and sets the current name and group.
|
* @param the name of the object to add which
|
* will also be the current name of the object
|
* the chopper is working with.
|
* @param group the current group that the chopper
|
* will be adding things too.
|
*/
|
public void addObject(String name, TransformGroup group)
|
{
|
sceneGroup.addChild(group);
|
currentGroup = group;
|
currentObjectName = name;
|
base.addNamedObject(name, group);
|
}
|
|
|
|
/**
|
* Gets the name of the current object
|
* the chopper is working with. The value returned
|
* from this generally is either set by a NamedObjectChunk
|
* and is the name of the name of the last object added
|
* or is the name set by setObjectName.
|
* @return the name of the current object being
|
* constructed.
|
*/
|
public String getObjectName()
|
{
|
return currentObjectName;
|
}
|
|
|
/**
|
* Sets the name of the current object.
|
* The name of the current object can also be set
|
* with {@link #addObject}
|
* @param name the name that the current object should be set to.
|
*/
|
public void setObjectName(String name)
|
{
|
currentObjectName = name;
|
}
|
|
/**
|
* Gets the group for the current object
|
* the chopper is working with. The value returned
|
* from this generally gets set by a NamedObjectChunk
|
* and is the name of the last object added.
|
* @return the group for the current object being
|
* constructed.
|
*/
|
public TransformGroup getGroup()
|
{
|
return currentGroup;
|
}
|
|
/**
|
* Used to store data that may later be used
|
* by another chunk.
|
* @param key the look up key.
|
* @param data the data to store.
|
*/
|
public void pushData(Object key, Object data)
|
{
|
dataMap.put(key, data);
|
}
|
|
/**
|
* Gets a datum that had been retrieved and stored
|
* via {@link #pushData} earlier and removes it.
|
* @param key the key used to store the datum earlier.
|
*/
|
public Object popData(Object key)
|
{
|
Object retVal = dataMap.remove(key);
|
return retVal;
|
}
|
|
/**
|
* Sets a named object in the loader.
|
* @param key the key name of the object
|
* @param value the named Object.
|
*/
|
public void setNamedObject(String key, Object value)
|
{
|
base.addNamedObject(key, value);
|
}
|
|
/**
|
* Returns true if there have been lights loaded.
|
* @return true if there are lights.
|
*/
|
public boolean hasLights()
|
{
|
return (base.getLightNodes() != null && base.getLightNodes().length > 0);
|
}
|
|
/**
|
* Adds a behavior to the scene base.
|
* @param behavior the behavior to add to the scene base.
|
*/
|
public void addBehaviorNode(Behavior behavior)
|
{
|
base.addBehaviorNode(behavior);
|
}
|
|
|
/**
|
* Adds a light to the scene base.
|
* @param light the light to add to the scene base.
|
*/
|
public void addLightNode(Light light)
|
{
|
base.addLightNode(light);
|
}
|
|
|
/**
|
* Adds a camera transform to the scene base.
|
* @param viewGroup the transform group to add as a view.
|
*/
|
public void addViewGroup(TransformGroup viewGroup)
|
{
|
base.addViewGroup(viewGroup);
|
}
|
|
/**
|
* Sets a named Object in the loader.
|
* @param key the key used as the name for which the object will be returned
|
*/
|
public Object getNamedObject(String key)
|
{
|
if(key == null)
|
return null;
|
return base.getNamedObjects().get(key);
|
}
|
|
/**
|
* Gets and cast the named object for the
|
* key provided. Its an error if its not
|
* a transform group.
|
*/
|
public TransformGroup getNamedTransformGroup(String key)
|
{
|
Object object = getNamedObject(key);
|
if(object instanceof TransformGroup)
|
{
|
return (TransformGroup)object;
|
}
|
else if (object != null)
|
{
|
logger.log(Level.INFO, "Retrieving " + key + " which is a named object but not useable because "+
|
" its not a transform group. Its a " + object.getClass().getName());
|
}
|
return null;
|
}
|
|
|
/**
|
* Gets a long from the chunk Buffer
|
*/
|
public long getLong()
|
{
|
return chunkBuffer.getLong();
|
}
|
|
/**
|
* Reads a short and returns it as a signed
|
* int.
|
*/
|
public int getShort()
|
{
|
return chunkBuffer.getShort();
|
}
|
|
/**
|
* Reads a short and returns it as an unsigned
|
* int.
|
*/
|
public int getUnsignedShort()
|
{
|
return chunkBuffer.getShort()&0xFFFF;
|
}
|
|
/**
|
* reads a float from the chunkBuffer.
|
*/
|
public float getFloat()
|
{
|
return chunkBuffer.getFloat();
|
}
|
|
/**
|
* Reads 3 floats x,z,y from the chunkbuffer.
|
* Since 3ds has z as up and y as pointing in whereas
|
* java3d has z as pointing forward and y as pointing up;
|
* this returns new Vector3f(x,-z,y)
|
*
|
*/
|
public Vector3f getVector()
|
{
|
return new Vector3f(getPoint());
|
}
|
/**
|
* Reads 3 floats x,z,y from the chunkbuffer.
|
* Since 3ds has z as up and y as pointing in whereas
|
* java3d has z as pointing forward and y as pointing up;
|
* this returns new Point3f(x,-z,y)
|
*/
|
public Point3f getPoint()
|
{
|
float x = chunkBuffer.getFloat();
|
float z = -chunkBuffer.getFloat();
|
float y = chunkBuffer.getFloat();
|
return new Point3f(x,y,z);
|
}
|
|
/**
|
* Reads an int and returns it
|
* @return the int read
|
*/
|
public int getInt()
|
{
|
return chunkBuffer.getInt();
|
}
|
|
/**
|
* Reads an int and returns it
|
* unsigned, any ints greater than MAX_INT
|
* will break.
|
*/
|
public int getUnsignedInt()
|
{
|
return chunkBuffer.getInt()&0xFFFFFFFF;
|
}
|
|
/**
|
* Reads a byte, unsigns it, returns the corresponding int.
|
* @return the unsigned int corresponding to the read byte.
|
*/
|
public int getUnsignedByte()
|
{
|
return chunkBuffer.get()&0xFF;
|
}
|
|
/**
|
* Reads a number of bytes corresponding to the
|
* number of bytes left in the current chunk and returns an array
|
* containing them.
|
* @return an array containing all the bytes for the current chunk.
|
*/
|
public byte[] getChunkBytes()
|
{
|
byte[] retVal = new byte[chunkBuffer.limit() - chunkBuffer.position()];
|
get(retVal);
|
return retVal;
|
}
|
|
/**
|
* Fills bytes with data from the chunk buffer.
|
* @param bytes the array to fill with data.
|
*/
|
public void get(byte[] bytes)
|
{
|
chunkBuffer.get(bytes);
|
}
|
|
|
/**
|
* Sets the data map used to store values
|
* that chunks may need to retrieve later.
|
* @param dataMap the hashmap that will be used to store
|
* and retrieve values for use by chunks.
|
*/
|
public void setDataMap(HashMap dataMap)
|
{
|
this.dataMap = dataMap;
|
}
|
|
|
/**
|
* This reads bytes until it gets 0x00 and returns
|
* the corresponding string.
|
*/
|
public String getString()
|
{
|
StringBuffer stringBuffer = new StringBuffer();
|
char charIn = (char)chunkBuffer.get();
|
while(charIn != 0x00)
|
{
|
stringBuffer.append(charIn);
|
charIn = (char)chunkBuffer.get();
|
}
|
return stringBuffer.toString();
|
}
|
|
/**
|
* Gets the id of the current chunk.
|
* @return id of the current chunk as read
|
* from the chunkBuffer. It will be a signed <code>short</code>.
|
*/
|
public Integer getID()
|
{
|
return chunkID;
|
}
|
|
/**
|
* Loads the image to server as a texture.
|
* @param textureImageName name of the image that
|
* is going to be set to be the texture.
|
*/
|
public Texture createTexture(String textureImageName)
|
{
|
Image image = loader.getTextureImage(textureImageName);
|
if(image == null)
|
{
|
System.err.println("Cannot load texture image " + textureImageName +
|
". Make sure it is in the directory with the model file. " +
|
"If its a bmp make sure JAI is installed.");
|
return null;
|
}
|
try
|
{
|
TextureLoader textureLoader = new TextureLoader(image, null);
|
return textureLoader.getTexture();
|
}
|
catch(Exception e){
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
/**
|
* prints some handy information... the chunk hierarchy.
|
*/
|
protected void debug(Chunk parentChunk, int level, Integer chunkID, long chunkLength, int position, long limit)
|
{
|
try {
|
for(int i=0; i<level; i++)
|
{
|
System.out.print(" ");
|
}
|
Object child = parentChunk.getSubChunk(chunkID);
|
int id = ((short)chunkID.intValue()) & 0xFFFF;
|
System.out.println(parentChunk + " is " +
|
(child==null?"skipping":"LOADING")+
|
": [id=" + Integer.toHexString(id) +
|
", object= <" + parentChunk.getSubChunk(chunkID) +
|
">, chunkLength=" + chunkLength +
|
", position=" + position +
|
" limit=" + limit + "]");
|
}
|
catch(Exception e){
|
//We're debugging.. its ok
|
e.printStackTrace();
|
}
|
}
|
|
/**
|
* Prints an exception and exits.
|
*/
|
private void exceptAndExit(Throwable exception)
|
{
|
logger.log(Level.SEVERE, "\nThe chunk for loadData method read too much or not enough data from the stream." +
|
" It needs be skipped or adjusted to read more or less data.");
|
exception.printStackTrace();
|
System.exit(3);
|
}
|
|
/**
|
* Convert the integer to an unsigned number.
|
* @param i the integer to convert.
|
*/
|
private static String byteString(int i)
|
{
|
final char[] digits = {
|
'0' , '1' , '2' , '3' , '4' , '5' ,
|
'6' , '7' , '8' , '9' , 'a' , 'b' ,
|
'c' , 'd' , 'e' , 'f' };
|
|
char[] buf = new char[2];
|
buf[1] = digits[i & 0xF];
|
i >>>= 4;
|
buf[0] = digits[i & 0xF];
|
|
return "0x" + new String(buf).toUpperCase();
|
}
|
}
|
