Example #1
0
 /**
  * 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());
 }
Example #2
0
  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;
  }
Example #3
0
  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();
    }
  }
Example #4
0
  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) {
        }
    }
  }
Example #5
0
  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) {
        }
    }
  }
Example #6
0
  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) {
        }
    }
  }