com.jme3.texture.plugins.gdx.GdxTGALoader Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mms-gdx Show documentation
Show all versions of mms-gdx Show documentation
A game engine compatible with MikuMikuDance.
The newest version!
/*
* Copyright (c) 2009-2010 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.texture.plugins.gdx;
import com.jme3.math.FastMath;
import com.jme3.asset.AssetLoader;
import com.jme3.texture.Image;
import com.jme3.util.BufferUtils;
import com.jme3.asset.AssetInfo;
import com.jme3.asset.TextureKey;
import com.jme3.texture.Image.Format;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
/**
* TextureManager provides static methods for building a
* Texture object. Typically, the information supplied is the
* filename and the texture properties.
*
* @author Mark Powell
* @author Joshua Slack - cleaned, commented, added ability to read 16bit true color and color-mapped TGAs.
* @author Kirill Vainer - ported to jME3
* @version $Id: TGALoader.java 4131 2009-03-19 20:15:28Z blaine.dev $
*/
public final class GdxTGALoader implements AssetLoader {
// 0 - no image data in file
public static final int TYPE_NO_IMAGE = 0;
// 1 - uncompressed, color-mapped image
public static final int TYPE_COLORMAPPED = 1;
// 2 - uncompressed, true-color image
public static final int TYPE_TRUECOLOR = 2;
// 3 - uncompressed, black and white image
public static final int TYPE_BLACKANDWHITE = 3;
// 9 - run-length encoded, color-mapped image
public static final int TYPE_COLORMAPPED_RLE = 9;
// 10 - run-length encoded, true-color image
public static final int TYPE_TRUECOLOR_RLE = 10;
// 11 - run-length encoded, black and white image
public static final int TYPE_BLACKANDWHITE_RLE = 11;
public Object load(AssetInfo info) throws IOException{
if (!(info.getKey() instanceof TextureKey))
throw new IllegalArgumentException("Texture assets must be loaded using a TextureKey");
boolean flip = ((TextureKey)info.getKey()).isFlipY();
InputStream in = null;
try {
in = info.openStream();
Image img = load(in, flip);
return img;
} finally {
if (in != null){
in.close();
}
}
}
/**
* loadImage is a manual image loader which is entirely
* independent of AWT. OUT: RGB888 or RGBA8888 Image object
*
* @return Image object that contains the
* image, either as a RGB888 or RGBA8888
* @param flip
* Flip the image vertically
* @param exp32
* Add a dummy Alpha channel to 24b RGB image.
* @param fis
* InputStream of an uncompressed 24b RGB or 32b RGBA TGA
* @throws java.io.IOException
*/
public static Image load(InputStream in, boolean flip) throws IOException {
boolean flipH = false;
// open a stream to the file
DataInputStream dis = new DataInputStream(new BufferedInputStream(in));
// ---------- Start Reading the TGA header ---------- //
// length of the image id (1 byte)
int idLength = dis.readUnsignedByte();
// Type of color map (if any) included with the image
// 0 - no color map data is included
// 1 - a color map is included
int colorMapType = dis.readUnsignedByte();
// Type of image being read:
int imageType = dis.readUnsignedByte();
// Read Color Map Specification (5 bytes)
// Index of first color map entry (if we want to use it, uncomment and remove extra read.)
// short cMapStart = flipEndian(dis.readShort());
dis.readShort();
// number of entries in the color map
short cMapLength = flipEndian(dis.readShort());
// number of bits per color map entry
int cMapDepth = dis.readUnsignedByte();
// Read Image Specification (10 bytes)
// horizontal coordinate of lower left corner of image. (if we want to use it, uncomment and remove extra read.)
// int xOffset = flipEndian(dis.readShort());
dis.readShort();
// vertical coordinate of lower left corner of image. (if we want to use it, uncomment and remove extra read.)
// int yOffset = flipEndian(dis.readShort());
dis.readShort();
// width of image - in pixels
int width = flipEndian(dis.readShort());
// height of image - in pixels
int height = flipEndian(dis.readShort());
// bits per pixel in image.
int pixelDepth = dis.readUnsignedByte();
int imageDescriptor = dis.readUnsignedByte();
if ((imageDescriptor & 32) != 0) // bit 5 : if 1, flip top/bottom ordering
flip = !flip;
if ((imageDescriptor & 16) != 0) // bit 4 : if 1, flip left/right ordering
flipH = !flipH;
// ---------- Done Reading the TGA header ---------- //
// Skip image ID
if (idLength > 0)
in.skip(idLength);
ColorMapEntry[] cMapEntries = null;
if (colorMapType != 0) {
// read the color map.
int bytesInColorMap = (cMapDepth * cMapLength) >> 3;
int bitsPerColor = Math.min(cMapDepth/3 , 8);
byte[] cMapData = new byte[bytesInColorMap];
in.read(cMapData);
// Only go to the trouble of constructing the color map
// table if this is declared a color mapped image.
if (imageType == TYPE_COLORMAPPED || imageType == TYPE_COLORMAPPED_RLE) {
cMapEntries = new ColorMapEntry[cMapLength];
int alphaSize = cMapDepth - (3*bitsPerColor);
float scalar = 255f / (FastMath.pow(2, bitsPerColor) - 1);
float alphaScalar = 255f / (FastMath.pow(2, alphaSize) - 1);
for (int i = 0; i < cMapLength; i++) {
ColorMapEntry entry = new ColorMapEntry();
int offset = cMapDepth * i;
entry.red = (byte)(int)(getBitsAsByte(cMapData, offset, bitsPerColor) * scalar);
entry.green = (byte)(int)(getBitsAsByte(cMapData, offset+bitsPerColor, bitsPerColor) * scalar);
entry.blue = (byte)(int)(getBitsAsByte(cMapData, offset+(2*bitsPerColor), bitsPerColor) * scalar);
if (alphaSize <= 0)
entry.alpha = (byte)255;
else
entry.alpha = (byte)(int)(getBitsAsByte(cMapData, offset+(3*bitsPerColor), alphaSize) * alphaScalar);
cMapEntries[i] = entry;
}
}
}
// Allocate image data array
Format format;
byte[] rawData = null;
int dl;
if (pixelDepth == 32) {
rawData = new byte[width * height * 4];
dl = 4;
} else {
rawData = new byte[width * height * 3];
dl = 3;
}
int rawDataIndex = 0;
if (imageType == TYPE_TRUECOLOR) {
byte red = 0;
byte green = 0;
byte blue = 0;
byte alpha = 0;
// Faster than doing a 16-or-24-or-32 check on each individual pixel,
// just make a seperate loop for each.
if (pixelDepth == 16) {
byte[] data = new byte[2];
float scalar = 255f/31f;
for (int i = 0; i <= (height - 1); i++) {
if (!flip)
rawDataIndex = (height - 1 - i) * width * dl;
for (int j = 0; j < width; j++) {
data[1] = dis.readByte();
data[0] = dis.readByte();
rawData[rawDataIndex++] = (byte)(int)(getBitsAsByte(data, 1, 5) * scalar);
rawData[rawDataIndex++] = (byte)(int)(getBitsAsByte(data, 6, 5) * scalar);
rawData[rawDataIndex++] = (byte)(int)(getBitsAsByte(data, 11, 5) * scalar);
if (dl == 4) {
// create an alpha channel
alpha = getBitsAsByte(data, 0, 1);
if (alpha == 1) alpha = (byte)255;
rawData[rawDataIndex++] = alpha;
} else {
rawData[rawDataIndex++] = (byte)0xff;
}
}
}
format = dl == 4 ? Format.RGBA8 : Format.RGB8;
} else if (pixelDepth == 24){
for (int y = 0; y < height; y++) {
if (!flip)
rawDataIndex = (height - 1 - y) * width * dl;
else
rawDataIndex = y * width * dl;
// dis.readFully(rawData, rawDataIndex, width * dl);
for (int x = 0; x < width; x++) {
// read scanline
blue = dis.readByte();
green = dis.readByte();
red = dis.readByte();
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
}
}
format = Format.RGB8;
} else if (pixelDepth == 32){
for (int i = 0; i <= (height - 1); i++) {
if (!flip)
rawDataIndex = (height - 1 - i) * width * dl;
for (int j = 0; j < width; j++) {
blue = dis.readByte();
green = dis.readByte();
red = dis.readByte();
alpha = dis.readByte();
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
rawData[rawDataIndex++] = alpha;
}
}
format = Format.RGBA8;
}else{
throw new IOException("Unsupported TGA true color depth: "+pixelDepth);
}
} else if( imageType == TYPE_TRUECOLOR_RLE ) {
byte red = 0;
byte green = 0;
byte blue = 0;
byte alpha = 0;
// Faster than doing a 16-or-24-or-32 check on each individual pixel,
// just make a seperate loop for each.
if( pixelDepth == 32 ){
for( int i = 0; i <= ( height - 1 ); ++i ){
if( !flip ){
rawDataIndex = ( height - 1 - i ) * width * dl;
}
for( int j = 0; j < width; ++j ){
// Get the number of pixels the next chunk covers (either packed or unpacked)
int count = dis.readByte();
if( ( count & 0x80 ) != 0 ){
// Its an RLE packed block - use the following 1 pixel for the next pixels
count &= 0x07f;
j += count;
blue = dis.readByte();
green = dis.readByte();
red = dis.readByte();
alpha = dis.readByte();
while( count-- >= 0 ){
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
rawData[rawDataIndex++] = alpha;
}
} else{
// Its not RLE packed, but the next pixels are raw.
j += count;
while( count-- >= 0 ){
blue = dis.readByte();
green = dis.readByte();
red = dis.readByte();
alpha = dis.readByte();
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
rawData[rawDataIndex++] = alpha;
}
}
}
}
format = Format.RGBA8;
} else if( pixelDepth == 24 ){
for( int i = 0; i <= ( height - 1 ); i++ ){
if( !flip ){
rawDataIndex = ( height - 1 - i ) * width * dl;
}
for( int j = 0; j < width; ++j ){
// Get the number of pixels the next chunk covers (either packed or unpacked)
int count = dis.readByte();
if( ( count & 0x80 ) != 0 ){
// Its an RLE packed block - use the following 1 pixel for the next pixels
count &= 0x07f;
j += count;
blue = dis.readByte();
green = dis.readByte();
red = dis.readByte();
while( count-- >= 0 ){
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
}
} else{
// Its not RLE packed, but the next pixels are raw.
j += count;
while( count-- >= 0 ){
blue = dis.readByte();
green = dis.readByte();
red = dis.readByte();
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
}
}
}
}
format = Format.RGB8;
} else if( pixelDepth == 16 ){
byte[] data = new byte[ 2 ];
float scalar = 255f / 31f;
for( int i = 0; i <= ( height - 1 ); i++ ){
if( !flip ){
rawDataIndex = ( height - 1 - i ) * width * dl;
}
for( int j = 0; j < width; j++ ){
// Get the number of pixels the next chunk covers (either packed or unpacked)
int count = dis.readByte();
if( ( count & 0x80 ) != 0 ){
// Its an RLE packed block - use the following 1 pixel for the next pixels
count &= 0x07f;
j += count;
data[1] = dis.readByte();
data[0] = dis.readByte();
blue = (byte) (int) ( getBitsAsByte( data, 1, 5 ) * scalar );
green = (byte) (int) ( getBitsAsByte( data, 6, 5 ) * scalar );
red = (byte) (int) ( getBitsAsByte( data, 11, 5 ) * scalar );
while( count-- >= 0 ){
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
}
} else{
// Its not RLE packed, but the next pixels are raw.
j += count;
while( count-- >= 0 ){
data[1] = dis.readByte();
data[0] = dis.readByte();
blue = (byte) (int) ( getBitsAsByte( data, 1, 5 ) * scalar );
green = (byte) (int) ( getBitsAsByte( data, 6, 5 ) * scalar );
red = (byte) (int) ( getBitsAsByte( data, 11, 5 ) * scalar );
rawData[rawDataIndex++] = red;
rawData[rawDataIndex++] = green;
rawData[rawDataIndex++] = blue;
}
}
}
}
format = Format.RGB8;
} else{
throw new IOException( "Unsupported TGA true color depth: " + pixelDepth );
}
} else if( imageType == TYPE_COLORMAPPED ){
int bytesPerIndex = pixelDepth / 8;
if (bytesPerIndex == 1) {
for (int i = 0; i <= (height - 1); i++) {
if (!flip)
rawDataIndex = (height - 1 - i) * width * dl;
for (int j = 0; j < width; j++) {
int index = dis.readUnsignedByte();
if (index >= cMapEntries.length || index < 0)
throw new IOException("TGA: Invalid color map entry referenced: "+index);
ColorMapEntry entry = cMapEntries[index];
rawData[rawDataIndex++] = entry.red;
rawData[rawDataIndex++] = entry.green;
rawData[rawDataIndex++] = entry.blue;
if (dl == 4) {
rawData[rawDataIndex++] = entry.alpha;
} else {
rawData[rawDataIndex++] = (byte)0xff;
}
}
}
} else if (bytesPerIndex == 2) {
for (int i = 0; i <= (height - 1); i++) {
if (!flip)
rawDataIndex = (height - 1 - i) * width * dl;
for (int j = 0; j < width; j++) {
int index = flipEndian(dis.readShort());
if (index >= cMapEntries.length || index < 0)
throw new IOException("TGA: Invalid color map entry referenced: "+index);
ColorMapEntry entry = cMapEntries[index];
rawData[rawDataIndex++] = entry.red;
rawData[rawDataIndex++] = entry.green;
rawData[rawDataIndex++] = entry.blue;
if (dl == 4) {
rawData[rawDataIndex++] = entry.alpha;
} else {
rawData[rawDataIndex++] = (byte)0xff;
}
}
}
} else {
throw new IOException("TGA: unknown colormap indexing size used: "+bytesPerIndex);
}
format = dl == 4 ? Format.RGBA8 : Format.RGB8;
} else {
throw new IOException("Grayscale TGA not supported");
}
in.close();
Image textureImage = new Image();
textureImage.setFormat(format);
textureImage.setWidth(FastMath.nearestPowerOfTwo(width));
textureImage.setHeight(FastMath.nearestPowerOfTwo(height));
if (format != Format.RGBA8) {
rawData = resize2(width, height, FastMath.nearestPowerOfTwo(width), FastMath.nearestPowerOfTwo(height), rawData);
//textureImage.setFormat(Format.RGBA8);
} else {
rawData = resize(width, height, FastMath.nearestPowerOfTwo(width), FastMath.nearestPowerOfTwo(height), rawData);
}
ByteBuffer bb = BufferUtils.createByteBuffer(rawData.length);
for(int i=0;i= w1 * h1) {
index = 0;
}
for(int i=0;i<4;i++) {
out[(x + y * w2)*4+i] = buf[index * 4 + i];
}
}
}
return out;
}
private static byte[] resize2(int w1,int h1, int w2, int h2, byte[] buf) {
// w2 = w1;
// h2 = h1;
if (w1 == w2 && h1 == h2) {
//return buf;
}
byte[] out = new byte[w2 * h2 * 3];
float f1 = ((float)w1) / (float)w2;
float f2 = ((float)h1) / (float)h2;
for(int x = 0;x= w1 * h1) {
index = 0;
}
for(int i=0;i<3;i++) {
out[(x + y * w2)*3+i] = buf[index * 3 + i];
}
}
}
return out;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy