bloomrenderpass.java

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

		fullScreenQuad.setTextureCombineMode(Spatial.TextureCombineMode.Replace);
		fullScreenQuad.setLightCombineMode(Spatial.LightCombineMode.Off);
        
		TextureState ts = display.getRenderer().createTextureState();
		ts.setEnabled(true);
        fullScreenQuad.setRenderState(ts);

		BlendState as = display.getRenderer().createBlendState();
		as.setBlendEnabled(true);
		as.setSourceFunction(BlendState.SourceFunction.One);
		as.setDestinationFunction(BlendState.DestinationFunction.One);
		as.setEnabled(true);
        fullScreenQuad.setRenderState(as);

        fullScreenQuad.updateRenderState();
        fullScreenQuad.updateGeometricState(0.0f, true);
	}

    /**
     * Helper class to get all spatials rendered in one TextureRenderer.render() call.
     */
    private class SpatialsRenderNode extends Node {
        private static final long serialVersionUID = 7367501683137581101L;
        public void draw( Renderer r ) {
            Spatial child;
            for (int i = 0, cSize = spatials.size(); i < cSize; i++) {
                child = spatials.get(i);
                if (child != null)
                    child.onDraw(r);
            }
        }

        public void onDraw( Renderer r ) {
            draw( r );
        }
    }

    private final SpatialsRenderNode spatialsRenderNode = new SpatialsRenderNode();

    @Override
    protected void doUpdate(float tpf) {
        super.doUpdate(tpf);
        sinceLast += tpf;
    }
    
    public void doRender(Renderer r) {
        if (!isSupported() || !useCurrentScene && spatials.size() == 0 ) {
            return;
        }

        BlendState as = (BlendState) fullScreenQuad.states[RenderState.StateType.Blend.ordinal()];

        if (sinceLast > throttle) {
            sinceLast = 0;

            as.setEnabled(false);
            TextureState ts = (TextureState) fullScreenQuad.states[RenderState.StateType.Texture.ordinal()];
            
            // see if we should use the current scene to bloom, or only things added to the pass.
            if (useCurrentScene) {
                // grab backbuffer to texture
                tRenderer.copyToTexture(screenTexture, 
                        DisplaySystem.getDisplaySystem().getWidth(), 
                        DisplaySystem.getDisplaySystem().getHeight());
                ts.setTexture(screenTexture, 0);
            } else {
        		//Render scene to texture
                tRenderer.render( spatialsRenderNode , mainTexture);
                ts.setTexture(mainTexture, 0);
            }

    		//Extract intensity
    		extractionShader.setUniform("exposurePow", getExposurePow());
    		extractionShader.setUniform("exposureCutoff", getExposureCutoff());
    
            fullScreenQuad.states[RenderState.StateType.GLSLShaderObjects.ordinal()] = extractionShader;
            tRenderer.render(fullScreenQuad, secondTexture);
        
            if (!useSeparateConvolution) {
                blurShader.setUniform("sampleDist", getBlurSize());
                blurShader.setUniform("blurIntensityMultiplier",  getBlurIntensityMultiplier());

                ts.setTexture(secondTexture, 0);
                fullScreenQuad.states[RenderState.StateType.GLSLShaderObjects.ordinal()] = blurShader;
                tRenderer.render(fullScreenQuad, mainTexture);

                //Extra blur passes
                for(int i = 1; i < getNrBlurPasses(); i++) {
                    blurShader.setUniform("sampleDist", getBlurSize() - (float)i*getBlurSize()/getNrBlurPasses());
                    if (i%2 == 1) {
                        ts.setTexture(mainTexture, 0);
                        tRenderer.render(fullScreenQuad, secondTexture);
                    } else {
                        ts.setTexture(secondTexture, 0);
                        tRenderer.render(fullScreenQuad, mainTexture);
                    }
                }
                if (getNrBlurPasses()%2 == 1) {
                    ts.setTexture(mainTexture, 0);
                } else {
                    ts.setTexture(secondTexture, 0);
                    tRenderer.render(fullScreenQuad, mainTexture, false);
                }
            } else {
                blurShaderVertical.setUniform("blurIntensityMultiplier",  getBlurIntensityMultiplier());

                for(int i = 0; i < getNrBlurPasses(); i++) {
                    blurShaderHorizontal.setUniform("sampleDist", getBlurSize() - (float)i*getBlurSize()/getNrBlurPasses());
                    blurShaderVertical.setUniform("sampleDist", getBlurSize() - (float)i*getBlurSize()/getNrBlurPasses());

                    ts.setTexture(secondTexture, 0);
                    fullScreenQuad.states[RenderState.StateType.GLSLShaderObjects.ordinal()] = blurShaderHorizontal;
                    ts.setTexture(mainTexture, 0);
                    fullScreenQuad.states[RenderState.StateType.GLSLShaderObjects.ordinal()] = blurShaderVertical;
                    tRenderer.render(fullScreenQuad, secondTexture);
                }
                ts.setTexture(secondTexture, 0);
            }
        }

		//Final blend
		as.setEnabled(true);
        
        fullScreenQuad.states[RenderState.StateType.GLSLShaderObjects.ordinal()] = finalShader;
        r.draw(fullScreenQuad);
	}

	/**
     * @return The throttle amount - or in other words, how much time in
     *         seconds must pass before the bloom effect is updated.
     */
    public float getThrottle() {
        return throttle;
    }

    /**
     * @param throttle
     *            The throttle amount - or in other words, how much time in
     *            seconds must pass before the bloom effect is updated.
     */
    public void setThrottle(float throttle) {
        this.throttle = throttle;
    }

    public float getBlurSize() {
		return blurSize;
	}

	public void setBlurSize(float blurSize) {
		this.blurSize = blurSize;
	}

	public float getExposurePow() {
		return exposurePow;
	}

	public void setExposurePow(float exposurePow) {
		this.exposurePow = exposurePow;
	}

	public float getExposureCutoff() {
		return exposureCutoff;
	}

	public void setExposureCutoff(float exposureCutoff) {
		this.exposureCutoff = exposureCutoff;
	}

	public float getBlurIntensityMultiplier() {
		return blurIntensityMultiplier;
	}

	public void setBlurIntensityMultiplier(float blurIntensityMultiplier) {
		this.blurIntensityMultiplier = blurIntensityMultiplier;
	}

	public int getNrBlurPasses() {
		return nrBlurPasses;
	}

	public void setNrBlurPasses(int nrBlurPasses) {
		this.nrBlurPasses = nrBlurPasses;
	}

    public boolean useCurrentScene() {
        return useCurrentScene;
    }

    public void setUseCurrentScene(boolean useCurrentScene) {
        this.useCurrentScene = useCurrentScene;
    }

    public void setUseSeparateConvolution(boolean useSeparateConvolution) {
        this.useSeparateConvolution = useSeparateConvolution;
    }

    public boolean isUseSeparateConvolution() {
        return useSeparateConvolution;
    }
}