Examples with Type com.jme3.scene.VertexBuffer.Type used on opensource projects

Example 61 with Type

use of com.jme3.scene.VertexBuffer.Type in project jmonkeyengine by jMonkeyEngine.

the class ShaderNodeVariable method read.

/**
     * jme serialization (not used)
     *
     * @param im the importer
     * @throws IOException
     */
@Override
public void read(JmeImporter im) throws IOException {
    InputCapsule ic = (InputCapsule) im.getCapsule(this);
    name = ic.readString("name", "");
    type = ic.readString("type", "");
    nameSpace = ic.readString("nameSpace", "");
    condition = ic.readString("condition", null);
    shaderOutput = ic.readBoolean("shaderOutput", false);
    multiplicity = ic.readString("multiplicity", null);
}

Example 62 with Type

use of com.jme3.scene.VertexBuffer.Type in project jmonkeyengine by jMonkeyEngine.

the class TGALoader method load.

/**
     * <code>loadImage</code> is a manual image loader which is entirely
     * independent of AWT. OUT: RGB888 or RGBA8888 Image object
     * 
     * 
    
     * @param in
     *            InputStream of an uncompressed 24b RGB or 32b RGBA TGA
     * @param flip
     *            Flip the image vertically
     * @return <code>Image</code> object that contains the
     *         image, either as a RGB888 or RGBA8888
     * @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 (// bit 5 : if 1, flip top/bottom ordering
    (imageDescriptor & 32) != 0) {
        flip = !flip;
    }
    if (// bit 4 : if 1, flip left/right ordering
    (imageDescriptor & 16) != 0) {
        flipH = !flipH;
    }
    // Skip image ID
    if (idLength > 0) {
        dis.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];
        dis.read(cMapData);
        // 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;
        // 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;
                    }
                }
            }
            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.BGR8;
        } 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;
        // 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 <count> 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 <count> 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 <count> 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 <count> 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 <count> 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 <count> 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.blue;
                    rawData[rawDataIndex++] = entry.green;
                    rawData[rawDataIndex++] = entry.red;
                    if (dl == 4) {
                        rawData[rawDataIndex++] = entry.alpha;
                    }
                }
            }
        } 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.blue;
                    rawData[rawDataIndex++] = entry.green;
                    rawData[rawDataIndex++] = entry.red;
                    if (dl == 4) {
                        rawData[rawDataIndex++] = entry.alpha;
                    }
                }
            }
        } else {
            throw new IOException("TGA: unknown colormap indexing size used: " + bytesPerIndex);
        }
        format = dl == 4 ? Format.RGBA8 : Format.RGB8;
    } else {
        throw new IOException("Monochrome and RLE colormapped images are not supported");
    }
    in.close();
    // Get a pointer to the image memory
    ByteBuffer scratch = BufferUtils.createByteBuffer(rawData.length);
    scratch.clear();
    scratch.put(rawData);
    scratch.rewind();
    // Create the Image object
    Image textureImage = new Image();
    textureImage.setFormat(format);
    textureImage.setWidth(width);
    textureImage.setHeight(height);
    textureImage.setData(scratch);
    return textureImage;
}

Example 63 with Type

use of com.jme3.scene.VertexBuffer.Type in project jmonkeyengine by jMonkeyEngine.

the class KTXWriter method write.

/**
     * Writes an image with the given params
     * 
     * textureType, allows one to write textureArrays, Texture3D, and TextureCubeMaps.
     * Texture2D will write a 2D image.
     * Note that the fileName should contain the extension (.ktx sounds like a wise choice)
     * @param image the image to write
     * @param textureType the texture type
     * @param fileName the name of the file to write
     */
public void write(Image image, Class<? extends Texture> textureType, String fileName) {
    FileOutputStream outs = null;
    try {
        File file = new File(filePath + "/" + fileName);
        outs = new FileOutputStream(file);
        DataOutput out = new DataOutputStream(outs);
        //fileID
        out.write(fileIdentifier);
        //endianness
        out.writeInt(0x04030201);
        GLImageFormat format = getGlFormat(image.getFormat());
        //glType
        out.writeInt(format.dataType);
        //glTypeSize
        out.writeInt(1);
        //glFormat
        out.writeInt(format.format);
        //glInernalFormat
        out.writeInt(format.internalFormat);
        //glBaseInternalFormat
        out.writeInt(format.format);
        //pixelWidth
        out.writeInt(image.getWidth());
        //pixelHeight
        out.writeInt(image.getHeight());
        int pixelDepth = 1;
        int numberOfArrayElements = 1;
        int numberOfFaces = 1;
        if (image.getDepth() > 1) {
            //pixelDepth
            if (textureType == Texture3D.class) {
                pixelDepth = image.getDepth();
            }
        }
        if (image.getData().size() > 1) {
            //numberOfArrayElements
            if (textureType == TextureArray.class) {
                numberOfArrayElements = image.getData().size();
            }
            //numberOfFaces                
            if (textureType == TextureCubeMap.class) {
                numberOfFaces = image.getData().size();
            }
        }
        out.writeInt(pixelDepth);
        out.writeInt(numberOfArrayElements);
        out.writeInt(numberOfFaces);
        int numberOfMipmapLevels = 1;
        //numberOfMipmapLevels
        if (image.hasMipmaps()) {
            numberOfMipmapLevels = image.getMipMapSizes().length;
        }
        out.writeInt(numberOfMipmapLevels);
        //bytesOfKeyValueData
        String keyValues = "KTXorientation\0S=r,T=u\0";
        int bytesOfKeyValueData = keyValues.length() + 4;
        int padding = 3 - ((bytesOfKeyValueData + 3) % 4);
        bytesOfKeyValueData += padding;
        out.writeInt(bytesOfKeyValueData);
        //keyAndValueByteSize
        out.writeInt(bytesOfKeyValueData - 4 - padding);
        //values
        out.writeBytes(keyValues);
        pad(padding, out);
        int offset = 0;
        //iterate over data
        for (int mipLevel = 0; mipLevel < numberOfMipmapLevels; mipLevel++) {
            int width = Math.max(1, image.getWidth() >> mipLevel);
            int height = Math.max(1, image.getHeight() >> mipLevel);
            int imageSize;
            if (image.hasMipmaps()) {
                imageSize = image.getMipMapSizes()[mipLevel];
            } else {
                imageSize = width * height * image.getFormat().getBitsPerPixel() / 8;
            }
            out.writeInt(imageSize);
            for (int arrayElem = 0; arrayElem < numberOfArrayElements; arrayElem++) {
                for (int face = 0; face < numberOfFaces; face++) {
                    int nbPixelWritten = 0;
                    for (int depth = 0; depth < pixelDepth; depth++) {
                        ByteBuffer byteBuffer = image.getData(getSlice(face, arrayElem));
                        // BufferUtils.ensureLargeEnough(byteBuffer, imageSize);
                        log.log(Level.FINE, "position {0}", byteBuffer.position());
                        byteBuffer.position(offset);
                        byte[] b = getByteBufferArray(byteBuffer, imageSize);
                        out.write(b);
                        nbPixelWritten = b.length;
                    }
                    //cube padding
                    if (numberOfFaces == 6 && numberOfArrayElements == 0) {
                        padding = 3 - ((nbPixelWritten + 3) % 4);
                        pad(padding, out);
                    }
                }
            }
            //mip padding
            log.log(Level.FINE, "skipping {0}", (3 - ((imageSize + 3) % 4)));
            padding = 3 - ((imageSize + 3) % 4);
            pad(padding, out);
            offset += imageSize;
        }
    } catch (FileNotFoundException ex) {
        Logger.getLogger(KTXWriter.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IOException ex) {
        Logger.getLogger(KTXWriter.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
        try {
            if (outs != null) {
                outs.close();
            }
        } catch (IOException ex) {
            Logger.getLogger(KTXWriter.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Example 64 with Type

use of com.jme3.scene.VertexBuffer.Type in project jmonkeyengine by jMonkeyEngine.

the class ShaderNodeLoaderDelegate method updateVariableFromList.

/**
     * search a variable in the given list and updates its type and namespace
     *
     * @param var the variable to update
     * @param list the variables list
     * @return true if the variable has been found and updated
     */
protected boolean updateVariableFromList(ShaderNodeVariable var, List<ShaderNodeVariable> list) {
    for (ShaderNodeVariable shaderNodeVariable : list) {
        if (shaderNodeVariable.getName().equals(var.getName())) {
            var.setType(shaderNodeVariable.getType());
            var.setMultiplicity(shaderNodeVariable.getMultiplicity());
            var.setNameSpace(shaderNode.getName());
            return true;
        }
    }
    return false;
}

Example 65 with Type

use of com.jme3.scene.VertexBuffer.Type in project jmonkeyengine by jMonkeyEngine.

the class ShaderNodeLoaderDelegate method readShaderNodeDefinition.

/**
     * effectively reads the ShaderNodesDefinitions block
     *
     * @param statements the list of statements to parse
     * @param key the ShaderNodeDefinitionKey
     * @throws IOException
     */
protected void readShaderNodeDefinition(List<Statement> statements, ShaderNodeDefinitionKey key) throws IOException {
    boolean isLoadDoc = key instanceof ShaderNodeDefinitionKey && ((ShaderNodeDefinitionKey) key).isLoadDocumentation();
    for (Statement statement : statements) {
        String[] split = statement.getLine().split("[ \\{]");
        String line = statement.getLine();
        if (line.startsWith("Type")) {
            String type = line.substring(line.lastIndexOf(':') + 1).trim();
            shaderNodeDefinition.setType(Shader.ShaderType.valueOf(type));
        } else if (line.startsWith("Shader ")) {
            readShaderStatement(statement);
            shaderNodeDefinition.getShadersLanguage().add(shaderLanguage);
            shaderNodeDefinition.getShadersPath().add(shaderName);
        } else if (line.startsWith("Documentation")) {
            if (isLoadDoc) {
                String doc = "";
                for (Statement statement1 : statement.getContents()) {
                    doc += "\n" + statement1.getLine();
                }
                shaderNodeDefinition.setDocumentation(doc);
            }
        } else if (line.startsWith("Input")) {
            varNames = "";
            for (Statement statement1 : statement.getContents()) {
                shaderNodeDefinition.getInputs().add(readVariable(statement1));
            }
        } else if (line.startsWith("Output")) {
            varNames = "";
            for (Statement statement1 : statement.getContents()) {
                if (statement1.getLine().trim().equals("None")) {
                    shaderNodeDefinition.setNoOutput(true);
                } else {
                    shaderNodeDefinition.getOutputs().add(readVariable(statement1));
                }
            }
        } else {
            throw new MatParseException("one of Type, Shader, Documentation, Input, Output", split[0], statement);
        }
    }
}