sigonasr2/jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* Fix Blender 2.62 issue with uint64_t

Browse Source 
git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@9186 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
This commit is contained in:
Sha..om 2012-02-23 14:05:59 +00:00
parent 321c50c514
commit 06f5ad5bce
1 changed files with 316 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

631
engine/src/blender/com/jme3/scene/plugins/blender/file/Structure.java
View File

@ -1,315 +1,316 @@
/* /*
* Copyright (c) 2009-2010 jMonkeyEngine * Copyright (c) 2009-2010 jMonkeyEngine
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are * modification, are permitted provided that the following conditions are
* met: * met:
* *
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* *
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* *
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software * may be used to endorse or promote products derived from this software
* without specific prior written permission. * without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package com.jme3.scene.plugins.blender.file; package com.jme3.scene.plugins.blender.file;
import com.jme3.scene.plugins.blender.BlenderContext; import com.jme3.scene.plugins.blender.BlenderContext;
import com.jme3.scene.plugins.blender.exceptions.BlenderFileException; import com.jme3.scene.plugins.blender.exceptions.BlenderFileException;
import java.util.HashMap; import java.util.HashMap;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
* A class representing a single structure in the file. * A class representing a single structure in the file.
* @author Marcin Roguski * @author Marcin Roguski
*/ */
public class Structure implements Cloneable { public class Structure implements Cloneable {
/** The blender context. */ /** The blender context. */
private BlenderContext blenderContext; private BlenderContext blenderContext;
/** The address of the block that fills the structure. */ /** The address of the block that fills the structure. */
private transient Long oldMemoryAddress; private transient Long oldMemoryAddress;
/** The type of the structure. */ /** The type of the structure. */
private String type; private String type;
/** /**
* The fields of the structure. Each field consists of a pair: name-type. * The fields of the structure. Each field consists of a pair: name-type.
*/ */
private Field[] fields; private Field[] fields;
/** /**
* Constructor that copies the data of the structure. * Constructor that copies the data of the structure.
* @param structure * @param structure
* the structure to copy. * the structure to copy.
* @param blenderContext * @param blenderContext
* the blender context of the structure * the blender context of the structure
* @throws CloneNotSupportedException * @throws CloneNotSupportedException
* this exception should never be thrown * this exception should never be thrown
*/ */
private Structure(Structure structure, BlenderContext blenderContext) throws CloneNotSupportedException { private Structure(Structure structure, BlenderContext blenderContext) throws CloneNotSupportedException {
type = structure.type; type = structure.type;
fields = new Field[structure.fields.length]; fields = new Field[structure.fields.length];
for (int i = 0; i < fields.length; ++i) { for (int i = 0; i < fields.length; ++i) {
fields[i] = (Field) structure.fields[i].clone(); fields[i] = (Field) structure.fields[i].clone();
} }
this.blenderContext = blenderContext; this.blenderContext = blenderContext;
this.oldMemoryAddress = structure.oldMemoryAddress; this.oldMemoryAddress = structure.oldMemoryAddress;
} }
/** /**
* Constructor. Loads the structure from the given stream during instance creation. * Constructor. Loads the structure from the given stream during instance creation.
* @param inputStream * @param inputStream
* the stream we read the structure from * the stream we read the structure from
* @param names * @param names
* the names from which the name of structure and its fields will be taken * the names from which the name of structure and its fields will be taken
* @param types * @param types
* the names of types for the structure * the names of types for the structure
* @param blenderContext * @param blenderContext
* the blender context * the blender context
* @throws BlenderFileException * @throws BlenderFileException
* this exception occurs if the amount of fields, defined in the file, is negative * this exception occurs if the amount of fields, defined in the file, is negative
*/ */
public Structure(BlenderInputStream inputStream, String[] names, String[] types, BlenderContext blenderContext) throws BlenderFileException { public Structure(BlenderInputStream inputStream, String[] names, String[] types, BlenderContext blenderContext) throws BlenderFileException {
int nameIndex = inputStream.readShort(); int nameIndex = inputStream.readShort();
type = types[nameIndex]; type = types[nameIndex];
this.blenderContext = blenderContext; this.blenderContext = blenderContext;
int fieldsAmount = inputStream.readShort(); int fieldsAmount = inputStream.readShort();
if (fieldsAmount < 0) { if (fieldsAmount < 0) {
throw new BlenderFileException("The amount of fields of " + this.type + " structure cannot be negative!"); throw new BlenderFileException("The amount of fields of " + this.type + " structure cannot be negative!");
} }
if (fieldsAmount > 0) { if (fieldsAmount > 0) {
fields = new Field[fieldsAmount]; fields = new Field[fieldsAmount];
for (int i = 0; i < fieldsAmount; ++i) { for (int i = 0; i < fieldsAmount; ++i) {
int typeIndex = inputStream.readShort(); int typeIndex = inputStream.readShort();
nameIndex = inputStream.readShort(); nameIndex = inputStream.readShort();
fields[i] = new Field(names[nameIndex], types[typeIndex], blenderContext); fields[i] = new Field(names[nameIndex], types[typeIndex], blenderContext);
} }
} }
this.oldMemoryAddress = Long.valueOf(-1L); this.oldMemoryAddress = Long.valueOf(-1L);
} }
/** /**
* This method fills the structure with data. * This method fills the structure with data.
* @param inputStream * @param inputStream
* the stream we read data from, its read cursor should be placed at the start position of the data for the * the stream we read data from, its read cursor should be placed at the start position of the data for the
* structure * structure
* @throws BlenderFileException * @throws BlenderFileException
* an exception is thrown when the blend file is somehow invalid or corrupted * an exception is thrown when the blend file is somehow invalid or corrupted
*/ */
public void fill(BlenderInputStream inputStream) throws BlenderFileException { public void fill(BlenderInputStream inputStream) throws BlenderFileException {
int position = inputStream.getPosition(); int position = inputStream.getPosition();
inputStream.setPosition(position - 8 - inputStream.getPointerSize()); inputStream.setPosition(position - 8 - inputStream.getPointerSize());
this.oldMemoryAddress = Long.valueOf(inputStream.readPointer()); this.oldMemoryAddress = Long.valueOf(inputStream.readPointer());
inputStream.setPosition(position); inputStream.setPosition(position);
for (Field field : fields) { for (Field field : fields) {
field.fill(inputStream); field.fill(inputStream);
} }
} }
/** /**
* This method returns the value of the filed with a given name. * This method returns the value of the filed with a given name.
* @param fieldName * @param fieldName
* the name of the field * the name of the field
* @return the value of the field or null if no field with a given name is found * @return the value of the field or null if no field with a given name is found
*/ */
public Object getFieldValue(String fieldName) { public Object getFieldValue(String fieldName) {
for (Field field : fields) { for (Field field : fields) {
if (field.name.equalsIgnoreCase(fieldName)) { if (field.name.equalsIgnoreCase(fieldName)) {
return field.value; return field.value;
} }
} }
return null; return null;
} }
/** /**
* This method returns the value of the filed with a given name. The structure is considered to have flat fields * This method returns the value of the filed with a given name. The structure is considered to have flat fields
* only (no substructures). * only (no substructures).
* @param fieldName * @param fieldName
* the name of the field * the name of the field
* @return the value of the field or null if no field with a given name is found * @return the value of the field or null if no field with a given name is found
*/ */
public Object getFlatFieldValue(String fieldName) { public Object getFlatFieldValue(String fieldName) {
for (Field field : fields) { for (Field field : fields) {
Object value = field.value; Object value = field.value;
if (field.name.equalsIgnoreCase(fieldName)) { if (field.name.equalsIgnoreCase(fieldName)) {
return value; return value;
} else if (value instanceof Structure) { } else if (value instanceof Structure) {
value = ((Structure) value).getFlatFieldValue(fieldName); value = ((Structure) value).getFlatFieldValue(fieldName);
if (value != null) {//we can compare references here, since we use one static object as a NULL field value if (value != null) {//we can compare references here, since we use one static object as a NULL field value
return value; return value;
} }
} }
} }
return null; return null;
} }
/** /**
* This methos should be used on structures that are of a 'ListBase' type. It creates a List of structures that are * This methos should be used on structures that are of a 'ListBase' type. It creates a List of structures that are
* held by this structure within the blend file. * held by this structure within the blend file.
* @param blenderContext * @param blenderContext
* the blender context * the blender context
* @return a list of filled structures * @return a list of filled structures
* @throws BlenderFileException * @throws BlenderFileException
* this exception is thrown when the blend file structure is somehow invalid or corrupted * this exception is thrown when the blend file structure is somehow invalid or corrupted
* @throws IllegalArgumentException * @throws IllegalArgumentException
* this exception is thrown if the type of the structure is not 'ListBase' * this exception is thrown if the type of the structure is not 'ListBase'
*/ */
public List<Structure> evaluateListBase(BlenderContext blenderContext) throws BlenderFileException { public List<Structure> evaluateListBase(BlenderContext blenderContext) throws BlenderFileException {
if (!"ListBase".equals(this.type)) { if (!"ListBase".equals(this.type)) {
throw new IllegalStateException("This structure is not of type: 'ListBase'"); throw new IllegalStateException("This structure is not of type: 'ListBase'");
} }
Pointer first = (Pointer) this.getFieldValue("first"); Pointer first = (Pointer) this.getFieldValue("first");
Pointer last = (Pointer) this.getFieldValue("last"); Pointer last = (Pointer) this.getFieldValue("last");
long currentAddress = 0; long currentAddress = 0;
long lastAddress = last.getOldMemoryAddress(); long lastAddress = last.getOldMemoryAddress();
List<Structure> result = new LinkedList<Structure>(); List<Structure> result = new LinkedList<Structure>();
while (currentAddress != lastAddress) { while (currentAddress != lastAddress) {
currentAddress = first.getOldMemoryAddress(); currentAddress = first.getOldMemoryAddress();
Structure structure = first.fetchData(blenderContext.getInputStream()).get(0); Structure structure = first.fetchData(blenderContext.getInputStream()).get(0);
result.add(structure); result.add(structure);
first = (Pointer) structure.getFlatFieldValue("next"); first = (Pointer) structure.getFlatFieldValue("next");
} }
return result; return result;
} }
/** /**
* This method returns the type of the structure. * This method returns the type of the structure.
* @return the type of the structure * @return the type of the structure
*/ */
public String getType() { public String getType() {
return type; return type;
} }
/** /**
* This method returns the amount of fields for the current structure. * This method returns the amount of fields for the current structure.
* @return the amount of fields for the current structure * @return the amount of fields for the current structure
*/ */
public int getFieldsAmount() { public int getFieldsAmount() {
return fields.length; return fields.length;
} }
/** /**
* This method returns the field name of the given index. * This method returns the field name of the given index.
* @param fieldIndex * @param fieldIndex
* the index of the field * the index of the field
* @return the field name of the given index * @return the field name of the given index
*/ */
public String getFieldName(int fieldIndex) { public String getFieldName(int fieldIndex) {
return fields[fieldIndex].name; return fields[fieldIndex].name;
} }
/** /**
* This method returns the field type of the given index. * This method returns the field type of the given index.
* @param fieldIndex * @param fieldIndex
* the index of the field * the index of the field
* @return the field type of the given index * @return the field type of the given index
*/ */
public String getFieldType(int fieldIndex) { public String getFieldType(int fieldIndex) {
return fields[fieldIndex].type; return fields[fieldIndex].type;
} }
/** /**
* This method returns the address of the structure. The strucutre should be filled with data otherwise an exception * This method returns the address of the structure. The strucutre should be filled with data otherwise an exception
* is thrown. * is thrown.
* @return the address of the feature stored in this structure * @return the address of the feature stored in this structure
*/ */
public Long getOldMemoryAddress() { public Long getOldMemoryAddress() {
if (oldMemoryAddress.longValue() == -1L) { if (oldMemoryAddress.longValue() == -1L) {
throw new IllegalStateException("Call the 'fill' method and fill the structure with data first!"); throw new IllegalStateException("Call the 'fill' method and fill the structure with data first!");
} }
return oldMemoryAddress; return oldMemoryAddress;
} }
/** /**
* This method returns the name of the structure. If the structure has an ID field then the name is returned. * This method returns the name of the structure. If the structure has an ID field then the name is returned.
* Otherwise the name does not exists and the method returns null. * Otherwise the name does not exists and the method returns null.
* @return the name of the structure read from the ID field or null * @return the name of the structure read from the ID field or null
*/ */
public String getName() { public String getName() {
Object fieldValue = this.getFieldValue("ID"); Object fieldValue = this.getFieldValue("ID");
if(fieldValue instanceof Structure) { if(fieldValue instanceof Structure) {
Structure id = (Structure)fieldValue; Structure id = (Structure)fieldValue;
return id == null ? null : id.getFieldValue("name").toString().substring(2);//blender adds 2-charactes as a name prefix return id == null ? null : id.getFieldValue("name").toString().substring(2);//blender adds 2-charactes as a name prefix
} }
return null; return null;
} }
@Override @Override
public String toString() { public String toString() {
StringBuilder result = new StringBuilder("struct ").append(type).append(" {\n"); StringBuilder result = new StringBuilder("struct ").append(type).append(" {\n");
for (int i = 0; i < fields.length; ++i) { for (int i = 0; i < fields.length; ++i) {
result.append(fields[i].toString()).append('\n'); result.append(fields[i].toString()).append('\n');
} }
return result.append('}').toString(); return result.append('}').toString();
} }
@Override @Override
public Object clone() throws CloneNotSupportedException { public Object clone() throws CloneNotSupportedException {
return new Structure(this, blenderContext); return new Structure(this, blenderContext);
} }
/** /**
* This enum enumerates all known data types that can be found in the blend file. * This enum enumerates all known data types that can be found in the blend file.
* @author Marcin Roguski * @author Marcin Roguski
*/ */
/*package*/ /*package*/
static enum DataType { static enum DataType {
CHARACTER, SHORT, INTEGER, LONG, FLOAT, DOUBLE, VOID, STRUCTURE, POINTER; CHARACTER, SHORT, INTEGER, LONG, FLOAT, DOUBLE, VOID, STRUCTURE, POINTER;
/** The map containing the known primary types. */ /** The map containing the known primary types. */
private static final Map<String, DataType> PRIMARY_TYPES = new HashMap<String, DataType>(10); private static final Map<String, DataType> PRIMARY_TYPES = new HashMap<String, DataType>(10);
static { static {
PRIMARY_TYPES.put("char", CHARACTER); PRIMARY_TYPES.put("char", CHARACTER);
PRIMARY_TYPES.put("uchar", CHARACTER); PRIMARY_TYPES.put("uchar", CHARACTER);
PRIMARY_TYPES.put("short", SHORT); PRIMARY_TYPES.put("short", SHORT);
PRIMARY_TYPES.put("ushort", SHORT); PRIMARY_TYPES.put("ushort", SHORT);
PRIMARY_TYPES.put("int", INTEGER); PRIMARY_TYPES.put("int", INTEGER);
PRIMARY_TYPES.put("long", LONG); PRIMARY_TYPES.put("long", LONG);
PRIMARY_TYPES.put("ulong", LONG); PRIMARY_TYPES.put("ulong", LONG);
PRIMARY_TYPES.put("float", FLOAT); PRIMARY_TYPES.put("uint64_t", LONG);
PRIMARY_TYPES.put("double", DOUBLE); PRIMARY_TYPES.put("float", FLOAT);
PRIMARY_TYPES.put("void", VOID); PRIMARY_TYPES.put("double", DOUBLE);
} PRIMARY_TYPES.put("void", VOID);
}
/**
* This method returns the data type that is appropriate to the given type name. WARNING! The type recognition /**
* is case sensitive! * This method returns the data type that is appropriate to the given type name. WARNING! The type recognition
* @param type * is case sensitive!
* the type name of the data * @param type
* @param blenderContext * the type name of the data
* the blender context * @param blenderContext
* @return appropriate enum value to the given type name * the blender context
* @throws BlenderFileException * @return appropriate enum value to the given type name
* this exception is thrown if the given type name does not exist in the blend file * @throws BlenderFileException
*/ * this exception is thrown if the given type name does not exist in the blend file
public static DataType getDataType(String type, BlenderContext blenderContext) throws BlenderFileException { */
DataType result = PRIMARY_TYPES.get(type); public static DataType getDataType(String type, BlenderContext blenderContext) throws BlenderFileException {
if (result != null) { DataType result = PRIMARY_TYPES.get(type);
return result; if (result != null) {
} return result;
if (blenderContext.getDnaBlockData().hasStructure(type)) { }
return STRUCTURE; if (blenderContext.getDnaBlockData().hasStructure(type)) {
} return STRUCTURE;
throw new BlenderFileException("Unknown data type: " + type); }
} throw new BlenderFileException("Unknown data type: " + type);
} }
} }
}