Examples with TexturePixel com.jme3.scene.plugins.blender.textures.TexturePixel used on opensource projects

Example 6 with TexturePixel

use of com.jme3.scene.plugins.blender.textures.TexturePixel in project jmonkeyengine by jMonkeyEngine.

the class TextureBlenderDDS method blend.

@Override
public Image blend(Image image, Image baseImage, BlenderContext blenderContext) {
    this.prepareImagesForBlending(image, baseImage);
    Format format = image.getFormat();
    int width = image.getWidth();
    int height = image.getHeight();
    int depth = image.getDepth();
    if (depth == 0) {
        depth = 1;
    }
    ArrayList<ByteBuffer> dataArray = new ArrayList<ByteBuffer>(depth);
    PixelInputOutput basePixelIO = null;
    float[][] compressedMaterialColor = null;
    TexturePixel[] baseTextureColors = null;
    if (baseImage != null) {
        basePixelIO = PixelIOFactory.getPixelIO(baseImage.getFormat());
        compressedMaterialColor = new float[2][4];
        baseTextureColors = new TexturePixel[] { new TexturePixel(), new TexturePixel() };
    }
    float[] resultPixel = new float[4];
    float[] pixelColor = new float[4];
    TexturePixel[] colors = new TexturePixel[] { new TexturePixel(), new TexturePixel() };
    int baseXTexelIndex = 0, baseYTexelIndex = 0;
    float[] alphas = new float[] { 1, 1 };
    for (int dataLayerIndex = 0; dataLayerIndex < depth; ++dataLayerIndex) {
        ByteBuffer data = image.getData(dataLayerIndex);
        data.rewind();
        ByteBuffer newData = BufferUtils.createByteBuffer(data.remaining());
        while (data.hasRemaining()) {
            if (format == Format.DXT3) {
                long alpha = data.getLong();
                // get alpha for first and last pixel that is compressed in the texel
                byte alpha0 = (byte) (alpha << 4 & 0xFF);
                byte alpha1 = (byte) (alpha >> 60 & 0xFF);
                alphas[0] = alpha0 >= 0 ? alpha0 / 255.0f : 1.0f - ~alpha0 / 255.0f;
                alphas[1] = alpha1 >= 0 ? alpha1 / 255.0f : 1.0f - ~alpha1 / 255.0f;
                newData.putLong(alpha);
            } else if (format == Format.DXT5) {
                byte alpha0 = data.get();
                byte alpha1 = data.get();
                alphas[0] = alpha0 >= 0 ? alpha0 / 255.0f : 1.0f - ~alpha0 / 255.0f;
                alphas[1] = alpha1 >= 0 ? alpha0 / 255.0f : 1.0f - ~alpha0 / 255.0f;
                newData.put(alpha0);
                newData.put(alpha1);
                // only read the next 6 bytes (these are alpha indexes)
                newData.putInt(data.getInt());
                newData.putShort(data.getShort());
            }
            int col0 = RGB565.RGB565_to_ARGB8(data.getShort());
            int col1 = RGB565.RGB565_to_ARGB8(data.getShort());
            colors[0].fromARGB8(col0);
            colors[1].fromARGB8(col1);
            // compressing 16 pixels from the base texture as if they belonged to a texel
            if (baseImage != null) {
                // reading pixels (first and last of the 16 colors array)
                // first pixel
                basePixelIO.read(baseImage, dataLayerIndex, baseTextureColors[0], baseXTexelIndex << 2, baseYTexelIndex << 2);
                // last pixel
                basePixelIO.read(baseImage, dataLayerIndex, baseTextureColors[1], baseXTexelIndex << 2 + 4, baseYTexelIndex << 2 + 4);
                baseTextureColors[0].toRGBA(compressedMaterialColor[0]);
                baseTextureColors[1].toRGBA(compressedMaterialColor[1]);
            }
            // blending colors
            for (int i = 0; i < colors.length; ++i) {
                if (negateTexture) {
                    colors[i].negate();
                }
                colors[i].toRGBA(pixelColor);
                pixelColor[3] = alphas[i];
                this.blendPixel(resultPixel, compressedMaterialColor != null ? compressedMaterialColor[i] : materialColor, pixelColor, blenderContext);
                colors[i].fromARGB(1, resultPixel[0], resultPixel[1], resultPixel[2]);
                int argb8 = colors[i].toARGB8();
                short rgb565 = RGB565.ARGB8_to_RGB565(argb8);
                newData.putShort(rgb565);
            }
            // just copy the remaining 4 bytes of the current texel
            newData.putInt(data.getInt());
            ++baseXTexelIndex;
            if (baseXTexelIndex > image.getWidth() >> 2) {
                baseXTexelIndex = 0;
                ++baseYTexelIndex;
            }
        }
        dataArray.add(newData);
    }
    Image result = dataArray.size() > 1 ? new Image(format, width, height, depth, dataArray, ColorSpace.Linear) : new Image(format, width, height, dataArray.get(0), ColorSpace.Linear);
    if (image.getMipMapSizes() != null) {
        result.setMipMapSizes(image.getMipMapSizes().clone());
    }
    return result;
}

Example 7 with TexturePixel

use of com.jme3.scene.plugins.blender.textures.TexturePixel in project jmonkeyengine by jMonkeyEngine.

the class TextureBlenderLuminance method blend.

public Image blend(Image image, Image baseImage, BlenderContext blenderContext) {
    this.prepareImagesForBlending(image, baseImage);
    Format format = image.getFormat();
    PixelInputOutput basePixelIO = null;
    TexturePixel basePixel = null;
    float[] materialColor = this.materialColor;
    if (baseImage != null) {
        basePixelIO = PixelIOFactory.getPixelIO(baseImage.getFormat());
        materialColor = new float[this.materialColor.length];
        basePixel = new TexturePixel();
    }
    int width = image.getWidth();
    int height = image.getHeight();
    int depth = image.getDepth();
    if (depth == 0) {
        depth = 1;
    }
    ArrayList<ByteBuffer> dataArray = new ArrayList<ByteBuffer>(depth);
    float[] resultPixel = new float[4];
    float[] tinAndAlpha = new float[2];
    for (int dataLayerIndex = 0; dataLayerIndex < depth; ++dataLayerIndex) {
        ByteBuffer data = image.getData(dataLayerIndex);
        data.rewind();
        ByteBuffer newData = BufferUtils.createByteBuffer(data.limit() * 4);
        int dataIndex = 0, x = 0, y = 0;
        while (data.hasRemaining()) {
            // getting the proper material color if the base texture is applied
            if (basePixelIO != null) {
                basePixelIO.read(baseImage, dataLayerIndex, basePixel, x, y);
                basePixel.toRGBA(materialColor);
                ++x;
                if (x >= width) {
                    x = 0;
                    ++y;
                }
            }
            this.getTinAndAlpha(data, format, negateTexture, tinAndAlpha);
            this.blendPixel(resultPixel, materialColor, color, tinAndAlpha[0], blendFactor, blendType, blenderContext);
            newData.put(dataIndex++, (byte) (resultPixel[0] * 255.0f));
            newData.put(dataIndex++, (byte) (resultPixel[1] * 255.0f));
            newData.put(dataIndex++, (byte) (resultPixel[2] * 255.0f));
            newData.put(dataIndex++, (byte) (tinAndAlpha[1] * 255.0f));
        }
        dataArray.add(newData);
    }
    Image result = depth > 1 ? new Image(Format.RGBA8, width, height, depth, dataArray, ColorSpace.Linear) : new Image(Format.RGBA8, width, height, dataArray.get(0), ColorSpace.Linear);
    if (image.getMipMapSizes() != null) {
        result.setMipMapSizes(image.getMipMapSizes().clone());
    }
    return result;
}

Example 8 with TexturePixel

use of com.jme3.scene.plugins.blender.textures.TexturePixel in project jmonkeyengine by jMonkeyEngine.

the class LandscapeHelper method toSky.

/**
     * Loads scene's sky. Sky can be plain or textured.
     * If no sky type is selected in blender then no sky is loaded.
     * @param worldStructure
     *            the world's structure
     * @return the scene's sky
     * @throws BlenderFileException
     *             blender exception is thrown when problems with blender file occur
     */
public Spatial toSky(Structure worldStructure) throws BlenderFileException {
    int skytype = ((Number) worldStructure.getFieldValue("skytype")).intValue();
    if (skytype == 0) {
        return null;
    }
    LOGGER.fine("Loading sky.");
    ColorRGBA horizontalColor = this.toBackgroundColor(worldStructure);
    float zenr = ((Number) worldStructure.getFieldValue("zenr")).floatValue();
    float zeng = ((Number) worldStructure.getFieldValue("zeng")).floatValue();
    float zenb = ((Number) worldStructure.getFieldValue("zenb")).floatValue();
    ColorRGBA zenithColor = new ColorRGBA(zenr, zeng, zenb, 1);
    // jutr for this case load generated textures wheather user had set it or not because those might be needed to properly load the sky
    boolean loadGeneratedTextures = blenderContext.getBlenderKey().isLoadGeneratedTextures();
    blenderContext.getBlenderKey().setLoadGeneratedTextures(true);
    TextureHelper textureHelper = blenderContext.getHelper(TextureHelper.class);
    List<CombinedTexture> loadedTextures = null;
    try {
        loadedTextures = textureHelper.readTextureData(worldStructure, new float[] { horizontalColor.r, horizontalColor.g, horizontalColor.b, horizontalColor.a }, true);
    } finally {
        blenderContext.getBlenderKey().setLoadGeneratedTextures(loadGeneratedTextures);
    }
    TextureCubeMap texture = null;
    if (loadedTextures != null && loadedTextures.size() > 0) {
        if (loadedTextures.size() > 1) {
            throw new IllegalStateException("There should be only one combined texture for sky!");
        }
        CombinedTexture combinedTexture = loadedTextures.get(0);
        texture = combinedTexture.generateSkyTexture(horizontalColor, zenithColor, blenderContext);
    } else {
        LOGGER.fine("Preparing colors for colorband.");
        int colorbandType = ColorBand.IPO_CARDINAL;
        List<ColorRGBA> colorbandColors = new ArrayList<ColorRGBA>(3);
        colorbandColors.add(horizontalColor);
        if ((skytype & SKYTYPE_BLEND) != 0) {
            if ((skytype & SKYTYPE_PAPER) != 0) {
                colorbandType = ColorBand.IPO_LINEAR;
            }
            if ((skytype & SKYTYPE_REAL) != 0) {
                colorbandColors.add(0, zenithColor);
            }
            colorbandColors.add(zenithColor);
        }
        int size = blenderContext.getBlenderKey().getSkyGeneratedTextureSize();
        List<Integer> positions = new ArrayList<Integer>(colorbandColors.size());
        positions.add(0);
        if (colorbandColors.size() == 2) {
            positions.add(size - 1);
        } else if (colorbandColors.size() == 3) {
            positions.add(size / 2);
            positions.add(size - 1);
        }
        LOGGER.fine("Generating sky texture.");
        float[][] values = new ColorBand(colorbandType, colorbandColors, positions, size).computeValues();
        Image image = ImageUtils.createEmptyImage(Format.RGB8, size, size, 6);
        PixelInputOutput pixelIO = PixelIOFactory.getPixelIO(image.getFormat());
        TexturePixel pixel = new TexturePixel();
        LOGGER.fine("Creating side textures.");
        int[] sideImagesIndexes = new int[] { 0, 1, 4, 5 };
        for (int i : sideImagesIndexes) {
            for (int y = 0; y < size; ++y) {
                pixel.red = values[y][0];
                pixel.green = values[y][1];
                pixel.blue = values[y][2];
                for (int x = 0; x < size; ++x) {
                    pixelIO.write(image, i, pixel, x, y);
                }
            }
        }
        LOGGER.fine("Creating top texture.");
        pixelIO.read(image, 0, pixel, 0, image.getHeight() - 1);
        for (int y = 0; y < size; ++y) {
            for (int x = 0; x < size; ++x) {
                pixelIO.write(image, 3, pixel, x, y);
            }
        }
        LOGGER.fine("Creating bottom texture.");
        pixelIO.read(image, 0, pixel, 0, 0);
        for (int y = 0; y < size; ++y) {
            for (int x = 0; x < size; ++x) {
                pixelIO.write(image, 2, pixel, x, y);
            }
        }
        texture = new TextureCubeMap(image);
    }
    LOGGER.fine("Sky texture created. Creating sky.");
    return SkyFactory.createSky(blenderContext.getAssetManager(), texture, SkyFactory.EnvMapType.CubeMap);
}

Example 9 with TexturePixel

use of com.jme3.scene.plugins.blender.textures.TexturePixel in project jmonkeyengine by jMonkeyEngine.

the class ImageUtils method decompress.

/**
     * This method decompresses the given image. If the given image is already
     * decompressed nothing happens and it is simply returned.
     * 
     * @param image
     *            the image to decompress
     * @return the decompressed image
     */
public static Image decompress(Image image) {
    Format format = image.getFormat();
    int depth = image.getDepth();
    if (depth == 0) {
        depth = 1;
    }
    ArrayList<ByteBuffer> dataArray = new ArrayList<ByteBuffer>(depth);
    int[] sizes = image.getMipMapSizes() != null ? image.getMipMapSizes() : new int[1];
    int[] newMipmapSizes = image.getMipMapSizes() != null ? new int[image.getMipMapSizes().length] : null;
    for (int dataLayerIndex = 0; dataLayerIndex < depth; ++dataLayerIndex) {
        ByteBuffer data = image.getData(dataLayerIndex);
        data.rewind();
        if (sizes.length == 1) {
            sizes[0] = data.remaining();
        }
        // this should always be constant for each mipmap
        float widthToHeightRatio = image.getWidth() / image.getHeight();
        List<DDSTexelData> texelDataList = new ArrayList<DDSTexelData>(sizes.length);
        int maxPosition = 0, resultSize = 0;
        for (int sizeIndex = 0; sizeIndex < sizes.length; ++sizeIndex) {
            maxPosition += sizes[sizeIndex];
            DDSTexelData texelData = new DDSTexelData(sizes[sizeIndex], widthToHeightRatio, format);
            texelDataList.add(texelData);
            switch(format) {
                // BC1
                case DXT1:
                case DXT1A:
                    while (data.position() < maxPosition) {
                        TexturePixel[] colors = new TexturePixel[] { new TexturePixel(), new TexturePixel(), new TexturePixel(), new TexturePixel() };
                        short c0 = data.getShort();
                        short c1 = data.getShort();
                        int col0 = RGB565.RGB565_to_ARGB8(c0);
                        int col1 = RGB565.RGB565_to_ARGB8(c1);
                        colors[0].fromARGB8(col0);
                        colors[1].fromARGB8(col1);
                        if (col0 > col1) {
                            // creating color2 = 2/3color0 + 1/3color1
                            colors[2].fromPixel(colors[0]);
                            colors[2].mult(2);
                            colors[2].add(colors[1]);
                            colors[2].divide(3);
                            // creating color3 = 1/3color0 + 2/3color1;
                            colors[3].fromPixel(colors[1]);
                            colors[3].mult(2);
                            colors[3].add(colors[0]);
                            colors[3].divide(3);
                        } else {
                            // creating color2 = 1/2color0 + 1/2color1
                            colors[2].fromPixel(colors[0]);
                            colors[2].add(colors[1]);
                            colors[2].mult(0.5f);
                            colors[3].fromARGB8(0);
                        }
                        // 4-byte table with color indexes in decompressed table
                        int indexes = data.getInt();
                        texelData.add(colors, indexes);
                    }
                    break;
                case // BC2
                DXT3:
                    while (data.position() < maxPosition) {
                        TexturePixel[] colors = new TexturePixel[] { new TexturePixel(), new TexturePixel(), new TexturePixel(), new TexturePixel() };
                        long alpha = data.getLong();
                        float[] alphas = new float[16];
                        long alphasIndex = 0;
                        for (int i = 0; i < 16; ++i) {
                            alphasIndex |= i << i * 4;
                            byte a = (byte) ((alpha >> i * 4 & 0x0F) << 4);
                            alphas[i] = a >= 0 ? a / 255.0f : 1.0f - ~a / 255.0f;
                        }
                        short c0 = data.getShort();
                        short c1 = data.getShort();
                        int col0 = RGB565.RGB565_to_ARGB8(c0);
                        int col1 = RGB565.RGB565_to_ARGB8(c1);
                        colors[0].fromARGB8(col0);
                        colors[1].fromARGB8(col1);
                        // creating color2 = 2/3color0 + 1/3color1
                        colors[2].fromPixel(colors[0]);
                        colors[2].mult(2);
                        colors[2].add(colors[1]);
                        colors[2].divide(3);
                        // creating color3 = 1/3color0 + 2/3color1;
                        colors[3].fromPixel(colors[1]);
                        colors[3].mult(2);
                        colors[3].add(colors[0]);
                        colors[3].divide(3);
                        // 4-byte table with color indexes in decompressed table
                        int indexes = data.getInt();
                        texelData.add(colors, indexes, alphas, alphasIndex);
                    }
                    break;
                case // BC3
                DXT5:
                    float[] alphas = new float[8];
                    while (data.position() < maxPosition) {
                        TexturePixel[] colors = new TexturePixel[] { new TexturePixel(), new TexturePixel(), new TexturePixel(), new TexturePixel() };
                        alphas[0] = data.get() * 255.0f;
                        alphas[1] = data.get() * 255.0f;
                        //the casts to long must be done here because otherwise 32-bit integers would be shifetd by 32 and 40 bits which would result in improper values
                        long alphaIndices = data.get() | (long) data.get() << 8 | (long) data.get() << 16 | (long) data.get() << 24 | (long) data.get() << 32 | (long) data.get() << 40;
                        if (alphas[0] > alphas[1]) {
                            // 6 interpolated alpha values.
                            alphas[2] = (6 * alphas[0] + alphas[1]) / 7;
                            alphas[3] = (5 * alphas[0] + 2 * alphas[1]) / 7;
                            alphas[4] = (4 * alphas[0] + 3 * alphas[1]) / 7;
                            alphas[5] = (3 * alphas[0] + 4 * alphas[1]) / 7;
                            alphas[6] = (2 * alphas[0] + 5 * alphas[1]) / 7;
                            alphas[7] = (alphas[0] + 6 * alphas[1]) / 7;
                        } else {
                            alphas[2] = (4 * alphas[0] + alphas[1]) * 0.2f;
                            alphas[3] = (3 * alphas[0] + 2 * alphas[1]) * 0.2f;
                            alphas[4] = (2 * alphas[0] + 3 * alphas[1]) * 0.2f;
                            alphas[5] = (alphas[0] + 4 * alphas[1]) * 0.2f;
                            alphas[6] = 0;
                            alphas[7] = 1;
                        }
                        short c0 = data.getShort();
                        short c1 = data.getShort();
                        int col0 = RGB565.RGB565_to_ARGB8(c0);
                        int col1 = RGB565.RGB565_to_ARGB8(c1);
                        colors[0].fromARGB8(col0);
                        colors[1].fromARGB8(col1);
                        // creating color2 = 2/3color0 + 1/3color1
                        colors[2].fromPixel(colors[0]);
                        colors[2].mult(2);
                        colors[2].add(colors[1]);
                        colors[2].divide(3);
                        // creating color3 = 1/3color0 + 2/3color1;
                        colors[3].fromPixel(colors[1]);
                        colors[3].mult(2);
                        colors[3].add(colors[0]);
                        colors[3].divide(3);
                        // 4-byte table with color indexes in decompressed table
                        int indexes = data.getInt();
                        texelData.add(colors, indexes, alphas, alphaIndices);
                    }
                    break;
                default:
                    throw new IllegalStateException("Unknown compressed format: " + format);
            }
            newMipmapSizes[sizeIndex] = texelData.getSizeInBytes();
            resultSize += texelData.getSizeInBytes();
        }
        byte[] bytes = new byte[resultSize];
        int offset = 0;
        byte[] pixelBytes = new byte[4];
        for (DDSTexelData texelData : texelDataList) {
            for (int i = 0; i < texelData.getPixelWidth(); ++i) {
                for (int j = 0; j < texelData.getPixelHeight(); ++j) {
                    if (texelData.getRGBA8(i, j, pixelBytes)) {
                        bytes[offset + (j * texelData.getPixelWidth() + i) * 4] = pixelBytes[0];
                        bytes[offset + (j * texelData.getPixelWidth() + i) * 4 + 1] = pixelBytes[1];
                        bytes[offset + (j * texelData.getPixelWidth() + i) * 4 + 2] = pixelBytes[2];
                        bytes[offset + (j * texelData.getPixelWidth() + i) * 4 + 3] = pixelBytes[3];
                    } else {
                        break;
                    }
                }
            }
            offset += texelData.getSizeInBytes();
        }
        dataArray.add(BufferUtils.createByteBuffer(bytes));
    }
    Image result = depth > 1 ? new Image(Format.RGBA8, image.getWidth(), image.getHeight(), depth, dataArray, com.jme3.texture.image.ColorSpace.Linear) : new Image(Format.RGBA8, image.getWidth(), image.getHeight(), dataArray.get(0), com.jme3.texture.image.ColorSpace.Linear);
    if (newMipmapSizes != null) {
        result.setMipMapSizes(newMipmapSizes);
    }
    return result;
}

Example 10 with TexturePixel

use of com.jme3.scene.plugins.blender.textures.TexturePixel in project jmonkeyengine by jMonkeyEngine.

the class ImageUtils method mix.

/**
     * This method merges two given images. The result is stored in the
     * 'target' image.
     * 
     * @param targetImage
     *            the target image
     * @param sourceImage
     *            the source image
     */
public static void mix(Image targetImage, Image sourceImage) {
    if (sourceImage.getDepth() != targetImage.getDepth()) {
        throw new IllegalArgumentException("The given images should have the same depth to merge them!");
    }
    if (sourceImage.getWidth() != targetImage.getWidth()) {
        throw new IllegalArgumentException("The given images should have the same width to merge them!");
    }
    if (sourceImage.getHeight() != targetImage.getHeight()) {
        throw new IllegalArgumentException("The given images should have the same height to merge them!");
    }
    PixelInputOutput sourceIO = PixelIOFactory.getPixelIO(sourceImage.getFormat());
    PixelInputOutput targetIO = PixelIOFactory.getPixelIO(targetImage.getFormat());
    TexturePixel sourcePixel = new TexturePixel();
    TexturePixel targetPixel = new TexturePixel();
    int depth = targetImage.getDepth() == 0 ? 1 : targetImage.getDepth();
    for (int layerIndex = 0; layerIndex < depth; ++layerIndex) {
        for (int x = 0; x < sourceImage.getWidth(); ++x) {
            for (int y = 0; y < sourceImage.getHeight(); ++y) {
                sourceIO.read(sourceImage, layerIndex, sourcePixel, x, y);
                targetIO.read(targetImage, layerIndex, targetPixel, x, y);
                targetPixel.mix(sourcePixel);
                targetIO.write(targetImage, layerIndex, targetPixel, x, y);
            }
        }
    }
}