Java SGL.GL_TEXTURE_2D属性代码示例

/**
    * Reload a given texture blob
    * 
    * @param texture The texture being reloaded
    * @param srcPixelFormat The source pixel format
    * @param componentCount The component count
    * @param minFilter The minification filter
    * @param magFilter The magnification filter 
    * @param textureBuffer The pixel data 
    * @return The ID of the newly created texture
    */
public int reload(TextureImpl texture, int srcPixelFormat, int componentCount,
		int minFilter, int magFilter, ByteBuffer textureBuffer) {
   	int target = SGL.GL_TEXTURE_2D;
       int textureID = createTextureID(); 
       GL.glBindTexture(target, textureID); 
       
       GL.glTexParameteri(target, SGL.GL_TEXTURE_MIN_FILTER, minFilter); 
       GL.glTexParameteri(target, SGL.GL_TEXTURE_MAG_FILTER, magFilter); 
       
       // produce a texture from the byte buffer
       GL.glTexImage2D(target, 
                     0, 
                     dstPixelFormat, 
                     texture.getTextureWidth(), 
                     texture.getTextureHeight(), 
                     0, 
                     srcPixelFormat, 
                     SGL.GL_UNSIGNED_BYTE, 
                     textureBuffer); 
       
       return textureID; 
}
 

/**
 * Get a texture from a image file
 * 
 * @param dataSource The image data to generate the texture from
 * @param filter The filter to use when scaling the texture
 * @return The texture created
 * @throws IOException Indicates the texture is too big for the hardware
 */
public Texture getTexture(ImageData dataSource, int filter) throws IOException
{ 
	int target = SGL.GL_TEXTURE_2D;

    ByteBuffer textureBuffer;
	textureBuffer = dataSource.getImageBufferData();
	
    // create the texture ID for this texture 
    int textureID = createTextureID(); 
    TextureImpl texture = new TextureImpl("generated:"+dataSource, target ,textureID); 
    
    int minFilter = filter;
    int magFilter = filter;
    boolean flipped = false;
    
    // bind this texture 
    GL.glBindTexture(target, textureID); 
	
    int width;
    int height;
    int texWidth;
    int texHeight;
    
    boolean hasAlpha;
	
	width = dataSource.getWidth();
	height = dataSource.getHeight();
	hasAlpha = dataSource.getDepth() == 32;
	
	texture.setTextureWidth(dataSource.getTexWidth());
	texture.setTextureHeight(dataSource.getTexHeight());

    texWidth = texture.getTextureWidth();
    texHeight = texture.getTextureHeight();
    
    int srcPixelFormat = hasAlpha ? SGL.GL_RGBA : SGL.GL_RGB;
    int componentCount = hasAlpha ? 4 : 3;
    
    texture.setWidth(width);
    texture.setHeight(height);
    texture.setAlpha(hasAlpha);
    
    IntBuffer temp = BufferUtils.createIntBuffer(16);
    GL.glGetInteger(SGL.GL_MAX_TEXTURE_SIZE, temp);
    int max = temp.get(0);
    if ((texWidth > max) || (texHeight > max)) {
    	throw new IOException("Attempt to allocate a texture to big for the current hardware");
    }

    if (holdTextureData) {
    	texture.setTextureData(srcPixelFormat, componentCount, minFilter, magFilter, textureBuffer);
    }
    
    GL.glTexParameteri(target, SGL.GL_TEXTURE_MIN_FILTER, minFilter); 
    GL.glTexParameteri(target, SGL.GL_TEXTURE_MAG_FILTER, magFilter); 
    
    // produce a texture from the byte buffer
    GL.glTexImage2D(target, 
                  0, 
                  dstPixelFormat, 
                  get2Fold(width), 
                  get2Fold(height), 
                  0, 
                  srcPixelFormat, 
                  SGL.GL_UNSIGNED_BYTE, 
                  textureBuffer); 
    
    return texture; 
}
 

/**
 * Load a texture into OpenGL from a BufferedImage
 * 
 * @param resourceName
 *            The location of the resource to load
 * @param resourceimage
 *            The BufferedImage we are converting
 * @param target
 *            The GL target to load the texture against
 * @param dstPixelFormat
 *            The pixel format of the screen
 * @param minFilter
 *            The minimising filter
 * @param magFilter
 *            The magnification filter
 * @return The loaded texture
 * @throws IOException
 *             Indicates a failure to access the resource
 */
public static Texture getTexture(String resourceName,
		BufferedImage resourceimage, int target, int dstPixelFormat,
		int minFilter, int magFilter) throws IOException {
	ImageIOImageData data = new ImageIOImageData();int srcPixelFormat = 0;

	// create the texture ID for this texture
	int textureID = InternalTextureLoader.createTextureID();
	TextureImpl texture = new TextureImpl(resourceName, target, textureID);

	// Enable texturing
	Renderer.get().glEnable(SGL.GL_TEXTURE_2D);

	// bind this texture
	Renderer.get().glBindTexture(target, textureID);

	BufferedImage bufferedImage = resourceimage;
	texture.setWidth(bufferedImage.getWidth());
	texture.setHeight(bufferedImage.getHeight());

	if (bufferedImage.getColorModel().hasAlpha()) {
		srcPixelFormat = SGL.GL_RGBA;
	} else {
		srcPixelFormat = SGL.GL_RGB;
	}

	// convert that image into a byte buffer of texture data
	ByteBuffer textureBuffer = data.imageToByteBuffer(bufferedImage, false, false, null);
	texture.setTextureHeight(data.getTexHeight());
	texture.setTextureWidth(data.getTexWidth());
	texture.setAlpha(data.getDepth() == 32);
	
	if (target == SGL.GL_TEXTURE_2D) {
		Renderer.get().glTexParameteri(target, SGL.GL_TEXTURE_MIN_FILTER, minFilter);
		Renderer.get().glTexParameteri(target, SGL.GL_TEXTURE_MAG_FILTER, magFilter);
		
        if (Renderer.get().canTextureMirrorClamp()) {
        	Renderer.get().glTexParameteri(SGL.GL_TEXTURE_2D, SGL.GL_TEXTURE_WRAP_S, SGL.GL_MIRROR_CLAMP_TO_EDGE_EXT);
        	Renderer.get().glTexParameteri(SGL.GL_TEXTURE_2D, SGL.GL_TEXTURE_WRAP_T, SGL.GL_MIRROR_CLAMP_TO_EDGE_EXT);
        } else {
        	Renderer.get().glTexParameteri(SGL.GL_TEXTURE_2D, SGL.GL_TEXTURE_WRAP_S, SGL.GL_CLAMP);
        	Renderer.get().glTexParameteri(SGL.GL_TEXTURE_2D, SGL.GL_TEXTURE_WRAP_T, SGL.GL_CLAMP);
        }
	}

	Renderer.get().glTexImage2D(target, 
                     0, 
                     dstPixelFormat, 
                     texture.getTextureWidth(), 
                     texture.getTextureHeight(), 
                     0, 
                     srcPixelFormat, 
                     SGL.GL_UNSIGNED_BYTE, 
                     textureBuffer); 

	return texture;
}