textureloader.java

JAVA3D矩陈的相关类

     /**
     * Choose the correct ImageComponent and Texture format for the given
     * image
     */
    private void chooseFormat(BufferedImage image) {
        switch (image.getType()) {
            case BufferedImage.TYPE_4BYTE_ABGR :  
            case BufferedImage.TYPE_INT_ARGB :
                imageComponentFormat = ImageComponent.FORMAT_RGBA;
                textureFormat = Texture.RGBA;
                break;
            case BufferedImage.TYPE_3BYTE_BGR :
            case BufferedImage.TYPE_INT_BGR:
            case BufferedImage.TYPE_INT_RGB:                
                imageComponentFormat = ImageComponent.FORMAT_RGB;
                textureFormat = Texture.RGB;
                break;
            case BufferedImage.TYPE_CUSTOM:
                if (is4ByteRGBAOr3ByteRGB(image)) {
                    SampleModel sm = image.getSampleModel();
                    if (sm.getNumBands() == 3) {
                        //System.out.println("ChooseFormat Custom:TYPE_4BYTE_ABGR");
                        imageComponentFormat = ImageComponent.FORMAT_RGB;
                        textureFormat = Texture.RGB;
                    }
                    else {
                        imageComponentFormat = ImageComponent.FORMAT_RGBA;
                        //System.out.println("ChooseFormat Custom:TYPE_3BYTE_BGR");
                        textureFormat = Texture.RGBA;
                    }
                }
                break;
            default :
                // System.err.println("Unoptimized Image Type "+image.getType());
                imageComponentFormat = ImageComponent.FORMAT_RGBA;
                textureFormat = Texture.RGBA;
                break;
        }
    }   

    private boolean is4ByteRGBAOr3ByteRGB(RenderedImage ri) {
        boolean value = false;
        int i;
        int biType = getImageType(ri);
        if (biType != BufferedImage.TYPE_CUSTOM)
            return false;
        ColorModel cm = ri.getColorModel();
        ColorSpace cs = cm.getColorSpace();
        SampleModel sm = ri.getSampleModel();
        boolean isAlphaPre = cm.isAlphaPremultiplied();
        int csType = cs.getType();
        if ( csType == ColorSpace.TYPE_RGB) {
            int numBands = sm.getNumBands();
            if (sm.getDataType() == DataBuffer.TYPE_BYTE) {
                if (cm instanceof ComponentColorModel &&
                    sm instanceof PixelInterleavedSampleModel) {
                    PixelInterleavedSampleModel csm = 
				(PixelInterleavedSampleModel) sm;
                    int[] offs = csm.getBandOffsets();
                    ComponentColorModel ccm = (ComponentColorModel)cm;
                    int[] nBits = ccm.getComponentSize();
                    boolean is8Bit = true;
                    for (i=0; i < numBands; i++) {
                        if (nBits[i] != 8) {
                            is8Bit = false;
                            break;
                        }
                    }
                    if (is8Bit &&
                        offs[0] == 0 &&
                        offs[1] == 1 &&
                        offs[2] == 2) {
                        if (numBands == 3) {
                            value = true;
                        }
                        else if (offs[3] == 3 && !isAlphaPre) {
                            value = true;
                        }
                    }
                }
            }
        }
        return value;
    }
    
     private int getImageType(RenderedImage ri) {
        int imageType = BufferedImage.TYPE_CUSTOM;
        int i;

        if (ri instanceof BufferedImage) {
            return ((BufferedImage)ri).getType();
        }
        ColorModel cm = ri.getColorModel();
        ColorSpace cs = cm.getColorSpace();
        SampleModel sm = ri.getSampleModel();
        int csType = cs.getType();
        boolean isAlphaPre = cm.isAlphaPremultiplied();
        if ( csType != ColorSpace.TYPE_RGB) {
            if (csType == ColorSpace.TYPE_GRAY &&
                cm instanceof ComponentColorModel) {
                if (sm.getDataType() == DataBuffer.TYPE_BYTE) {
                    imageType = BufferedImage.TYPE_BYTE_GRAY;
                } else if (sm.getDataType() == DataBuffer.TYPE_USHORT) {
                    imageType = BufferedImage.TYPE_USHORT_GRAY;
                }
            }
        }
        // RGB , only interested in BYTE ABGR and BGR for now
        // all others will be copied to a buffered image
        else {
            int numBands = sm.getNumBands();
            if (sm.getDataType() == DataBuffer.TYPE_BYTE) {
                if (cm instanceof ComponentColorModel &&
                    sm instanceof PixelInterleavedSampleModel) {
                    PixelInterleavedSampleModel csm = 
				(PixelInterleavedSampleModel) sm;
                    int[] offs = csm.getBandOffsets();
                    ComponentColorModel ccm = (ComponentColorModel)cm;
                    int[] nBits = ccm.getComponentSize();
                    boolean is8Bit = true;
                    for (i=0; i < numBands; i++) {
                        if (nBits[i] != 8) {
                            is8Bit = false;
                            break;
                        }
                    }
                    if (is8Bit &&
                        offs[0] == numBands-1 &&
                        offs[1] == numBands-2 &&
                        offs[2] == numBands-3) {
                        if (numBands == 3) {
                            imageType = BufferedImage.TYPE_3BYTE_BGR;
                        }
                        else if (offs[3] == 0) {
                            imageType = (isAlphaPre
                                         ? BufferedImage.TYPE_4BYTE_ABGR_PRE
                                         : BufferedImage.TYPE_4BYTE_ABGR);
                        }
                    }
                }
            }
        }
        return imageType;
    }
         
    // initialize appropriate format for ImageComponent and Texture
    private void parseFormat(String format) {
         if (format==null)
            return;
         
        if (format.equals("RGBA")) {
            imageComponentFormat = ImageComponent.FORMAT_RGBA;
            textureFormat = Texture.RGBA;

        } else if (format.equals("RGBA4")) {                                  
            imageComponentFormat = ImageComponent.FORMAT_RGBA4;
            textureFormat = Texture.RGBA;

        } else if (format.equals("RGB5_A1")) {                                 
            imageComponentFormat = ImageComponent.FORMAT_RGB5_A1;
            textureFormat = Texture.RGBA;

        } else if (format.equals("RGB")) { 
            imageComponentFormat = ImageComponent.FORMAT_RGB;
            textureFormat = Texture.RGB;

        } else if (format.equals("RGB4")) {
            imageComponentFormat = ImageComponent.FORMAT_RGB4;
            textureFormat = Texture.RGB;

        } else if (format.equals("RGB5")) {                                  
            imageComponentFormat = ImageComponent.FORMAT_RGB5;
            textureFormat = Texture.RGB;

        } else if (format.equals("R3_G3_B2")) {                              
            imageComponentFormat = ImageComponent.FORMAT_R3_G3_B2;
            textureFormat = Texture.RGB;
 
        } else if (format.equals("LUM8_ALPHA8")) {
            imageComponentFormat = ImageComponent.FORMAT_LUM8_ALPHA8;
            textureFormat = Texture.LUMINANCE_ALPHA;

        } else if (format.equals("LUM4_ALPHA4")) {
            imageComponentFormat = ImageComponent.FORMAT_LUM4_ALPHA4;
            textureFormat = Texture.LUMINANCE_ALPHA;
       
        } else if (format.equals("LUMINANCE")) {
            imageComponentFormat = ImageComponent.FORMAT_CHANNEL8;
            textureFormat = Texture.LUMINANCE;
 
        } else if (format.equals("ALPHA")) {
            imageComponentFormat = ImageComponent.FORMAT_CHANNEL8;
            textureFormat = Texture.ALPHA;
        }
    }

    // return a scaled image of given width and height
    private BufferedImage getScaledImage(BufferedImage origImage,
                                         int width, int height) {

        int origW = origImage.getWidth();
        int origH = origImage.getHeight();
        float xScale = (float)width/(float)origW;
        float yScale = (float)height/(float)origH;

	return (getScaledImage(origImage, xScale, yScale));
    }

    // return a scaled image of given x and y scale
    private BufferedImage getScaledImage(BufferedImage origImage,
                                         float xScale, float yScale) {


        // System.err.println("(1) origImage " + origImage);
        // If the image is already the requested size, no need to scale
        if (xScale == 1.0f && yScale == 1.0f)
            return origImage;
        else {
            int scaleW = (int)(origImage.getWidth() * xScale + 0.5);
            int scaleH = (int)(origImage.getHeight() * yScale + 0.5);

            int origImageType = origImage.getType();
            BufferedImage scaledImage;
            WritableRaster wr;

            if (origImageType != BufferedImage.TYPE_CUSTOM) {
                WritableRaster origWr = origImage.getRaster();
                wr = origWr.createCompatibleWritableRaster(0, 0, scaleW, scaleH);
                scaledImage = new BufferedImage(scaleW, scaleH, origImageType);
            } else {
                int numComponents = origImage.getSampleModel().getNumBands();
                int[] bandOffset = new int[numComponents];
                int[] nBits = new int[numComponents];
                for (int ii=0; ii < numComponents; ii++) {
                    bandOffset[ii] = ii;
                    nBits[ii] = 8;
                }
                
                wr = java.awt.image.Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
                        scaleW, scaleH,
                        scaleW * numComponents, numComponents,
                        bandOffset, null);

                int imageType;
                
                switch (numComponents) {
                    case 1:
                        imageType = BufferedImage.TYPE_BYTE_GRAY;
                        break;
                    case 3:
                        imageType = BufferedImage.TYPE_3BYTE_BGR;
                        break;
                    case 4:
                        imageType = BufferedImage.TYPE_4BYTE_ABGR;
                        break;
                    default:
                        throw new ImageException("Illegal number of bands : " + numComponents);
                        
                }
                
                scaledImage = new BufferedImage(scaleW, scaleH, imageType);
            }
            
            scaledImage.setData(wr);
            java.awt.Graphics2D g2 = scaledImage.createGraphics();
            AffineTransform at = AffineTransform.getScaleInstance(xScale,
                    yScale);
            g2.transform(at);
            g2.drawImage(origImage, 0, 0, null);

            return scaledImage;
        }
    }

    private int computeLog(int value) {
        int i = 0;

        if (value == 0) return -1;
        for (;;) {
            if (value == 1) 
                return i;
            value >>= 1;
	    i++;
        }
    }

    private int getClosestPowerOf2(int value) {

	if (value < 1)
	    return value;
	
	int powerValue = 1;
	for (;;) {
	    powerValue *= 2;
	    if (value < powerValue) {
		// Found max bound of power, determine which is closest
		int minBound = powerValue/2;
		if ((powerValue - value) >
		    (value - minBound))
		    return minBound;
		else
		    return powerValue;
	    }
	}
    }
}