/**
* Writes the ETC1Data with a PKM header to the given file.
*
* @param file the file.
*/
public void write(FileHandle file) {
DataOutputStream write = null;
byte[] buffer = new byte[10 * 1024];
int writtenBytes = 0;
compressedData.position(0);
compressedData.limit(compressedData.capacity());
try {
write = new DataOutputStream(new GZIPOutputStream(file.write(false)));
write.writeInt(compressedData.capacity());
while (writtenBytes != compressedData.capacity()) {
int bytesToWrite = Math.min(compressedData.remaining(), buffer.length);
compressedData.get(buffer, 0, bytesToWrite);
write.write(buffer, 0, bytesToWrite);
writtenBytes += bytesToWrite;
}
} catch (Exception e) {
throw new GdxRuntimeException("Couldn't write PKM file to '" + file + "'", e);
} finally {
if (write != null)
try {
write.close();
} catch (Exception e) {
}
}
compressedData.position(dataOffset);
compressedData.limit(compressedData.capacity());
}
private boolean saveScreenshot(byte[] screenshot, String fileName) {
int length = screenshot.length;
Bitmap fullScreenBitmap;
Bitmap centerSquareBitmap;
int[] colors = new int[length / 4];
if (colors.length != screenshotWidth * screenshotHeight || colors.length == 0) {
return false;
}
for (int i = 0; i < length; i += 4) {
colors[i / 4] =
android.graphics.Color.argb(
255, screenshot[i + 0] & 0xFF, screenshot[i + 1] & 0xFF, screenshot[i + 2] & 0xFF);
}
fullScreenBitmap =
Bitmap.createBitmap(
colors, 0, screenshotWidth, screenshotWidth, screenshotHeight, Config.ARGB_8888);
if (screenshotWidth < screenshotHeight) {
int verticalMargin = (screenshotHeight - screenshotWidth) / 2;
centerSquareBitmap =
Bitmap.createBitmap(
fullScreenBitmap, 0, verticalMargin, screenshotWidth, screenshotWidth);
} else if (screenshotWidth > screenshotHeight) {
int horizontalMargin = (screenshotWidth - screenshotHeight) / 2;
centerSquareBitmap =
Bitmap.createBitmap(
fullScreenBitmap, horizontalMargin, 0, screenshotHeight, screenshotHeight);
} else {
centerSquareBitmap =
Bitmap.createBitmap(fullScreenBitmap, 0, 0, screenshotWidth, screenshotHeight);
}
FileHandle image = Gdx.files.absolute(pathForScreenshot + fileName);
OutputStream stream = image.write(false);
try {
new File(pathForScreenshot + Constants.NO_MEDIA_FILE).createNewFile();
centerSquareBitmap.compress(Bitmap.CompressFormat.PNG, 100, stream);
stream.close();
} catch (IOException e) {
return false;
}
return true;
}
public static void save(SaveGame save) {
FileHandle file = Gdx.files.local(SAVE_FILE);
ObjectOutputStream out = null;
try {
out = new ObjectOutputStream(file.write(false));
} catch (IOException e2) {
e2.printStackTrace();
}
try {
out.writeObject(save);
} catch (IOException e1) {
e1.printStackTrace();
}
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void export(StillModel model, FileHandle file) {
ChunkWriter writer = new ChunkWriter();
// write version info
writer.newChunk(G3dConstants.VERSION_INFO);
writer.writeByte(G3dConstants.MAJOR_VERSION);
writer.writeByte(G3dConstants.MINOR_VERSION);
writer.endChunk();
// write still model
writer.newChunk(G3dConstants.STILL_MODEL);
writer.writeInt(model.subMeshes.length);
// write sub mesh
for (StillSubMesh mesh : model.subMeshes) {
// start sub mesh
writer.newChunk(G3dConstants.STILL_SUBMESH);
writer.writeString(mesh.name == null ? "" : mesh.name);
writer.writeInt(mesh.primitiveType);
// write vertex attributes
writer.newChunk(G3dConstants.VERTEX_ATTRIBUTES);
writer.writeInt(mesh.mesh.getVertexAttributes().size());
for (int i = 0; i < mesh.mesh.getVertexAttributes().size(); i++) {
VertexAttribute attribute = mesh.mesh.getVertexAttributes().get(i);
writer.newChunk(G3dConstants.VERTEX_ATTRIBUTE);
writer.writeInt(attribute.usage);
writer.writeInt(attribute.numComponents);
writer.writeString(attribute.alias);
writer.endChunk();
}
writer.endChunk();
// write vertices
writer.newChunk(G3dConstants.VERTEX_LIST);
int numFloats = mesh.mesh.getNumVertices() * mesh.mesh.getVertexSize() / 4;
float[] vertices = new float[numFloats];
mesh.mesh.getVertices(vertices);
writer.writeInt(mesh.mesh.getNumVertices());
writer.writeFloats(vertices);
writer.endChunk();
// write indices
writer.newChunk(G3dConstants.INDEX_LIST);
int numShorts = mesh.mesh.getNumIndices();
short[] indices = new short[numShorts];
mesh.mesh.getIndices(indices);
writer.writeInt(numShorts);
writer.writeShorts(indices);
writer.endChunk();
// end sub mesh
writer.endChunk();
}
// end still model
writer.endChunk();
// write to file
OutputStream out = null;
try {
out = file.write(false);
writer.writeToStream(out);
} catch (IOException e) {
throw new GdxRuntimeException(
"An error occured while exporting the still model, " + e.getMessage(), e);
} finally {
if (out != null)
try {
out.close();
} catch (IOException e) {
}
}
}
public static void export(SkeletonModel model, FileHandle file) {
ChunkWriter writer = new ChunkWriter();
// write version info
writer.newChunk(G3dConstants.VERSION_INFO);
writer.writeByte(G3dConstants.MAJOR_VERSION);
writer.writeByte(G3dConstants.MINOR_VERSION);
writer.endChunk();
// write skeleton model
writer.newChunk(G3dConstants.SKELETON_MODEL);
writer.writeInt(model.subMeshes.length);
for (SkeletonSubMesh mesh : model.subMeshes) {
// writes skeleton submesh
writer.newChunk(G3dConstants.SKELETON_SUBMESH);
writer.writeString(mesh.name == null ? "" : mesh.name);
writer.writeInt(mesh.primitiveType);
// write vertex attributes
writer.newChunk(G3dConstants.VERTEX_ATTRIBUTES);
writer.writeInt(mesh.mesh.getVertexAttributes().size());
for (int i = 0; i < mesh.mesh.getVertexAttributes().size(); i++) {
VertexAttribute attribute = mesh.mesh.getVertexAttributes().get(i);
writer.newChunk(G3dConstants.VERTEX_ATTRIBUTE);
writer.writeInt(attribute.usage);
writer.writeInt(attribute.numComponents);
writer.writeString(attribute.alias);
writer.endChunk();
}
writer.endChunk();
// write static components, sort of like a bind pose mesh
writer.newChunk(G3dConstants.VERTEX_LIST);
int numFloats = mesh.mesh.getNumVertices() * mesh.mesh.getVertexSize() / 4;
writer.writeInt(mesh.mesh.getNumVertices());
writer.writeFloats(mesh.vertices);
writer.endChunk();
// write indices
writer.newChunk(G3dConstants.INDEX_LIST);
int numShorts = mesh.mesh.getNumIndices();
writer.writeInt(numShorts);
writer.writeShorts(mesh.indices);
writer.endChunk();
// write bone weight
writer.newChunk(G3dConstants.BONE_WEIGHTS);
writer.writeInt(mesh.boneWeights.length);
for (float array[] : mesh.boneWeights) {
writer.newChunk(G3dConstants.BONE_WEIGHT);
writer.writeInt(array.length);
writer.writeFloats(array);
writer.endChunk();
}
writer.endChunk();
// write bone assignment
writer.newChunk(G3dConstants.BONE_ASSIGNMENTS);
writer.writeInt(mesh.boneAssignments.length);
for (int array[] : mesh.boneAssignments) {
writer.newChunk(G3dConstants.BONE_ASSIGNMENT);
writer.writeInt(array.length);
writer.writeInts(array);
writer.endChunk();
}
writer.endChunk();
// end skeleton submesh
writer.endChunk();
}
// Write Skeleton
writer.newChunk(G3dConstants.SKELETON);
// Write Skeleton hierarchy
writer.newChunk(G3dConstants.SKELETON_HIERARCHY);
writer.writeInt(model.skeleton.hierarchy.size);
for (SkeletonJoint joint : model.skeleton.hierarchy) {
writeSkeletonJoint(writer, joint);
}
// end Skeleton hierarchy
writer.endChunk();
// Write Skeleton animations
writer.newChunk(G3dConstants.SKELETON_ANIMATIONS);
writer.writeInt(model.skeleton.animations.size);
for (String animationName : model.skeleton.animations.keys()) {
writer.newChunk(G3dConstants.SKELETON_ANIMATION);
writer.writeString(animationName);
SkeletonAnimation animation = model.skeleton.animations.get(animationName);
writer.writeFloat(animation.totalDuration);
writer.writeInt(animation.perJointkeyFrames.length);
for (SkeletonKeyframe array[] : animation.perJointkeyFrames) {
writer.writeInt(array.length);
for (SkeletonKeyframe frame : array) {
writer.writeFloat(frame.timeStamp);
writer.writeInt(frame.parentIndex);
writer.writeFloat(frame.position.x);
writer.writeFloat(frame.position.y);
writer.writeFloat(frame.position.z);
writer.writeFloat(frame.rotation.w);
writer.writeFloat(frame.rotation.x);
writer.writeFloat(frame.rotation.y);
writer.writeFloat(frame.rotation.z);
writer.writeFloat(frame.scale.x);
writer.writeFloat(frame.scale.y);
writer.writeFloat(frame.scale.z);
}
}
writer.endChunk();
}
// end Skeleton animations
writer.endChunk();
// end Skeleton
writer.endChunk();
// end skeleton model
writer.endChunk();
// write to file
OutputStream out = null;
try {
out = file.write(false);
writer.writeToStream(out);
} catch (IOException e) {
throw new GdxRuntimeException(
"An error occured while exporting the still model, " + e.getMessage(), e);
} finally {
if (out != null)
try {
out.close();
} catch (IOException e) {
}
}
}
public static void export(KeyframedModel model, FileHandle file) {
ChunkWriter writer = new ChunkWriter();
// write version info
writer.newChunk(G3dConstants.VERSION_INFO);
writer.writeByte(G3dConstants.MAJOR_VERSION);
writer.writeByte(G3dConstants.MINOR_VERSION);
writer.endChunk();
// write keyframed model
writer.newChunk(G3dConstants.KEYFRAMED_MODEL);
writer.writeInt(model.subMeshes.length);
for (KeyframedSubMesh mesh : model.subMeshes) {
// writes keyframed submesh
writer.newChunk(G3dConstants.KEYFRAMED_SUBMESH);
writer.writeString(mesh.name == null ? "" : mesh.name);
writer.writeInt(mesh.primitiveType);
writer.writeInt(mesh.animatedComponents);
writer.writeInt(mesh.animations.size);
// write vertex attributes
writer.newChunk(G3dConstants.VERTEX_ATTRIBUTES);
writer.writeInt(mesh.mesh.getVertexAttributes().size());
for (int i = 0; i < mesh.mesh.getVertexAttributes().size(); i++) {
VertexAttribute attribute = mesh.mesh.getVertexAttributes().get(i);
writer.newChunk(G3dConstants.VERTEX_ATTRIBUTE);
writer.writeInt(attribute.usage);
writer.writeInt(attribute.numComponents);
writer.writeString(attribute.alias);
writer.endChunk();
}
writer.endChunk();
// write static components, sort of like a bind pose mesh
writer.newChunk(G3dConstants.VERTEX_LIST);
int numFloats = mesh.mesh.getNumVertices() * mesh.mesh.getVertexSize() / 4;
float[] vertices = new float[numFloats];
mesh.mesh.getVertices(vertices);
writer.writeInt(mesh.mesh.getNumVertices());
writer.writeFloats(vertices);
writer.endChunk();
// write indices
writer.newChunk(G3dConstants.INDEX_LIST);
int numShorts = mesh.mesh.getNumIndices();
short[] indices = new short[numShorts];
mesh.mesh.getIndices(indices);
writer.writeInt(mesh.mesh.getNumIndices());
writer.writeShorts(indices);
writer.endChunk();
// write animations
for (String animationName : mesh.animations.keys()) {
KeyframedAnimation animation = mesh.animations.get(animationName);
// write keyframed animation
writer.newChunk(G3dConstants.KEYFRAMED_ANIMATION);
writer.writeString(animation.name);
writer.writeFloat(animation.frameDuration);
// write key frames
writer.writeInt(animation.keyframes.length);
for (Keyframe keyframe : animation.keyframes) {
// write keyframed
writer.newChunk(G3dConstants.KEYFRAMED_FRAME);
writer.writeFloat(keyframe.timeStamp);
writer.writeFloats(keyframe.vertices);
writer.endChunk();
}
// end keyframed animation
writer.endChunk();
}
// end keyframed submesh
writer.endChunk();
}
// end keyframed model
writer.endChunk();
// write to file
OutputStream out = null;
try {
out = file.write(false);
writer.writeToStream(out);
} catch (IOException e) {
throw new GdxRuntimeException(
"An error occured while exporting the still model, " + e.getMessage(), e);
} finally {
if (out != null)
try {
out.close();
} catch (IOException e) {
}
}
}
