jogltexturerenderer.java

java 3d game jme 工程开发源代码

        switchCameraOut();

        // automatically generate mipmaps for our texture.
        if (tex.getMinificationFilter().usesMipMapLevels()) {
            JOGLTextureState.doTextureBind(tex.getTextureId(), 0, Texture.Type.TwoDimensional);
            gl.glGenerateMipmapEXT(GL.GL_TEXTURE_2D);
        }
    }


    private void checkFBOComplete() {
        final GL gl = GLU.getCurrentGL();

        int framebuffer = gl
                .glCheckFramebufferStatusEXT(GL.GL_FRAMEBUFFER_EXT);
        switch (framebuffer) {
            case GL.GL_FRAMEBUFFER_COMPLETE_EXT:
                break;
            case GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
                throw new RuntimeException(
                        "FrameBuffer: "
                                + fboID
                                + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT exception");
            case GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
                throw new RuntimeException(
                        "FrameBuffer: "
                                + fboID
                                + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT exception");
            case GL.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
                throw new RuntimeException(
                        "FrameBuffer: "
                                + fboID
                                + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT exception");
            case GL.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
                throw new RuntimeException(
                        "FrameBuffer: "
                                + fboID
                                + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT exception");
            case GL.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
                throw new RuntimeException(
                        "FrameBuffer: "
                                + fboID
                                + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT exception");
            case GL.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
                throw new RuntimeException(
                        "FrameBuffer: "
                                + fboID
                                + ", has caused a GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT exception");
            case GL.GL_FRAMEBUFFER_UNSUPPORTED_EXT:
                throw new RuntimeException(
                        "FrameBuffer: "
                                + fboID
                                + ", has caused a GL_FRAMEBUFFER_UNSUPPORTED_EXT exception");
            default:
                throw new RuntimeException(
                        "Unexpected reply from glCheckFramebufferStatusEXT: "
                                + framebuffer);
        }
    }

    /**
     * <code>copyToTexture</code> copies the FBO contents to the given
     * Texture. What is copied is up to the Texture object's rttSource field.
     *
     * @param tex
     *            The Texture to copy into.
     * @param width
     *            the width of the texture image
     * @param height
     *            the height of the texture image
     */
    public void copyToTexture(Texture tex, int width, int height) {
        final GL gl = GLU.getCurrentGL();

        JOGLTextureState.doTextureBind(tex.getTextureId(), 0,
		Texture.Type.TwoDimensional);

	int source = GL.GL_RGBA;
	switch (tex.getRTTSource()) {
	case RGBA:
	case RGBA8:
	    break;
	case RGB:
	case RGB8:
	    source = GL.GL_RGB;
	    break;
	case Alpha:
	case Alpha8:
	    source = GL.GL_ALPHA;
	    break;
	case Depth:
	    source = GL.GL_DEPTH_COMPONENT;
	    break;
	case Intensity:
	case Intensity8:
	    source = GL.GL_INTENSITY;
	    break;
	case Luminance:
	case Luminance8:
	    source = GL.GL_LUMINANCE;
	    break;
	case LuminanceAlpha:
	case Luminance8Alpha8:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	case Alpha4:
	    source = GL.GL_ALPHA;
	    break;
	case Alpha12:
	    source = GL.GL_ALPHA;
	    break;
	case Alpha16:
	    source = GL.GL_ALPHA;
	    break;
	case Luminance4:
	    source = GL.GL_LUMINANCE;
	    break;
	case Luminance12:
	    source = GL.GL_LUMINANCE;
	    break;
	case Luminance16:
	    source = GL.GL_LUMINANCE;
	    break;
	case Luminance4Alpha4:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	case Luminance6Alpha2:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	case Luminance12Alpha4:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	case Luminance12Alpha12:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	case Luminance16Alpha16:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	case Intensity4:
	    source = GL.GL_INTENSITY;
	    break;
	case Intensity12:
	    source = GL.GL_INTENSITY;
	    break;
	case Intensity16:
	    source = GL.GL_INTENSITY;
	    break;
	case R3_G3_B2:
	    source = GL.GL_RGB;
	    break;
	case RGB4:
	    source = GL.GL_RGB;
	    break;
	case RGB5:
	    source = GL.GL_RGB;
	    break;
	case RGB10:
	    source = GL.GL_RGB;
	    break;
	case RGB12:
	    source = GL.GL_RGB;
	    break;
	case RGB16:
	    source = GL.GL_RGB;
	    break;
	case RGBA2:
	    source = GL.GL_RGBA;
	    break;
	case RGBA4:
	    source = GL.GL_RGBA;
	    break;
	case RGB5_A1:
	    source = GL.GL_RGBA;
	    break;
	case RGB10_A2:
	    source = GL.GL_RGBA;
	    break;
	case RGBA12:
	    source = GL.GL_RGBA;
	    break;
	case RGBA16:
	    source = GL.GL_RGBA;
	    break;
	case RGBA32F:
	    source = GL.GL_RGBA;
	    break;
	case RGB32F:
	    source = GL.GL_RGB;
	    break;
	case Alpha32F:
	    source = GL.GL_ALPHA;
	    break;
	case Intensity32F:
	    source = GL.GL_INTENSITY;
	    break;
	case Luminance32F:
	    source = GL.GL_LUMINANCE;
	    break;
	case LuminanceAlpha32F:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	case RGBA16F:
	    source = GL.GL_RGBA;
	    break;
	case RGB16F:
	    source = GL.GL_RGB;
	    break;
	case Alpha16F:
	    source = GL.GL_ALPHA;
	    break;
	case Intensity16F:
	    source = GL.GL_INTENSITY;
	    break;
	case Luminance16F:
	    source = GL.GL_LUMINANCE;
	    break;
	case LuminanceAlpha16F:
	    source = GL.GL_LUMINANCE_ALPHA;
	    break;
	}
	gl.glCopyTexImage2D(GL.GL_TEXTURE_2D, 0, source, 0, 0, width,
			height, 0);
    }

    private Camera oldCamera;
    private int oldWidth, oldHeight;
    private void switchCameraIn(boolean doClear) {
        final GL gl = GLU.getCurrentGL();

        // grab non-rtt settings
        oldCamera = parentRenderer.getCamera();
        oldWidth = parentRenderer.getWidth();
        oldHeight = parentRenderer.getHeight();
        parentRenderer.setCamera(getCamera());

        // swap to rtt settings
        parentRenderer.getQueue().swapBuckets();
        parentRenderer.reinit(width, height);

        // clear the scene
        if (doClear) {
            gl.glDisable(GL.GL_SCISSOR_TEST);
            parentRenderer.clearBuffers();
        }

        getCamera().update();
        getCamera().apply();
    }

    private void switchCameraOut() {
        parentRenderer.setCamera(oldCamera);
        parentRenderer.reinit(oldWidth, oldHeight);

        // back to the non rtt settings
        parentRenderer.getQueue().swapBuckets();
        oldCamera.update();
        oldCamera.apply();
    }

    private void doDraw(Spatial spat) {
        // Override parent's last frustum test to avoid accidental incorrect
        // cull
        if (spat.getParent() != null)
            spat.getParent().setLastFrustumIntersection(Camera.FrustumIntersect.Intersects);

        // do rtt scene render
        spat.onDraw(parentRenderer);
        parentRenderer.renderQueue();
    }

    private void doDraw(ArrayList<? extends Spatial> toDraw) {
        for (int x = 0, max = toDraw.size(); x < max; x++) {
            Spatial spat = toDraw.get(x);
            doDraw(spat);
        }
    }

    private void activate() {
        final GL gl = GLU.getCurrentGL();

        if (!isSupported) {
            return;
        }
        if (active == 0) {
            gl.glClearColor(backgroundColor.r, backgroundColor.g,
                    backgroundColor.b, backgroundColor.a);
            gl.glBindFramebufferEXT(
                    GL.GL_FRAMEBUFFER_EXT, fboID);
        }
        active++;
    }

    private void deactivate() {
        final GL gl = GLU.getCurrentGL();

        if (!isSupported) {
            return;
        }
        if (active == 1) {
            gl.glClearColor(parentRenderer.getBackgroundColor().r,
                    parentRenderer.getBackgroundColor().g, parentRenderer
                            .getBackgroundColor().b, parentRenderer
                            .getBackgroundColor().a);
            gl.glBindFramebufferEXT(
                    GL.GL_FRAMEBUFFER_EXT, 0);
        }
        active--;
    }

    private void initCamera() {
        if (!isSupported) {
            return;
        }
        logger.info("Init RTT camera");
        camera = new JOGLCamera(width, height, false);
        camera.setFrustum(1.0f, 1000.0f, -0.50f, 0.50f, 0.50f, -0.50f);
        Vector3f loc = new Vector3f(0.0f, 0.0f, 0.0f);
        Vector3f left = new Vector3f(-1.0f, 0.0f, 0.0f);
        Vector3f up = new Vector3f(0.0f, 1.0f, 0.0f);
        Vector3f dir = new Vector3f(0.0f, 0f, -1.0f);
        camera.setFrame(loc, left, up, dir);
        camera.setDataOnly(false);
    }

    public void cleanup() {
        final GL gl = GLU.getCurrentGL();

        if (!isSupported) {
            return;
        }

        if (fboID > 0) {
            IntBuffer id = BufferUtils.createIntBuffer(1);
            id.put(fboID);
            id.rewind();
            gl.glDeleteFramebuffersEXT(id.limit(),id); // TODO Check <size>
        }
    }

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }

    public void setMultipleTargets(boolean multi) {
        // ignore. Does not matter to FBO.
    }
}