diff options
Diffstat (limited to 'src/javax/media/j3d/TextureAttributesRetained.java')
| -rw-r--r-- | src/javax/media/j3d/TextureAttributesRetained.java | 996 |
1 files changed, 996 insertions, 0 deletions
diff --git a/src/javax/media/j3d/TextureAttributesRetained.java b/src/javax/media/j3d/TextureAttributesRetained.java new file mode 100644 index 0000000..a31d8fc --- /dev/null +++ b/src/javax/media/j3d/TextureAttributesRetained.java @@ -0,0 +1,996 @@ +/* + * Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package javax.media.j3d; + +import java.util.ArrayList; + +import javax.vecmath.Color4f; + +/** + * The TextureAttributes object defines attributes that apply to + * to texture mapping. + */ +class TextureAttributesRetained extends NodeComponentRetained { + + // A list of pre-defined bits to indicate which component + // in this TextureAttributes object changed. + static final int TRANSFORM_CHANGED = 0x0001; + static final int MODE_CHANGED = 0x0002; + static final int COLOR_CHANGED = 0x0004; + static final int CORRECTION_CHANGED = 0x0008; + static final int TEXTURE_COLOR_TABLE_CHANGED = 0x0010; + static final int COMBINE_RGB_MODE_CHANGED = 0x0020; + static final int COMBINE_ALPHA_MODE_CHANGED = 0x0040; + static final int COMBINE_RGB_SRC_CHANGED = 0x0080; + static final int COMBINE_ALPHA_SRC_CHANGED = 0x0100; + static final int COMBINE_RGB_FCN_CHANGED = 0x0200; + static final int COMBINE_ALPHA_FCN_CHANGED = 0x0400; + static final int COMBINE_RGB_SCALE_CHANGED = 0x0800; + static final int COMBINE_ALPHA_SCALE_CHANGED = 0x1000; + + // static class variable for enums. Currently only supports 0 - 9. + static final Integer[] enums; + + // Texture transform + Transform3D transform = new Transform3D(); + + // Texture mode + int textureMode = TextureAttributes.REPLACE; + + // Texture blend color + Color4f textureBlendColor = new Color4f(0.0f, 0.0f, 0.0f, 0.0f); + + // Texture color table + int textureColorTable[] = null; + int numTextureColorTableComponents = 0; + int textureColorTableSize = 0; + + // Texture Combine Mode + + int combineRgbMode = TextureAttributes.COMBINE_MODULATE; + int combineAlphaMode = TextureAttributes.COMBINE_MODULATE; + + // the following fields are only applicable if textureMode specifies + // COMBINE. If COMBINE mode is specified, then each of the following + // fields will be referencing an array of 3 integers, each representing + // an operand in the combine equation. + int [] combineRgbSrc = null; + int [] combineAlphaSrc = null; + int [] combineRgbFcn = null; + int [] combineAlphaFcn = null; + + int combineRgbScale = 1; + int combineAlphaScale = 1; + + //Perspective correction mode, used for color/texCoord interpolation + int perspCorrectionMode = TextureAttributes.NICEST; + + // true when mirror texCoord component set + boolean mirrorCompDirty = false; + + static { + // create some of the enums Integer to be used in the messages + // this can be eliminated if the message is modified to take + // integer itself + // + // NOTE: check with the actual enum value before using this + // list. This list only supports 0 - 9 + enums = new Integer[10]; + for (int i = 0; i < enums.length; i++) { + enums[i] = new Integer(i); + } + } + + TextureAttributesRetained() {} + + // initCombineMode -- initializes the combine mode related fields + // delay the allocation of memory to minimize + // memory footprint + + final void initCombineMode(TextureAttributesRetained tr) { + tr.combineRgbSrc = new int[3]; + tr.combineAlphaSrc = new int[3]; + tr.combineRgbFcn = new int[3]; + tr.combineAlphaFcn = new int[3]; + + //default values + + tr.combineRgbSrc[0] = TextureAttributes.COMBINE_TEXTURE_COLOR; + tr.combineRgbSrc[1] = TextureAttributes.COMBINE_PREVIOUS_TEXTURE_UNIT_STATE; + tr.combineRgbSrc[2] = TextureAttributes.COMBINE_CONSTANT_COLOR; + + tr.combineAlphaSrc[0] = TextureAttributes.COMBINE_TEXTURE_COLOR; + tr.combineAlphaSrc[1] = TextureAttributes.COMBINE_PREVIOUS_TEXTURE_UNIT_STATE; + tr.combineAlphaSrc[2] = TextureAttributes.COMBINE_CONSTANT_COLOR; + + tr.combineRgbFcn[0] = TextureAttributes.COMBINE_SRC_COLOR; + tr.combineRgbFcn[1] = TextureAttributes.COMBINE_SRC_COLOR; + tr.combineRgbFcn[2] = TextureAttributes.COMBINE_SRC_COLOR; + + tr.combineAlphaFcn[0] = TextureAttributes.COMBINE_SRC_ALPHA; + tr.combineAlphaFcn[1] = TextureAttributes.COMBINE_SRC_ALPHA; + tr.combineAlphaFcn[2] = TextureAttributes.COMBINE_SRC_ALPHA; + } + + final void initTextureMode(int textureMode) { + this.textureMode = textureMode; + + if (textureMode == TextureAttributes.COMBINE) { + if (combineRgbSrc == null) { + initCombineMode(this); + } + } + } + + /** + * Sets the texture mode parameter for this + * appearance component object. + * @param textureMode the texture mode, one of: MODULATE, + * DECAL, BLEND, or REPLACE + */ + final void setTextureMode(int textureMode) { + initTextureMode(textureMode); + sendMessage(MODE_CHANGED, enums[textureMode], null); + } + + /** + * Gets the texture mode parameter for this + * texture attributes object. + * @return textureMode the texture mode + */ + final int getTextureMode() { + return textureMode; + } + + final void initTextureBlendColor(Color4f textureBlendColor) { + this.textureBlendColor.set(textureBlendColor); + + } + + /** + * Sets the texture blend color for this + * texture attributes object. + * @param textureBlendColor the texture blend color used when + * the mode is BLEND + */ + final void setTextureBlendColor(Color4f textureBlendColor) { + this.textureBlendColor.set(textureBlendColor); + sendMessage(COLOR_CHANGED, new Color4f(textureBlendColor), null); + } + + + final void initTextureBlendColor(float r, float g, float b, float a) { + this.textureBlendColor.set(r, g, b, a); + } + + + /** + * Sets the texture blend color for this + * appearance component object. This color is used when + * the mode is BLEND. + * @param r the red component of the color + * @param g the green component of the color + * @param b the blue component of the color + * @param a the alpha component of the color + */ + final void setTextureBlendColor(float r, float g, float b, float a) { + this.textureBlendColor.set(r, g, b, a); + sendMessage(COLOR_CHANGED, new Color4f(r, g, b, a), null); + } + + + /** + * Gets the texture blend color for this + * appearance component object. + * @param textureBlendColor the vector that will receive the texture + * blend color used when the mode is BLEND + */ + final void getTextureBlendColor(Color4f textureBlendColor) { + textureBlendColor.set(this.textureBlendColor); + } + + + final void initTextureTransform(Transform3D transform) { + this.transform.set(transform); + } + + + /** + * Sets the texture transform object used to transform texture + * coordinates. A copy of the specified Transform3D object is + * stored in this TextureAttributes object. + * @param transform the new transform object + */ + final void setTextureTransform(Transform3D transform) { + this.transform.set(transform); + sendMessage(TRANSFORM_CHANGED, new Transform3D(transform), null); + } + + + /** + * Retrieves a copy of the texture transform object. + * @param transform the transform object that will receive the + * current texture transform. + */ + final void getTextureTransform(Transform3D transform) { + transform.set(this.transform); + } + + + final void initPerspectiveCorrectionMode(int mode) { + this.perspCorrectionMode = mode; + } + + /** + * Sets perspective correction mode to be used for color + * and/or texture coordinate interpolation. + * A value of NICEST indicates that perspective correction should be + * performed and that the highest quality method should be used. + * A value of FASTEST indicates that the most efficient perspective + * correction method should be used. + * @param mode one of NICEST or FASTEST. + * The default value is NICEST. + */ + final void setPerspectiveCorrectionMode(int mode) { + this.perspCorrectionMode = mode; + sendMessage(CORRECTION_CHANGED, enums[mode], null); + } + + /** + * Gets perspective correction mode value. + * @return mode the value of perspective correction mode. + */ + final int getPerspectiveCorrectionMode() { + return perspCorrectionMode; + } + + final void setTextureColorTable(int[][] table) { + initTextureColorTable(table); + + //clone a copy of the texture for the mirror object + if (table == null) { + sendMessage(TEXTURE_COLOR_TABLE_CHANGED, null, null); + } else { + int ctable[] = new int[textureColorTableSize * + numTextureColorTableComponents]; + System.arraycopy(textureColorTable, 0, ctable, 0, + textureColorTable.length); + Object args[] = new Object[3]; + + args[0] = new Integer(numTextureColorTableComponents); + args[1] = new Integer(textureColorTableSize); + args[2] = ctable; + sendMessage(TEXTURE_COLOR_TABLE_CHANGED, args, null); + } + } + + final void initTextureColorTable(int[][] table) { + + numTextureColorTableComponents = 0; + textureColorTableSize = 0; + + if (table == null) { + textureColorTable = null; + return; + } + + if (table.length < 3 || table.length > 4) { + throw new IllegalArgumentException(J3dI18N.getString("TextureAttributes13")); + } + + if (Texture.getPowerOf2(table[0].length) == -1) { + throw new IllegalArgumentException(J3dI18N.getString("TextureAttributes14")); + } + + for (int i = 1; i < table.length; i++) { + if (table[i].length != table[0].length) + throw new IllegalArgumentException(J3dI18N.getString("TextureAttributes15")); + } + + numTextureColorTableComponents = table.length; + textureColorTableSize = table[0].length; + + if (textureColorTable == null || + textureColorTable.length != numTextureColorTableComponents * + textureColorTableSize) { + textureColorTable = new int[numTextureColorTableComponents * + textureColorTableSize]; + } + + int k = 0; + for (int i = 0; i < textureColorTableSize; i++) { + for (int j = 0; j < numTextureColorTableComponents; j++) { + textureColorTable[k++] = table[j][i]; + } + } + } + + + final void getTextureColorTable(int[][] table) { + + if (textureColorTable == null) + return; + + int k = 0; + for (int i = 0; i < textureColorTableSize; i++) { + for (int j = 0; j < numTextureColorTableComponents; j++) { + table[j][i] = textureColorTable[k++]; + } + } + } + + final int getNumTextureColorTableComponents() { + return numTextureColorTableComponents; + } + + final int getTextureColorTableSize() { + return textureColorTableSize; + } + + + final void initCombineRgbMode(int mode) { + combineRgbMode = mode; + } + + final void setCombineRgbMode(int mode) { + initCombineRgbMode(mode); + sendMessage(COMBINE_RGB_MODE_CHANGED, enums[mode], null); + } + + final int getCombineRgbMode() { + return combineRgbMode; + } + + final void initCombineAlphaMode(int mode) { + combineAlphaMode = mode; + } + + final void setCombineAlphaMode(int mode) { + initCombineAlphaMode(mode); + sendMessage(COMBINE_ALPHA_MODE_CHANGED, enums[mode], null); + } + + final int getCombineAlphaMode() { + return combineAlphaMode; + } + + final void initCombineRgbSource(int index, int src) { + if (combineRgbSrc == null) { + // it is possible to set the combineRgbSource before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + combineRgbSrc[index] = src; + } + + final void setCombineRgbSource(int index, int src) { + initCombineRgbSource(index, src); + sendMessage(COMBINE_RGB_SRC_CHANGED, enums[index], enums[src]); + } + + final int getCombineRgbSource(int index) { + if (combineRgbSrc == null) { + // it is possible to do a get before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + return combineRgbSrc[index]; + } + + final void initCombineAlphaSource(int index, int src) { + if (combineRgbSrc == null) { + // it is possible to set the combineAlphaSource before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + combineAlphaSrc[index] = src; + } + + final void setCombineAlphaSource(int index, int src) { + initCombineAlphaSource(index, src); + sendMessage(COMBINE_ALPHA_SRC_CHANGED, enums[index], enums[src]); + } + + final int getCombineAlphaSource(int index) { + if (combineRgbSrc == null) { + // it is possible to do a get before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + return combineAlphaSrc[index]; + } + + final void initCombineRgbFunction(int index, int fcn) { + if (combineRgbSrc == null) { + // it is possible to set the combineRgbFcn before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + combineRgbFcn[index] = fcn; + } + + final void setCombineRgbFunction(int index, int fcn) { + initCombineRgbFunction(index, fcn); + sendMessage(COMBINE_RGB_FCN_CHANGED, enums[index], enums[fcn]); + } + + final int getCombineRgbFunction(int index) { + if (combineRgbSrc == null) { + // it is possible to do a get before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + return combineRgbFcn[index]; + } + + final void initCombineAlphaFunction(int index, int fcn) { + if (combineRgbSrc == null) { + // it is possible to set the combineAlphaFcn before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + combineAlphaFcn[index] = fcn; + } + + final void setCombineAlphaFunction(int index, int fcn) { + initCombineAlphaFunction(index, fcn); + sendMessage(COMBINE_ALPHA_FCN_CHANGED, enums[index], enums[fcn]); + } + + final int getCombineAlphaFunction(int index) { + if (combineRgbSrc == null) { + // it is possible to do a get before + // setting the texture mode to COMBINE, so need to initialize + // the combine mode related fields here + initCombineMode(this); + } + return combineAlphaFcn[index]; + } + + final void initCombineRgbScale(int scale) { + combineRgbScale = scale; + } + + final void setCombineRgbScale(int scale) { + initCombineRgbScale(scale); + sendMessage(COMBINE_RGB_SCALE_CHANGED, enums[scale], null); + } + + final int getCombineRgbScale() { + return combineRgbScale; + } + + final void initCombineAlphaScale(int scale) { + combineAlphaScale = scale; + } + + final void setCombineAlphaScale(int scale) { + initCombineAlphaScale(scale); + sendMessage(COMBINE_ALPHA_SCALE_CHANGED, enums[scale], null); + } + + final int getCombineAlphaScale() { + return combineAlphaScale; + } + + void updateNative(Canvas3D cv, boolean simulate, int textureFormat) { + + //System.err.println("TextureAttributes/updateNative: simulate= " + simulate + " " + this); + + //if ((cv.textureExtendedFeatures & Canvas3D.TEXTURE_COLOR_TABLE) + // == 0) && textureColorTable != null) { + // System.err.println("TextureColorTable Not supported"); + //} + + //System.err.println("textureMode= " + textureMode); + boolean isIdentity = + ((transform.getType() & Transform3D.IDENTITY) != 0); + + if (simulate == false) { + if (VirtualUniverse.mc.useCombiners && + (cv.textureExtendedFeatures & + Canvas3D.TEXTURE_REGISTER_COMBINERS) != 0) { + Pipeline.getPipeline().updateRegisterCombiners(cv.ctx, + transform.mat, isIdentity, textureMode, perspCorrectionMode, + textureBlendColor.x, textureBlendColor.y, + textureBlendColor.z, textureBlendColor.w, + textureFormat, combineRgbMode, combineAlphaMode, + combineRgbSrc, combineAlphaSrc, + combineRgbFcn, combineAlphaFcn, + combineRgbScale, combineAlphaScale); + } else { + if (textureMode == TextureAttributes.COMBINE) { + + if ((cv.textureExtendedFeatures & + Canvas3D.TEXTURE_COMBINE) != 0) { + + // Texture COMBINE is supported by the underlying layer + + int _combineRgbMode = combineRgbMode; + int _combineAlphaMode = combineAlphaMode; + + Pipeline.getPipeline().updateTextureAttributes(cv.ctx, + transform.mat, isIdentity, textureMode, + perspCorrectionMode, + textureBlendColor.x, textureBlendColor.y, + textureBlendColor.z, textureBlendColor.w, + textureFormat); + + + if (((combineRgbMode == TextureAttributes.COMBINE_DOT3) && + ((cv.textureExtendedFeatures & + Canvas3D.TEXTURE_COMBINE_DOT3) == 0)) || + ((combineRgbMode == TextureAttributes.COMBINE_SUBTRACT) && + ((cv.textureExtendedFeatures & + Canvas3D.TEXTURE_COMBINE_SUBTRACT) == 0))) { + + // Combine DOT3/SUBTRACT is not supported by the + // underlying layer, fallback to COMBINE_REPLACE + + _combineRgbMode = TextureAttributes.COMBINE_REPLACE; + } + + if (((combineAlphaMode == TextureAttributes.COMBINE_DOT3) && + ((cv.textureExtendedFeatures & + Canvas3D.TEXTURE_COMBINE_DOT3) == 0)) || + ((combineAlphaMode == TextureAttributes.COMBINE_SUBTRACT) && + ((cv.textureExtendedFeatures & + Canvas3D.TEXTURE_COMBINE_SUBTRACT) == 0))) { + + // Combine DOT3/SUBTRACT is not supported by the + // underlying layer, fallback to COMBINE_REPLACE + + _combineAlphaMode = TextureAttributes.COMBINE_REPLACE; + } + + Pipeline.getPipeline().updateCombiner(cv.ctx, + _combineRgbMode, _combineAlphaMode, + combineRgbSrc, combineAlphaSrc, + combineRgbFcn, combineAlphaFcn, + combineRgbScale, combineAlphaScale); + + } else { + + // Texture COMBINE is not supported by the underlying + // layer, fallback to REPLACE + + Pipeline.getPipeline().updateTextureAttributes(cv.ctx, + transform.mat, isIdentity, + TextureAttributes.REPLACE, + perspCorrectionMode, + textureBlendColor.x, textureBlendColor.y, + textureBlendColor.z, textureBlendColor.w, + textureFormat); + } + } else { + Pipeline.getPipeline().updateTextureAttributes(cv.ctx, + transform.mat, isIdentity, textureMode, + perspCorrectionMode, + textureBlendColor.x, textureBlendColor.y, + textureBlendColor.z, textureBlendColor.w, + textureFormat); + } + } + + + if (((cv.textureExtendedFeatures & Canvas3D.TEXTURE_COLOR_TABLE) + != 0) && textureColorTable != null) { + + Pipeline.getPipeline().updateTextureColorTable(cv.ctx, + numTextureColorTableComponents, + textureColorTableSize, textureColorTable); + } + } else { + // we are in the multi-pass mode, + // in this case, set the texture Mode to replace and use + // blending to simulate the original textureMode + Pipeline.getPipeline().updateTextureAttributes(cv.ctx, + transform.mat, isIdentity, TextureAttributes.REPLACE, + perspCorrectionMode, + textureBlendColor.x, textureBlendColor.y, + textureBlendColor.z, textureBlendColor.w, textureFormat); + + if (((cv.textureExtendedFeatures & Canvas3D.TEXTURE_COLOR_TABLE) + != 0) && textureColorTable != null) { + + Pipeline.getPipeline().updateTextureColorTable(cv.ctx, numTextureColorTableComponents, + textureColorTableSize, textureColorTable); + } + + switch (textureMode) { + case TextureAttributes.COMBINE: + case TextureAttributes.REPLACE: + cv.setBlendFunc(cv.ctx, + TransparencyAttributes.BLEND_ONE, + TransparencyAttributes.BLEND_ZERO); + break; + case TextureAttributes.MODULATE: + cv.setBlendFunc(cv.ctx, + TransparencyAttributes.BLEND_DST_COLOR, + TransparencyAttributes.BLEND_ZERO); + break; + case TextureAttributes.DECAL: + if (textureFormat == Texture.RGBA) { + cv.setBlendFunc(cv.ctx, + TransparencyAttributes.BLEND_SRC_ALPHA, + TransparencyAttributes.BLEND_ONE_MINUS_SRC_ALPHA); + } else { + cv.setBlendFunc(cv.ctx, + TransparencyAttributes.BLEND_ONE, + TransparencyAttributes.BLEND_ZERO); + } + break; + case TextureAttributes.BLEND: + cv.setBlendColor(cv.ctx, textureBlendColor.x, textureBlendColor.y, + textureBlendColor.z, textureBlendColor.w); + cv.setBlendFunc(cv.ctx, + TransparencyAttributes.BLEND_CONSTANT_COLOR, + TransparencyAttributes.BLEND_ONE_MINUS_SRC_COLOR); + break; + } + } + } + + + /** + * Creates and initializes a mirror object, point the mirror object + * to the retained object if the object is not editable + */ + @Override + synchronized void createMirrorObject() { + + if (mirror == null) { + // Check the capability bits and let the mirror object + // point to itself if is not editable + if (isStatic()) { + mirror = this; + } else { + TextureAttributesRetained mirrorTa = new TextureAttributesRetained(); + mirrorTa.source = source; + mirrorTa.set(this); + mirror = mirrorTa; + } + } else { + ((TextureAttributesRetained)mirror).set(this); + } + } + + /** + * Initializes a mirror object + */ + @Override + synchronized void initMirrorObject() { + ((TextureAttributesRetained)mirror).set(this); + } + + + /** + * Update the "component" field of the mirror object with the + * given "value" + */ + synchronized void updateMirrorObject(int component, Object value, + Object value2) { + TextureAttributesRetained mirrorTa = (TextureAttributesRetained)mirror; + mirrorTa.mirrorCompDirty = true; + + if ((component & TRANSFORM_CHANGED) != 0) { + mirrorTa.transform.set((Transform3D)value); + } + else if ((component & MODE_CHANGED) != 0) { + mirrorTa.textureMode = ((Integer)value).intValue(); + + if ((mirrorTa.textureMode == TextureAttributes.COMBINE) && + (mirrorTa.combineRgbSrc == null)) { + initCombineMode(mirrorTa); + } + } + else if ((component & COLOR_CHANGED) != 0) { + mirrorTa.textureBlendColor.set((Color4f)value); + } + else if ((component & CORRECTION_CHANGED) != 0) { + mirrorTa.perspCorrectionMode = ((Integer)value).intValue(); + } + else if ((component & TEXTURE_COLOR_TABLE_CHANGED) != 0) { + if (value == null) { + mirrorTa.textureColorTable = null; + mirrorTa.numTextureColorTableComponents = 0; + mirrorTa.textureColorTableSize = 0; + } else { + Object args[] = (Object[])value; + mirrorTa.textureColorTable = (int[])args[2]; + mirrorTa.numTextureColorTableComponents = + ((Integer)args[0]).intValue(); + mirrorTa.textureColorTableSize = + ((Integer)args[1]).intValue(); + } + } + else if ((component & COMBINE_RGB_MODE_CHANGED) != 0) { + mirrorTa.combineRgbMode = ((Integer)value).intValue(); + } + else if ((component & COMBINE_ALPHA_MODE_CHANGED) != 0) { + mirrorTa.combineAlphaMode = ((Integer)value).intValue(); + } + else if ((component & COMBINE_RGB_SRC_CHANGED) != 0) { + if (mirrorTa.combineRgbSrc == null) { + //initialize the memory for combine mode + initCombineMode(mirrorTa); + } + int index = ((Integer)value).intValue(); + mirrorTa.combineRgbSrc[index] = ((Integer)value2).intValue(); + } + else if ((component & COMBINE_ALPHA_SRC_CHANGED) != 0) { + if (mirrorTa.combineRgbSrc == null) { + //initialize the memory for combine mode + initCombineMode(mirrorTa); + } + int index = ((Integer)value).intValue(); + mirrorTa.combineAlphaSrc[index] = ((Integer)value2).intValue(); + } + else if ((component & COMBINE_RGB_FCN_CHANGED) != 0) { + if (mirrorTa.combineRgbSrc == null) { + //initialize the memory for combine mode + initCombineMode(mirrorTa); + } + int index = ((Integer)value).intValue(); + mirrorTa.combineRgbFcn[index] = ((Integer)value2).intValue(); + } + else if ((component & COMBINE_ALPHA_FCN_CHANGED) != 0) { + if (mirrorTa.combineRgbSrc == null) { + //initialize the memory for combine mode + initCombineMode(mirrorTa); + } + int index = ((Integer)value).intValue(); + mirrorTa.combineAlphaFcn[index] = ((Integer)value2).intValue(); + } + else if ((component & COMBINE_RGB_SCALE_CHANGED) != 0) { + mirrorTa.combineRgbScale = ((Integer)value).intValue(); + } + else if ((component & COMBINE_ALPHA_SCALE_CHANGED) != 0) { + mirrorTa.combineAlphaScale = ((Integer)value).intValue(); + } + } + + + boolean equivalent(TextureAttributesRetained tr) { + + if (tr == null) { + return (false); + + } else if ((this.changedFrequent != 0) || (tr.changedFrequent != 0)) { + return (this == tr); + } + + if (!(tr.transform.equals(transform) && + tr.textureBlendColor.equals(textureBlendColor) && + (tr.textureMode == textureMode) && + (tr.perspCorrectionMode == perspCorrectionMode))) { + return false; + } + + + // now check for combine mode attributes if textureMode specifies + // COMBINE + + if (textureMode == TextureAttributes.COMBINE) { + + if ((tr.combineRgbMode != combineRgbMode) || + (tr.combineAlphaMode != combineAlphaMode) || + (tr.combineRgbScale != combineRgbScale) || + (tr.combineAlphaScale != combineAlphaScale)) { + return false; + } + + // now check if the operands for the combine equations are + // equivalent + + int nOpNeeded = 0; + + if (combineRgbMode == TextureAttributes.COMBINE_REPLACE) { + nOpNeeded = 1; + } else if (combineRgbMode == TextureAttributes.COMBINE_INTERPOLATE) { + nOpNeeded = 3; + } else { + nOpNeeded = 2; + } + + for (int i = 0; i < nOpNeeded; i++) { + if ((tr.combineRgbSrc[i] != combineRgbSrc[i]) || + (tr.combineAlphaSrc[i] != combineAlphaSrc[i]) || + (tr.combineRgbFcn[i] != combineRgbFcn[i]) || + (tr.combineAlphaFcn[i] != combineAlphaFcn[i])) { + return false; + } + } + } + + // now check for texture color table + + if (tr.textureColorTable == null) { + if (this.textureColorTable == null) + return true; + else + return false; + } else if (this.textureColorTable == null) { + // tr.textureColorTable != null + return false; + } else { + if (tr.textureColorTable.length != this.textureColorTable.length) + return false; + + for (int i = 0; i < this.textureColorTable.length; i++) { + if (this.textureColorTable[i] != tr.textureColorTable[i]) + return false; + } + + return true; + } + + } + + + @Override + protected Object clone() { + TextureAttributesRetained tr = (TextureAttributesRetained)super.clone(); + tr.transform = new Transform3D(transform); + tr.textureBlendColor = new Color4f(textureBlendColor); + if (textureColorTable != null) { + tr.textureColorTable = new int[textureColorTable.length]; + System.arraycopy(textureColorTable, 0, tr.textureColorTable, 0, + textureColorTable.length); + } else { + tr.textureColorTable = null; + } + + // clone the combine mode attributes + if (combineRgbSrc != null) { + tr.combineRgbSrc = new int[3]; + tr.combineAlphaSrc = new int[3]; + tr.combineRgbFcn = new int[3]; + tr.combineAlphaFcn = new int[3]; + + for (int i = 0; i < 3; i++) { + tr.combineRgbSrc[i] = combineRgbSrc[i]; + tr.combineAlphaSrc[i] = combineAlphaSrc[i]; + tr.combineRgbFcn[i] = combineRgbFcn[i]; + tr.combineAlphaFcn[i] = combineAlphaFcn[i]; + } + } + + // other attributes are copied in super.clone() + return tr; + } + + protected void set(TextureAttributesRetained tr) { + super.set(tr); + transform.set(tr.transform); + textureBlendColor.set(tr.textureBlendColor); + textureMode = tr.textureMode; + perspCorrectionMode = tr.perspCorrectionMode; + + // set texture color table + + if (tr.textureColorTable != null) { + if (textureColorTable == null || + textureColorTable.length != tr.textureColorTable.length) { + textureColorTable = new int[tr.textureColorTable.length]; + } + System.arraycopy(tr.textureColorTable, 0, textureColorTable, 0, + tr.textureColorTable.length); + } else { + textureColorTable = null; + } + numTextureColorTableComponents = tr.numTextureColorTableComponents; + textureColorTableSize = tr.textureColorTableSize; + + + // set the combine mode attributes + + combineRgbMode = tr.combineRgbMode; + combineAlphaMode = tr.combineAlphaMode; + combineRgbScale = tr.combineRgbScale; + combineAlphaScale = tr.combineAlphaScale; + + if (tr.combineRgbSrc != null) { + if (combineRgbSrc == null) { + combineRgbSrc = new int[3]; + combineAlphaSrc = new int[3]; + combineRgbFcn = new int[3]; + combineAlphaFcn = new int[3]; + } + + for (int i = 0; i < 3; i++) { + combineRgbSrc[i] = tr.combineRgbSrc[i]; + combineAlphaSrc[i] = tr.combineAlphaSrc[i]; + combineRgbFcn[i] = tr.combineRgbFcn[i]; + combineAlphaFcn[i] = tr.combineAlphaFcn[i]; + } + } + } + + + final void sendMessage(int attrMask, Object attr1, Object attr2) { + + ArrayList<VirtualUniverse> univList = new ArrayList<VirtualUniverse>(); + ArrayList<ArrayList<GeometryAtom>> gaList = Shape3DRetained.getGeomAtomsList(mirror.users, univList); + + + // Send to rendering attribute structure, regardless of + // whether there are users or not (alternate appearance case ..) + J3dMessage createMessage = new J3dMessage(); + createMessage.threads = J3dThread.UPDATE_RENDERING_ATTRIBUTES; + createMessage.type = J3dMessage.TEXTUREATTRIBUTES_CHANGED; + createMessage.universe = null; + createMessage.args[0] = this; + createMessage.args[1] = new Integer(attrMask); + createMessage.args[2] = attr1; + createMessage.args[3] = attr2; + createMessage.args[4] = new Integer(changedFrequent); + VirtualUniverse.mc.processMessage(createMessage); + + + // System.err.println("univList.size is " + univList.size()); + for(int i=0; i<univList.size(); i++) { + createMessage = new J3dMessage(); + createMessage.threads = J3dThread.UPDATE_RENDER; + createMessage.type = J3dMessage.TEXTUREATTRIBUTES_CHANGED; + + createMessage.universe = univList.get(i); + createMessage.args[0] = this; + createMessage.args[1] = new Integer(attrMask); + createMessage.args[2] = attr1; + + ArrayList<GeometryAtom> gL = gaList.get(i); + GeometryAtom[] gaArr = new GeometryAtom[gL.size()]; + gL.toArray(gaArr); + createMessage.args[3] = gaArr; + + VirtualUniverse.mc.processMessage(createMessage); + } + } + + @Override + void handleFrequencyChange(int bit) { + switch (bit) { + case TextureAttributes.ALLOW_MODE_WRITE: + case TextureAttributes.ALLOW_BLEND_COLOR_WRITE: + case TextureAttributes.ALLOW_TRANSFORM_WRITE: + case TextureAttributes.ALLOW_COLOR_TABLE_WRITE: + case TextureAttributes.ALLOW_COMBINE_WRITE: { + setFrequencyChangeMask(bit, bit); + } + default: + break; + } + } +} |