- support for DDS blending (without textures decompression :) ) - support for RGBA textures blending - support for generated textures blending Also done blending refactoring. Blending functions moved to separated classes from TextureHelper. It will increase code redability. git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@9188 75d07b2b-3a1a-0410-a2c5-0572b91ccdca3.0
Kae..pl
13 years ago
parent
b12285b8a4
commit
2b004e803d
@ -1,304 +0,0 @@ |
||||
package com.jme3.scene.plugins.blender.textures; |
||||
|
||||
import java.nio.ByteBuffer; |
||||
import java.util.logging.Logger; |
||||
|
||||
import jme3tools.converters.RGB565; |
||||
|
||||
import com.jme3.math.FastMath; |
||||
import com.jme3.texture.Image; |
||||
import com.jme3.texture.Image.Format; |
||||
import com.jme3.util.BufferUtils; |
||||
|
||||
/** |
||||
* This class decompresses the given image (if necessary) to the RGBA8 format. |
||||
* Currently supported compressed textures are: DXT1, DXT3, DXT5. |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
/*package*/ class TextureDecompressor { |
||||
private static final Logger LOGGER = Logger.getLogger(TextureDecompressor.class.getName()); |
||||
|
||||
/** |
||||
* 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) {//TODO: support 3D textures
|
||||
byte[] bytes = null; |
||||
TexturePixel[] colors = null; |
||||
ByteBuffer data = image.getData(0); |
||||
data.rewind(); |
||||
Format format = image.getFormat(); |
||||
|
||||
DDSTexelData texelData = new DDSTexelData(data.remaining() / (format.getBitsPerPixel() * 2), image.getWidth(), image.getHeight(), format != Format.DXT1); |
||||
switch (format) {// TODO: DXT1A
|
||||
case DXT1:// BC1
|
||||
bytes = new byte[image.getWidth() * image.getHeight() * 4]; |
||||
colors = new TexturePixel[] { new TexturePixel(), new TexturePixel(), new TexturePixel(), new TexturePixel() }; |
||||
while (data.hasRemaining()) { |
||||
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); |
||||
} |
||||
int indexes = data.getInt();// 4-byte table with color indexes in decompressed table
|
||||
texelData.add(colors, indexes); |
||||
} |
||||
break; |
||||
case DXT3:// BC2
|
||||
bytes = new byte[image.getWidth() * image.getHeight() * 4]; |
||||
colors = new TexturePixel[] { new TexturePixel(), new TexturePixel(), new TexturePixel(), new TexturePixel() }; |
||||
while (data.hasRemaining()) { |
||||
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); |
||||
|
||||
int indexes = data.getInt();// 4-byte table with color indexes in decompressed table
|
||||
texelData.add(colors, indexes, alphas, alphasIndex); |
||||
} |
||||
break; |
||||
case DXT5:// BC3
|
||||
bytes = new byte[image.getWidth() * image.getHeight() * 4]; |
||||
colors = new TexturePixel[] { new TexturePixel(), new TexturePixel(), new TexturePixel(), new TexturePixel() }; |
||||
float[] alphas = new float[8]; |
||||
while (data.hasRemaining()) { |
||||
alphas[0] = data.get() * 255.0f; |
||||
alphas[1] = data.get() * 255.0f; |
||||
long alphaIndices = (int) data.get() | ((int) data.get() << 8) | ((int) data.get() << 16) | ((int) data.get() << 24) | ((int) data.get() << 32) | ((int) 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); |
||||
|
||||
int indexes = data.getInt();// 4-byte table with color
|
||||
// indexes in decompressed table
|
||||
texelData.add(colors, indexes, alphas, alphaIndices); |
||||
} |
||||
break; |
||||
default: |
||||
LOGGER.fine("Unsupported decompression format."); |
||||
} |
||||
|
||||
if (bytes != null) {// writing the data to the result table
|
||||
byte[] pixelBytes = new byte[4]; |
||||
for (int i = 0; i < image.getWidth(); ++i) { |
||||
for (int j = 0; j < image.getHeight(); ++j) { |
||||
texelData.getRGBA8(i, j, pixelBytes); |
||||
bytes[(j * image.getWidth() + i) * 4] = pixelBytes[0]; |
||||
bytes[(j * image.getWidth() + i) * 4 + 1] = pixelBytes[1]; |
||||
bytes[(j * image.getWidth() + i) * 4 + 2] = pixelBytes[2]; |
||||
bytes[(j * image.getWidth() + i) * 4 + 3] = pixelBytes[3]; |
||||
} |
||||
} |
||||
return new Image(Format.RGBA8, image.getWidth(), image.getHeight(), BufferUtils.createByteBuffer(bytes)); |
||||
} |
||||
return image; |
||||
} |
||||
|
||||
/** |
||||
* The data that helps in bytes calculations for the result image. |
||||
* |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
private static class DDSTexelData { |
||||
/** The colors of the texes. */ |
||||
private TexturePixel[][] colors; |
||||
/** The indexes of the texels. */ |
||||
private long[] indexes; |
||||
/** The alphas of the texels (might be null). */ |
||||
private float[][] alphas; |
||||
/** The indexels of texels alpha values (might be null). */ |
||||
private long[] alphaIndexes; |
||||
/** The counter of texel x column. */ |
||||
private int xCounter; |
||||
/** The counter of texel y row. */ |
||||
private int yCounter; |
||||
/** The width of the image in pixels. */ |
||||
private int pixelWidth; |
||||
/** The height of the image in pixels. */ |
||||
private int pixelHeight; |
||||
/** The total texel count. */ |
||||
private int xTexelCount; |
||||
|
||||
/** |
||||
* Constructor. Allocates the required memory. Initializes variables. |
||||
* |
||||
* @param textelsCount |
||||
* the total count of the texels |
||||
* @param pixelWidth |
||||
* the width of the image in pixels |
||||
* @param pixelHeight |
||||
* the height of the image in pixels |
||||
* @param isAlpha |
||||
* indicates if the memory for alpha values should be |
||||
* allocated |
||||
*/ |
||||
public DDSTexelData(int textelsCount, int pixelWidth, int pixelHeight, boolean isAlpha) { |
||||
textelsCount = (pixelWidth * pixelHeight) >> 4; |
||||
this.colors = new TexturePixel[textelsCount][]; |
||||
this.indexes = new long[textelsCount]; |
||||
this.xTexelCount = pixelWidth >> 2; |
||||
this.yCounter = (pixelHeight >> 2) - 1;// xCounter is 0 for now
|
||||
this.pixelHeight = pixelHeight; |
||||
this.pixelWidth = pixelWidth; |
||||
if (isAlpha) { |
||||
this.alphas = new float[textelsCount][]; |
||||
this.alphaIndexes = new long[textelsCount]; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method adds a color and indexes for a texel. |
||||
* |
||||
* @param colors |
||||
* the colors of the texel |
||||
* @param indexes |
||||
* the indexes of the texel |
||||
*/ |
||||
public void add(TexturePixel[] colors, int indexes) { |
||||
this.add(colors, indexes, null, 0); |
||||
} |
||||
|
||||
/** |
||||
* This method adds a color, color indexes and alha values (with their |
||||
* indexes) for a texel. |
||||
* |
||||
* @param colors |
||||
* the colors of the texel |
||||
* @param indexes |
||||
* the indexes of the texel |
||||
* @param alphas |
||||
* the alpha values |
||||
* @param alphaIndexes |
||||
* the indexes of the given alpha values |
||||
*/ |
||||
public void add(TexturePixel[] colors, int indexes, float[] alphas, long alphaIndexes) { |
||||
int index = yCounter * xTexelCount + xCounter; |
||||
this.colors[index] = colors; |
||||
this.indexes[index] = indexes; |
||||
if (alphas != null) { |
||||
this.alphas[index] = alphas; |
||||
this.alphaIndexes[index] = alphaIndexes; |
||||
} |
||||
++this.xCounter; |
||||
if (this.xCounter >= this.xTexelCount) { |
||||
this.xCounter = 0; |
||||
--this.yCounter; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method returns the values of the pixel located on the given |
||||
* coordinates on the result image. |
||||
* |
||||
* @param x |
||||
* the x coordinate of the pixel |
||||
* @param y |
||||
* the y coordinate of the pixel |
||||
* @param result |
||||
* the table where the result is stored |
||||
*/ |
||||
public void getRGBA8(int x, int y, byte[] result) { |
||||
int xTexetlIndex = (x % pixelWidth) / 4; |
||||
int yTexelIndex = (y % pixelHeight) / 4; |
||||
|
||||
int texelIndex = yTexelIndex * xTexelCount + xTexetlIndex; |
||||
TexturePixel[] colors = this.colors[texelIndex]; |
||||
|
||||
// coordinates of the pixel in the selected texel
|
||||
x = x - 4 * xTexetlIndex;// pixels are arranged from left to right
|
||||
y = 3 - y - 4 * yTexelIndex;// pixels are arranged from bottom to top (that is why '3 - ...' is at the start)
|
||||
|
||||
int pixelIndexInTexel = (y * 4 + x) * (int) FastMath.log(colors.length, 2); |
||||
int alphaIndexInTexel = alphas != null ? (y * 4 + x) * (int) FastMath.log(alphas.length, 2) : 0; |
||||
|
||||
// getting the pixel
|
||||
int indexMask = colors.length - 1; |
||||
int colorIndex = (int) ((this.indexes[texelIndex] >> pixelIndexInTexel) & indexMask); |
||||
float alpha = this.alphas != null ? this.alphas[texelIndex][(int) ((this.alphaIndexes[texelIndex] >> alphaIndexInTexel) & 0x07)] : colors[colorIndex].alpha; |
||||
result[0] = (byte) (colors[colorIndex].red * 255.0f); |
||||
result[1] = (byte) (colors[colorIndex].green * 255.0f); |
||||
result[2] = (byte) (colors[colorIndex].blue * 255.0f); |
||||
result[3] = (byte) (alpha * 255.0f); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,195 @@ |
||||
package com.jme3.scene.plugins.blender.textures.blending; |
||||
|
||||
import com.jme3.math.FastMath; |
||||
import com.jme3.scene.plugins.blender.BlenderContext; |
||||
import com.jme3.scene.plugins.blender.materials.MaterialHelper; |
||||
|
||||
/** |
||||
* An abstract class that contains the basic methods used by the classes that |
||||
* will derive from it. |
||||
* |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
/* package */abstract class AbstractTextureBlender implements TextureBlender { |
||||
/** |
||||
* This method blends the single pixel depending on the blending type. |
||||
* |
||||
* @param result |
||||
* the result pixel |
||||
* @param materialColor |
||||
* the material color |
||||
* @param pixelColor |
||||
* the pixel color |
||||
* @param blendFactor |
||||
* the blending factor |
||||
* @param blendtype |
||||
* the blending type |
||||
* @param blenderContext |
||||
* the blender context |
||||
*/ |
||||
protected void blendPixel(float[] result, float[] materialColor, float[] pixelColor, float blendFactor, int blendtype, BlenderContext blenderContext) { |
||||
float oneMinusFactor = 1.0f - blendFactor, col; |
||||
|
||||
switch (blendtype) { |
||||
case MTEX_BLEND: |
||||
result[0] = blendFactor * pixelColor[0] + oneMinusFactor * materialColor[0]; |
||||
result[1] = blendFactor * pixelColor[1] + oneMinusFactor * materialColor[1]; |
||||
result[2] = blendFactor * pixelColor[2] + oneMinusFactor * materialColor[2]; |
||||
break; |
||||
case MTEX_MUL: |
||||
result[0] = (oneMinusFactor + blendFactor * materialColor[0]) * pixelColor[0]; |
||||
result[1] = (oneMinusFactor + blendFactor * materialColor[1]) * pixelColor[1]; |
||||
result[2] = (oneMinusFactor + blendFactor * materialColor[2]) * pixelColor[2]; |
||||
break; |
||||
case MTEX_DIV: |
||||
if (pixelColor[0] != 0.0) { |
||||
result[0] = (oneMinusFactor * materialColor[0] + blendFactor * materialColor[0] / pixelColor[0]) * 0.5f; |
||||
} |
||||
if (pixelColor[1] != 0.0) { |
||||
result[1] = (oneMinusFactor * materialColor[1] + blendFactor * materialColor[1] / pixelColor[1]) * 0.5f; |
||||
} |
||||
if (pixelColor[2] != 0.0) { |
||||
result[2] = (oneMinusFactor * materialColor[2] + blendFactor * materialColor[2] / pixelColor[2]) * 0.5f; |
||||
} |
||||
break; |
||||
case MTEX_SCREEN: |
||||
result[0] = 1.0f - (oneMinusFactor + blendFactor * (1.0f - materialColor[0])) * (1.0f - pixelColor[0]); |
||||
result[1] = 1.0f - (oneMinusFactor + blendFactor * (1.0f - materialColor[1])) * (1.0f - pixelColor[1]); |
||||
result[2] = 1.0f - (oneMinusFactor + blendFactor * (1.0f - materialColor[2])) * (1.0f - pixelColor[2]); |
||||
break; |
||||
case MTEX_OVERLAY: |
||||
if (materialColor[0] < 0.5f) { |
||||
result[0] = pixelColor[0] * (oneMinusFactor + 2.0f * blendFactor * materialColor[0]); |
||||
} else { |
||||
result[0] = 1.0f - (oneMinusFactor + 2.0f * blendFactor * (1.0f - materialColor[0])) * (1.0f - pixelColor[0]); |
||||
} |
||||
if (materialColor[1] < 0.5f) { |
||||
result[1] = pixelColor[1] * (oneMinusFactor + 2.0f * blendFactor * materialColor[1]); |
||||
} else { |
||||
result[1] = 1.0f - (oneMinusFactor + 2.0f * blendFactor * (1.0f - materialColor[1])) * (1.0f - pixelColor[1]); |
||||
} |
||||
if (materialColor[2] < 0.5f) { |
||||
result[2] = pixelColor[2] * (oneMinusFactor + 2.0f * blendFactor * materialColor[2]); |
||||
} else { |
||||
result[2] = 1.0f - (oneMinusFactor + 2.0f * blendFactor * (1.0f - materialColor[2])) * (1.0f - pixelColor[2]); |
||||
} |
||||
break; |
||||
case MTEX_SUB: |
||||
result[0] = materialColor[0] - blendFactor * pixelColor[0]; |
||||
result[1] = materialColor[1] - blendFactor * pixelColor[1]; |
||||
result[2] = materialColor[2] - blendFactor * pixelColor[2]; |
||||
result[0] = FastMath.clamp(result[0], 0.0f, 1.0f); |
||||
result[1] = FastMath.clamp(result[1], 0.0f, 1.0f); |
||||
result[2] = FastMath.clamp(result[2], 0.0f, 1.0f); |
||||
break; |
||||
case MTEX_ADD: |
||||
result[0] = (blendFactor * pixelColor[0] + materialColor[0]) * 0.5f; |
||||
result[1] = (blendFactor * pixelColor[1] + materialColor[1]) * 0.5f; |
||||
result[2] = (blendFactor * pixelColor[2] + materialColor[2]) * 0.5f; |
||||
break; |
||||
case MTEX_DIFF: |
||||
result[0] = oneMinusFactor * materialColor[0] + blendFactor * Math.abs(materialColor[0] - pixelColor[0]); |
||||
result[1] = oneMinusFactor * materialColor[1] + blendFactor * Math.abs(materialColor[1] - pixelColor[1]); |
||||
result[2] = oneMinusFactor * materialColor[2] + blendFactor * Math.abs(materialColor[2] - pixelColor[2]); |
||||
break; |
||||
case MTEX_DARK: |
||||
col = blendFactor * pixelColor[0]; |
||||
result[0] = col < materialColor[0] ? col : materialColor[0]; |
||||
col = blendFactor * pixelColor[1]; |
||||
result[1] = col < materialColor[1] ? col : materialColor[1]; |
||||
col = blendFactor * pixelColor[2]; |
||||
result[2] = col < materialColor[2] ? col : materialColor[2]; |
||||
break; |
||||
case MTEX_LIGHT: |
||||
col = blendFactor * pixelColor[0]; |
||||
result[0] = col > materialColor[0] ? col : materialColor[0]; |
||||
col = blendFactor * pixelColor[1]; |
||||
result[1] = col > materialColor[1] ? col : materialColor[1]; |
||||
col = blendFactor * pixelColor[2]; |
||||
result[2] = col > materialColor[2] ? col : materialColor[2]; |
||||
break; |
||||
case MTEX_BLEND_HUE: |
||||
case MTEX_BLEND_SAT: |
||||
case MTEX_BLEND_VAL: |
||||
case MTEX_BLEND_COLOR: |
||||
System.arraycopy(materialColor, 0, result, 0, 3); |
||||
this.blendHSV(blendtype, result, blendFactor, pixelColor, blenderContext); |
||||
break; |
||||
default: |
||||
throw new IllegalStateException("Unknown blend type: " + blendtype); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* The method that performs the ramp blending. |
||||
* |
||||
* @param type |
||||
* the blend type |
||||
* @param materialRGB |
||||
* the rgb value of the material, here the result is stored too |
||||
* @param fac |
||||
* color affection factor |
||||
* @param pixelColor |
||||
* the texture color |
||||
* @param blenderContext |
||||
* the blender context |
||||
*/ |
||||
protected void blendHSV(int type, float[] materialRGB, float fac, float[] pixelColor, BlenderContext blenderContext) { |
||||
float oneMinusFactor = 1.0f - fac; |
||||
MaterialHelper materialHelper = blenderContext.getHelper(MaterialHelper.class); |
||||
|
||||
switch (type) { |
||||
case MTEX_BLEND_HUE: {// FIXME: not working well for image textures
|
||||
// (works fine for generated textures)
|
||||
float[] colorTransformResult = new float[3]; |
||||
materialHelper.rgbToHsv(pixelColor[0], pixelColor[1], pixelColor[2], colorTransformResult); |
||||
if (colorTransformResult[0] != 0.0f) { |
||||
float colH = colorTransformResult[0]; |
||||
materialHelper.rgbToHsv(materialRGB[0], materialRGB[1], materialRGB[2], colorTransformResult); |
||||
materialHelper.hsvToRgb(colH, colorTransformResult[1], colorTransformResult[2], colorTransformResult); |
||||
materialRGB[0] = oneMinusFactor * materialRGB[0] + fac * colorTransformResult[0]; |
||||
materialRGB[1] = oneMinusFactor * materialRGB[1] + fac * colorTransformResult[1]; |
||||
materialRGB[2] = oneMinusFactor * materialRGB[2] + fac * colorTransformResult[2]; |
||||
} |
||||
break; |
||||
} |
||||
case MTEX_BLEND_SAT: { |
||||
float[] colorTransformResult = new float[3]; |
||||
materialHelper.rgbToHsv(materialRGB[0], materialRGB[1], materialRGB[2], colorTransformResult); |
||||
float h = colorTransformResult[0]; |
||||
float s = colorTransformResult[1]; |
||||
float v = colorTransformResult[2]; |
||||
if (s != 0.0f) { |
||||
materialHelper.rgbToHsv(pixelColor[0], pixelColor[1], pixelColor[2], colorTransformResult); |
||||
materialHelper.hsvToRgb(h, (oneMinusFactor * s + fac * colorTransformResult[1]), v, materialRGB); |
||||
} |
||||
break; |
||||
} |
||||
case MTEX_BLEND_VAL: { |
||||
float[] rgbToHsv = new float[3]; |
||||
float[] colToHsv = new float[3]; |
||||
materialHelper.rgbToHsv(materialRGB[0], materialRGB[1], materialRGB[2], rgbToHsv); |
||||
materialHelper.rgbToHsv(pixelColor[0], pixelColor[1], pixelColor[2], colToHsv); |
||||
materialHelper.hsvToRgb(rgbToHsv[0], rgbToHsv[1], (oneMinusFactor * rgbToHsv[2] + fac * colToHsv[2]), materialRGB); |
||||
break; |
||||
} |
||||
case MTEX_BLEND_COLOR: {// FIXME: not working well for image
|
||||
// textures (works fine for generated
|
||||
// textures)
|
||||
float[] rgbToHsv = new float[3]; |
||||
float[] colToHsv = new float[3]; |
||||
materialHelper.rgbToHsv(pixelColor[0], pixelColor[1], pixelColor[2], colToHsv); |
||||
if (colToHsv[2] != 0) { |
||||
materialHelper.rgbToHsv(materialRGB[0], materialRGB[1], materialRGB[2], rgbToHsv); |
||||
materialHelper.hsvToRgb(colToHsv[0], colToHsv[1], rgbToHsv[2], rgbToHsv); |
||||
materialRGB[0] = oneMinusFactor * materialRGB[0] + fac * rgbToHsv[0]; |
||||
materialRGB[1] = oneMinusFactor * materialRGB[1] + fac * rgbToHsv[1]; |
||||
materialRGB[2] = oneMinusFactor * materialRGB[2] + fac * rgbToHsv[2]; |
||||
} |
||||
break; |
||||
} |
||||
default: |
||||
throw new IllegalStateException("Unknown ramp type: " + type); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,51 @@ |
||||
package com.jme3.scene.plugins.blender.textures.blending; |
||||
|
||||
import com.jme3.scene.plugins.blender.BlenderContext; |
||||
import com.jme3.texture.Texture; |
||||
|
||||
/** |
||||
* An interface for texture blending classes (the classes that mix the texture |
||||
* pixels with the material colors). |
||||
* |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
public interface TextureBlender { |
||||
// types of blending
|
||||
int MTEX_BLEND = 0; |
||||
int MTEX_MUL = 1; |
||||
int MTEX_ADD = 2; |
||||
int MTEX_SUB = 3; |
||||
int MTEX_DIV = 4; |
||||
int MTEX_DARK = 5; |
||||
int MTEX_DIFF = 6; |
||||
int MTEX_LIGHT = 7; |
||||
int MTEX_SCREEN = 8; |
||||
int MTEX_OVERLAY = 9; |
||||
int MTEX_BLEND_HUE = 10; |
||||
int MTEX_BLEND_SAT = 11; |
||||
int MTEX_BLEND_VAL = 12; |
||||
int MTEX_BLEND_COLOR = 13; |
||||
int MTEX_NUM_BLENDTYPES = 14; |
||||
|
||||
/** |
||||
* This method blends the given texture with material color and the defined |
||||
* color in 'map to' panel. As a result of this method a new texture is |
||||
* created. The input texture is NOT. |
||||
* |
||||
* @param materialColor |
||||
* the material diffuse color |
||||
* @param texture |
||||
* the texture we use in blending |
||||
* @param color |
||||
* the color defined for the texture |
||||
* @param affectFactor |
||||
* the factor that the color affects the texture (value form 0.0 |
||||
* to 1.0) |
||||
* @param blendType |
||||
* the blending type |
||||
* @param blenderContext |
||||
* the blender context |
||||
* @return new texture that was created after the blending |
||||
*/ |
||||
Texture blend(float[] materialColor, Texture texture, float[] color, float affectFactor, int blendType, boolean neg, BlenderContext blenderContext); |
||||
} |
||||
@ -0,0 +1,162 @@ |
||||
package com.jme3.scene.plugins.blender.textures.blending; |
||||
|
||||
import java.nio.ByteBuffer; |
||||
import java.util.ArrayList; |
||||
import java.util.logging.Level; |
||||
import java.util.logging.Logger; |
||||
|
||||
import com.jme3.scene.plugins.blender.BlenderContext; |
||||
import com.jme3.texture.Image; |
||||
import com.jme3.texture.Texture; |
||||
import com.jme3.texture.Texture2D; |
||||
import com.jme3.texture.Texture3D; |
||||
import com.jme3.texture.Image.Format; |
||||
import com.jme3.util.BufferUtils; |
||||
|
||||
/** |
||||
* The class that is responsible for blending the following texture types: |
||||
* <li> RGBA8 |
||||
* <li> ABGR8 |
||||
* <li> BGR8 |
||||
* <li> RGB8 |
||||
* Not yet supported (but will be): |
||||
* <li> ARGB4444: |
||||
* <li> RGB10: |
||||
* <li> RGB111110F: |
||||
* <li> RGB16: |
||||
* <li> RGB16F: |
||||
* <li> RGB16F_to_RGB111110F: |
||||
* <li> RGB16F_to_RGB9E5: |
||||
* <li> RGB32F: |
||||
* <li> RGB565: |
||||
* <li> RGB5A1: |
||||
* <li> RGB9E5: |
||||
* <li> RGBA16: |
||||
* <li> RGBA16F |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
public class TextureBlenderAWT extends AbstractTextureBlender { |
||||
private static final Logger LOGGER = Logger.getLogger(TextureBlenderAWT.class.getName()); |
||||
|
||||
@Override |
||||
public Texture blend(float[] materialColor, Texture texture, float[] color, float affectFactor, int blendType, boolean neg, BlenderContext blenderContext) { |
||||
float[] pixelColor = new float[] { color[0], color[1], color[2], 1.0f }; |
||||
Format format = texture.getImage().getFormat(); |
||||
ByteBuffer data = texture.getImage().getData(0); |
||||
data.rewind(); |
||||
|
||||
int width = texture.getImage().getWidth(); |
||||
int height = texture.getImage().getHeight(); |
||||
int depth = texture.getImage().getDepth(); |
||||
if (depth == 0) { |
||||
depth = 1; |
||||
} |
||||
ByteBuffer newData = BufferUtils.createByteBuffer(width * height * depth * 4); |
||||
|
||||
float[] resultPixel = new float[4]; |
||||
int dataIndex = 0; |
||||
while (data.hasRemaining()) { |
||||
float tin = this.setupMaterialColor(data, format, neg, pixelColor); |
||||
this.blendPixel(resultPixel, materialColor, color, tin, 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) (pixelColor[3] * 255.0f)); |
||||
} |
||||
if (texture.getType() == Texture.Type.TwoDimensional) { |
||||
return new Texture2D(new Image(Format.RGBA8, width, height, newData)); |
||||
} else { |
||||
ArrayList<ByteBuffer> dataArray = new ArrayList<ByteBuffer>(1); |
||||
dataArray.add(newData); |
||||
return new Texture3D(new Image(Format.RGBA8, width, height, depth, dataArray)); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method alters the material color in a way dependent on the type of |
||||
* the image. For example the color remains untouched if the texture is of |
||||
* Luminance type. The luminance defines the interaction between the |
||||
* material color and color defined for texture blending. If the type has 3 |
||||
* or more color channels then the material color is replaced with the |
||||
* texture's color and later blended with the defined blend color. All alpha |
||||
* values (if present) are ignored and not used during blending. |
||||
* |
||||
* @param data |
||||
* the image data |
||||
* @param imageFormat |
||||
* the format of the image |
||||
* @param neg |
||||
* defines it the result color should be nagated |
||||
* @param materialColor |
||||
* the material's color (value may be changed) |
||||
* @return texture intensity for the current pixel |
||||
*/ |
||||
protected float setupMaterialColor(ByteBuffer data, Format imageFormat, boolean neg, float[] materialColor) { |
||||
float tin = 0.0f; |
||||
byte pixelValue = data.get();// at least one byte is always taken :)
|
||||
float firstPixelValue = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
switch (imageFormat) { |
||||
case RGBA8: |
||||
materialColor[0] = firstPixelValue; |
||||
pixelValue = data.get(); |
||||
materialColor[1] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
pixelValue = data.get(); |
||||
materialColor[2] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
pixelValue = data.get(); |
||||
materialColor[3] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
break; |
||||
case ABGR8: |
||||
materialColor[3] = firstPixelValue; |
||||
pixelValue = data.get(); |
||||
materialColor[2] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
pixelValue = data.get(); |
||||
materialColor[1] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
pixelValue = data.get(); |
||||
materialColor[0] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
break; |
||||
case BGR8: |
||||
materialColor[2] = firstPixelValue; |
||||
pixelValue = data.get(); |
||||
materialColor[1] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
pixelValue = data.get(); |
||||
materialColor[0] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
materialColor[3] = 1.0f; |
||||
break; |
||||
case RGB8: |
||||
materialColor[0] = firstPixelValue; |
||||
pixelValue = data.get(); |
||||
materialColor[1] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
pixelValue = data.get(); |
||||
materialColor[2] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
materialColor[3] = 1.0f; |
||||
break; |
||||
case ARGB4444: |
||||
case RGB10: |
||||
case RGB111110F: |
||||
case RGB16: |
||||
case RGB16F: |
||||
case RGB16F_to_RGB111110F: |
||||
case RGB16F_to_RGB9E5: |
||||
case RGB32F: |
||||
case RGB565: |
||||
case RGB5A1: |
||||
case RGB9E5: |
||||
case RGBA16: |
||||
case RGBA16F: |
||||
case RGBA32F:// TODO: implement these textures
|
||||
LOGGER.log(Level.WARNING, "Image type not yet supported for blending: {0}", imageFormat); |
||||
break; |
||||
default: |
||||
throw new IllegalStateException("Invalid image format type for AWT texture blender: " + imageFormat); |
||||
} |
||||
if (neg) { |
||||
materialColor[0] = 1.0f - materialColor[0]; |
||||
materialColor[1] = 1.0f - materialColor[1]; |
||||
materialColor[2] = 1.0f - materialColor[2]; |
||||
} |
||||
// Blender formula for texture intensity calculation:
|
||||
// 0.35*texres.tr+0.45*texres.tg+0.2*texres.tb
|
||||
tin = 0.35f * materialColor[0] + 0.45f * materialColor[1] + 0.2f * materialColor[2]; |
||||
return tin; |
||||
} |
||||
} |
||||
@ -0,0 +1,96 @@ |
||||
package com.jme3.scene.plugins.blender.textures.blending; |
||||
|
||||
import java.nio.ByteBuffer; |
||||
import java.util.ArrayList; |
||||
import java.util.logging.Level; |
||||
import java.util.logging.Logger; |
||||
|
||||
import jme3tools.converters.RGB565; |
||||
|
||||
import com.jme3.scene.plugins.blender.BlenderContext; |
||||
import com.jme3.scene.plugins.blender.textures.TexturePixel; |
||||
import com.jme3.texture.Image; |
||||
import com.jme3.texture.Image.Format; |
||||
import com.jme3.texture.Texture; |
||||
import com.jme3.texture.Texture2D; |
||||
import com.jme3.texture.Texture3D; |
||||
import com.jme3.util.BufferUtils; |
||||
|
||||
/** |
||||
* The class that is responsible for blending the following texture types: |
||||
* <li> DXT1 |
||||
* <li> DXT3 |
||||
* <li> DXT5 |
||||
* Not yet supported (but will be): |
||||
* <li> DXT1A: |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
public class TextureBlenderDDS extends AbstractTextureBlender { |
||||
private static final Logger LOGGER = Logger.getLogger(TextureBlenderDDS.class.getName()); |
||||
|
||||
@Override |
||||
public Texture blend(float[] materialColor, Texture texture, float[] color, float affectFactor, int blendType, boolean neg, BlenderContext blenderContext) { |
||||
Format format = texture.getImage().getFormat(); |
||||
ByteBuffer data = texture.getImage().getData(0); |
||||
data.rewind(); |
||||
|
||||
int width = texture.getImage().getWidth(); |
||||
int height = texture.getImage().getHeight(); |
||||
int depth = texture.getImage().getDepth(); |
||||
if (depth == 0) { |
||||
depth = 1; |
||||
} |
||||
ByteBuffer newData = BufferUtils.createByteBuffer(data.remaining()); |
||||
|
||||
float[] resultPixel = new float[4]; |
||||
float[] pixelColor = new float[4]; |
||||
TexturePixel[] colors = new TexturePixel[] { new TexturePixel(), new TexturePixel() }; |
||||
int dataIndex = 0; |
||||
while (data.hasRemaining()) { |
||||
switch (format) { |
||||
case DXT3: |
||||
case DXT5: |
||||
newData.putLong(dataIndex, data.getLong());// just copy the
|
||||
// 8 bytes of
|
||||
// alphas
|
||||
dataIndex += 8; |
||||
case DXT1: |
||||
int col0 = RGB565.RGB565_to_ARGB8(data.getShort()); |
||||
int col1 = RGB565.RGB565_to_ARGB8(data.getShort()); |
||||
colors[0].fromARGB8(col0); |
||||
colors[1].fromARGB8(col1); |
||||
break; |
||||
case DXT1A: |
||||
LOGGER.log(Level.WARNING, "Image type not yet supported for blending: {0}", format); |
||||
break; |
||||
default: |
||||
throw new IllegalStateException("Invalid image format type for DDS texture blender: " + format); |
||||
} |
||||
|
||||
// blending colors
|
||||
for (int i = 0; i < colors.length; ++i) { |
||||
if (neg) { |
||||
colors[i].negate(); |
||||
} |
||||
colors[i].toRGBA(pixelColor); |
||||
this.blendPixel(resultPixel, materialColor, pixelColor, affectFactor, blendType, blenderContext); |
||||
colors[i].fromARGB8(1, resultPixel[0], resultPixel[1], resultPixel[2]); |
||||
int argb8 = colors[i].toARGB8(); |
||||
short rgb565 = RGB565.ARGB8_to_RGB565(argb8); |
||||
newData.putShort(dataIndex, rgb565); |
||||
dataIndex += 2; |
||||
} |
||||
|
||||
// just copy the remaining 4 bytes of the current texel
|
||||
newData.putInt(dataIndex, data.getInt()); |
||||
dataIndex += 4; |
||||
} |
||||
if (texture.getType() == Texture.Type.TwoDimensional) { |
||||
return new Texture2D(new Image(format, width, height, newData)); |
||||
} else { |
||||
ArrayList<ByteBuffer> dataArray = new ArrayList<ByteBuffer>(1); |
||||
dataArray.add(newData); |
||||
return new Texture3D(new Image(format, width, height, depth, dataArray)); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,81 @@ |
||||
package com.jme3.scene.plugins.blender.textures.blending; |
||||
|
||||
import java.util.logging.Level; |
||||
import java.util.logging.Logger; |
||||
|
||||
import com.jme3.scene.plugins.blender.BlenderContext; |
||||
import com.jme3.texture.Texture; |
||||
import com.jme3.texture.Image.Format; |
||||
|
||||
/** |
||||
* This class creates the texture blending class depending on the texture type. |
||||
* |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
public class TextureBlenderFactory { |
||||
private static final Logger LOGGER = Logger.getLogger(TextureBlenderFactory.class.getName()); |
||||
|
||||
/** |
||||
* This method creates the blending class. |
||||
* |
||||
* @param format |
||||
* the texture format |
||||
* @returntexture blending class
|
||||
*/ |
||||
public static TextureBlender createTextureBlender(Format format) { |
||||
switch (format) { |
||||
case Luminance8: |
||||
case Luminance8Alpha8: |
||||
case Luminance16: |
||||
case Luminance16Alpha16: |
||||
case Luminance16F: |
||||
case Luminance16FAlpha16F: |
||||
case Luminance32F: |
||||
return new TextureBlenderLuminance(); |
||||
case RGBA8: |
||||
case ABGR8: |
||||
case BGR8: |
||||
case RGB8: |
||||
case RGB10: |
||||
case RGB111110F: |
||||
case RGB16: |
||||
case RGB16F: |
||||
case RGB16F_to_RGB111110F: |
||||
case RGB16F_to_RGB9E5: |
||||
case RGB32F: |
||||
case RGB565: |
||||
case RGB5A1: |
||||
case RGB9E5: |
||||
case RGBA16: |
||||
case RGBA16F: |
||||
case RGBA32F: |
||||
return new TextureBlenderAWT(); |
||||
case DXT1: |
||||
case DXT1A: |
||||
case DXT3: |
||||
case DXT5: |
||||
return new TextureBlenderDDS(); |
||||
case Alpha16: |
||||
case Alpha8: |
||||
case ARGB4444: |
||||
case Depth: |
||||
case Depth16: |
||||
case Depth24: |
||||
case Depth32: |
||||
case Depth32F: |
||||
case Intensity16: |
||||
case Intensity8: |
||||
case LATC: |
||||
case LTC: |
||||
LOGGER.log(Level.WARNING, "Image type not yet supported for blending: {0}. Returning a blender that does not change the texture.", format); |
||||
return new TextureBlender() { |
||||
@Override |
||||
public Texture blend(float[] materialColor, Texture texture, float[] color, float affectFactor, int blendType, boolean neg, BlenderContext blenderContext) { |
||||
return texture; |
||||
} |
||||
}; |
||||
default: |
||||
throw new IllegalStateException("Unknown image format type: " + format); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,221 @@ |
||||
package com.jme3.scene.plugins.blender.textures.blending; |
||||
|
||||
import java.nio.ByteBuffer; |
||||
import java.util.ArrayList; |
||||
import java.util.logging.Level; |
||||
import java.util.logging.Logger; |
||||
|
||||
import com.jme3.math.FastMath; |
||||
import com.jme3.scene.plugins.blender.BlenderContext; |
||||
import com.jme3.texture.Image; |
||||
import com.jme3.texture.Texture; |
||||
import com.jme3.texture.Texture2D; |
||||
import com.jme3.texture.Texture3D; |
||||
import com.jme3.texture.Image.Format; |
||||
import com.jme3.util.BufferUtils; |
||||
|
||||
/** |
||||
* The class that is responsible for blending the following texture types: |
||||
* <li> Luminance8 |
||||
* <li> Luminance8Alpha8 |
||||
* Not yet supported (but will be): |
||||
* <li> Luminance16: |
||||
* <li> Luminance16Alpha16: |
||||
* <li> Luminance16F: |
||||
* <li> Luminance16FAlpha16F: |
||||
* <li> Luminance32F: |
||||
* @author Marcin Roguski (Kaelthas) |
||||
*/ |
||||
public class TextureBlenderLuminance extends AbstractTextureBlender { |
||||
private static final Logger LOGGER = Logger.getLogger(TextureBlenderLuminance.class.getName()); |
||||
|
||||
@Override |
||||
public Texture blend(float[] materialColor, Texture texture, float[] color, float affectFactor, int blendType, boolean neg, BlenderContext blenderContext) { |
||||
Format format = texture.getImage().getFormat(); |
||||
ByteBuffer data = texture.getImage().getData(0); |
||||
data.rewind(); |
||||
|
||||
int width = texture.getImage().getWidth(); |
||||
int height = texture.getImage().getHeight(); |
||||
int depth = texture.getImage().getDepth(); |
||||
if (depth == 0) { |
||||
depth = 1; |
||||
} |
||||
ByteBuffer newData = BufferUtils.createByteBuffer(width * height * depth * 4); |
||||
|
||||
float[] resultPixel = new float[4]; |
||||
float[] tinAndAlpha = new float[2]; |
||||
int dataIndex = 0; |
||||
while (data.hasRemaining()) { |
||||
this.getTinAndAlpha(data, format, neg, tinAndAlpha); |
||||
this.blendPixel(resultPixel, materialColor, color, tinAndAlpha[0], affectFactor, 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)); |
||||
} |
||||
if (texture.getType() == Texture.Type.TwoDimensional) { |
||||
return new Texture2D(new Image(Format.RGBA8, width, height, newData)); |
||||
} else { |
||||
ArrayList<ByteBuffer> dataArray = new ArrayList<ByteBuffer>(1); |
||||
dataArray.add(newData); |
||||
return new Texture3D(new Image(Format.RGBA8, width, height, depth, dataArray)); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method return texture intensity and alpha value. |
||||
* |
||||
* @param data |
||||
* the texture data |
||||
* @param imageFormat |
||||
* the image format |
||||
* @param neg |
||||
* indicates if the texture is negated |
||||
* @param result |
||||
* the table (2 elements) where the result is being stored |
||||
*/ |
||||
protected void getTinAndAlpha(ByteBuffer data, Format imageFormat, boolean neg, float[] result) { |
||||
byte pixelValue = data.get();// at least one byte is always taken
|
||||
float firstPixelValue = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
switch (imageFormat) { |
||||
case Luminance8: |
||||
result[0] = neg ? 1.0f - firstPixelValue : firstPixelValue; |
||||
result[1] = 1.0f; |
||||
break; |
||||
case Luminance8Alpha8: |
||||
result[0] = neg ? 1.0f - firstPixelValue : firstPixelValue; |
||||
pixelValue = data.get(); |
||||
result[1] = pixelValue >= 0 ? pixelValue / 255.0f : 1.0f - (~pixelValue) / 255.0f; |
||||
break; |
||||
case Luminance16: |
||||
case Luminance16Alpha16: |
||||
case Luminance16F: |
||||
case Luminance16FAlpha16F: |
||||
case Luminance32F: |
||||
LOGGER.log(Level.WARNING, "Image type not yet supported for blending: {0}", imageFormat); |
||||
break; |
||||
default: |
||||
throw new IllegalStateException("Invalid image format type for DDS texture blender: " + imageFormat); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This method blends the texture with an appropriate color. |
||||
* |
||||
* @param result |
||||
* the result color (variable 'in' in blender source code) |
||||
* @param materialColor |
||||
* the texture color (variable 'out' in blender source coude) |
||||
* @param color |
||||
* the previous color (variable 'tex' in blender source code) |
||||
* @param textureIntensity |
||||
* texture intensity (variable 'fact' in blender source code) |
||||
* @param textureFactor |
||||
* texture affection factor (variable 'facg' in blender source |
||||
* code) |
||||
* @param blendtype |
||||
* the blend type |
||||
* @param blenderContext |
||||
* the blender context |
||||
*/ |
||||
protected void blendPixel(float[] result, float[] materialColor, float[] color, float textureIntensity, float textureFactor, int blendtype, BlenderContext blenderContext) { |
||||
float oneMinusFactor, col; |
||||
textureIntensity *= textureFactor; |
||||
|
||||
switch (blendtype) { |
||||
case MTEX_BLEND: |
||||
oneMinusFactor = 1.0f - textureIntensity; |
||||
result[0] = textureIntensity * color[0] + oneMinusFactor * materialColor[0]; |
||||
result[1] = textureIntensity * color[1] + oneMinusFactor * materialColor[1]; |
||||
result[2] = textureIntensity * color[2] + oneMinusFactor * materialColor[2]; |
||||
break; |
||||
case MTEX_MUL: |
||||
oneMinusFactor = 1.0f - textureFactor; |
||||
result[0] = (oneMinusFactor + textureIntensity * materialColor[0]) * color[0]; |
||||
result[1] = (oneMinusFactor + textureIntensity * materialColor[1]) * color[1]; |
||||
result[2] = (oneMinusFactor + textureIntensity * materialColor[2]) * color[2]; |
||||
break; |
||||
case MTEX_DIV: |
||||
oneMinusFactor = 1.0f - textureIntensity; |
||||
if (color[0] != 0.0) { |
||||
result[0] = (oneMinusFactor * materialColor[0] + textureIntensity * materialColor[0] / color[0]) * 0.5f; |
||||
} |
||||
if (color[1] != 0.0) { |
||||
result[1] = (oneMinusFactor * materialColor[1] + textureIntensity * materialColor[1] / color[1]) * 0.5f; |
||||
} |
||||
if (color[2] != 0.0) { |
||||
result[2] = (oneMinusFactor * materialColor[2] + textureIntensity * materialColor[2] / color[2]) * 0.5f; |
||||
} |
||||
break; |
||||
case MTEX_SCREEN: |
||||
oneMinusFactor = 1.0f - textureFactor; |
||||
result[0] = 1.0f - (oneMinusFactor + textureIntensity * (1.0f - materialColor[0])) * (1.0f - color[0]); |
||||
result[1] = 1.0f - (oneMinusFactor + textureIntensity * (1.0f - materialColor[1])) * (1.0f - color[1]); |
||||
result[2] = 1.0f - (oneMinusFactor + textureIntensity * (1.0f - materialColor[2])) * (1.0f - color[2]); |
||||
break; |
||||
case MTEX_OVERLAY: |
||||
oneMinusFactor = 1.0f - textureFactor; |
||||
if (materialColor[0] < 0.5f) { |
||||
result[0] = color[0] * (oneMinusFactor + 2.0f * textureIntensity * materialColor[0]); |
||||
} else { |
||||
result[0] = 1.0f - (oneMinusFactor + 2.0f * textureIntensity * (1.0f - materialColor[0])) * (1.0f - color[0]); |
||||
} |
||||
if (materialColor[1] < 0.5f) { |
||||
result[1] = color[1] * (oneMinusFactor + 2.0f * textureIntensity * materialColor[1]); |
||||
} else { |
||||
result[1] = 1.0f - (oneMinusFactor + 2.0f * textureIntensity * (1.0f - materialColor[1])) * (1.0f - color[1]); |
||||
} |
||||
if (materialColor[2] < 0.5f) { |
||||
result[2] = color[2] * (oneMinusFactor + 2.0f * textureIntensity * materialColor[2]); |
||||
} else { |
||||
result[2] = 1.0f - (oneMinusFactor + 2.0f * textureIntensity * (1.0f - materialColor[2])) * (1.0f - color[2]); |
||||
} |
||||
break; |
||||
case MTEX_SUB: |
||||
result[0] = materialColor[0] - textureIntensity * color[0]; |
||||
result[1] = materialColor[1] - textureIntensity * color[1]; |
||||
result[2] = materialColor[2] - textureIntensity * color[2]; |
||||
result[0] = FastMath.clamp(result[0], 0.0f, 1.0f); |
||||
result[1] = FastMath.clamp(result[1], 0.0f, 1.0f); |
||||
result[2] = FastMath.clamp(result[2], 0.0f, 1.0f); |
||||
break; |
||||
case MTEX_ADD: |
||||
result[0] = (textureIntensity * color[0] + materialColor[0]) * 0.5f; |
||||
result[1] = (textureIntensity * color[1] + materialColor[1]) * 0.5f; |
||||
result[2] = (textureIntensity * color[2] + materialColor[2]) * 0.5f; |
||||
break; |
||||
case MTEX_DIFF: |
||||
oneMinusFactor = 1.0f - textureIntensity; |
||||
result[0] = oneMinusFactor * materialColor[0] + textureIntensity * Math.abs(materialColor[0] - color[0]); |
||||
result[1] = oneMinusFactor * materialColor[1] + textureIntensity * Math.abs(materialColor[1] - color[1]); |
||||
result[2] = oneMinusFactor * materialColor[2] + textureIntensity * Math.abs(materialColor[2] - color[2]); |
||||
break; |
||||
case MTEX_DARK: |
||||
col = textureIntensity * color[0]; |
||||
result[0] = col < materialColor[0] ? col : materialColor[0]; |
||||
col = textureIntensity * color[1]; |
||||
result[1] = col < materialColor[1] ? col : materialColor[1]; |
||||
col = textureIntensity * color[2]; |
||||
result[2] = col < materialColor[2] ? col : materialColor[2]; |
||||
break; |
||||
case MTEX_LIGHT: |
||||
col = textureIntensity * color[0]; |
||||
result[0] = col > materialColor[0] ? col : materialColor[0]; |
||||
col = textureIntensity * color[1]; |
||||
result[1] = col > materialColor[1] ? col : materialColor[1]; |
||||
col = textureIntensity * color[2]; |
||||
result[2] = col > materialColor[2] ? col : materialColor[2]; |
||||
break; |
||||
case MTEX_BLEND_HUE: |
||||
case MTEX_BLEND_SAT: |
||||
case MTEX_BLEND_VAL: |
||||
case MTEX_BLEND_COLOR: |
||||
System.arraycopy(materialColor, 0, result, 0, 3); |
||||
this.blendHSV(blendtype, result, textureIntensity, color, blenderContext); |
||||
break; |
||||
default: |
||||
throw new IllegalStateException("Unknown blend type: " + blendtype); |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue