Examples with RenderQueue com.jme3.renderer.queue.RenderQueue used on opensource projects

Example 1 with RenderQueue

use of com.jme3.renderer.queue.RenderQueue in project jmonkeyengine by jMonkeyEngine.

the class PssmShadowRenderer method postQueue.

@SuppressWarnings("fallthrough")
public void postQueue(RenderQueue rq) {
    for (Spatial scene : viewPort.getScenes()) {
        ShadowUtil.getGeometriesInCamFrustum(scene, viewPort.getCamera(), ShadowMode.Receive, lightReceivers);
    }
    Camera viewCam = viewPort.getCamera();
    float zFar = zFarOverride;
    if (zFar == 0) {
        zFar = viewCam.getFrustumFar();
    }
    //We prevent computing the frustum points and splits with zeroed or negative near clip value
    float frustumNear = Math.max(viewCam.getFrustumNear(), 0.001f);
    ShadowUtil.updateFrustumPoints(viewCam, frustumNear, zFar, 1.0f, points);
    //shadowCam.setDirection(direction);
    shadowCam.getRotation().lookAt(direction, shadowCam.getUp());
    shadowCam.update();
    shadowCam.updateViewProjection();
    PssmShadowUtil.updateFrustumSplits(splitsArray, frustumNear, zFar, lambda);
    switch(splitsArray.length) {
        case 5:
            splits.a = splitsArray[4];
        case 4:
            splits.b = splitsArray[3];
        case 3:
            splits.g = splitsArray[2];
        case 2:
        case 1:
            splits.r = splitsArray[1];
            break;
    }
    Renderer r = renderManager.getRenderer();
    renderManager.setForcedMaterial(preshadowMat);
    renderManager.setForcedTechnique("PreShadow");
    for (int i = 0; i < nbSplits; i++) {
        // update frustum points based on current camera and split
        ShadowUtil.updateFrustumPoints(viewCam, splitsArray[i], splitsArray[i + 1], 1.0f, points);
        //Updating shadow cam with curent split frustra
        ShadowUtil.updateShadowCamera(viewPort, lightReceivers, shadowCam, points, splitOccluders, shadowMapSize);
        //saving light view projection matrix for this split            
        lightViewProjectionsMatrices[i].set(shadowCam.getViewProjectionMatrix());
        renderManager.setCamera(shadowCam, false);
        if (debugfrustums) {
            //                    frustrumFromBound(b.casterBB,ColorRGBA.Blue );
            //                    frustrumFromBound(b.receiverBB,ColorRGBA.Green );
            //                    frustrumFromBound(b.splitBB,ColorRGBA.Yellow );
            ((Node) viewPort.getScenes().get(0)).attachChild(createFrustum(points, i));
            ShadowUtil.updateFrustumPoints2(shadowCam, points);
            ((Node) viewPort.getScenes().get(0)).attachChild(createFrustum(points, i));
        }
        r.setFrameBuffer(shadowFB[i]);
        r.clearBuffers(true, true, true);
        // render shadow casters to shadow map
        viewPort.getQueue().renderShadowQueue(splitOccluders, renderManager, shadowCam, true);
    }
    debugfrustums = false;
    //restore setting for future rendering
    r.setFrameBuffer(viewPort.getOutputFrameBuffer());
    renderManager.setForcedMaterial(null);
    renderManager.setForcedTechnique(null);
    renderManager.setCamera(viewCam, false);
}

Example 2 with RenderQueue

use of com.jme3.renderer.queue.RenderQueue in project jmonkeyengine by jMonkeyEngine.

the class AbstractShadowRenderer method postQueue.

@SuppressWarnings("fallthrough")
public void postQueue(RenderQueue rq) {
    lightReceivers.clear();
    skipPostPass = false;
    if (!checkCulling(viewPort.getCamera())) {
        skipPostPass = true;
        return;
    }
    updateShadowCams(viewPort.getCamera());
    Renderer r = renderManager.getRenderer();
    renderManager.setForcedMaterial(preshadowMat);
    renderManager.setForcedTechnique("PreShadow");
    for (int shadowMapIndex = 0; shadowMapIndex < nbShadowMaps; shadowMapIndex++) {
        if (debugfrustums) {
            doDisplayFrustumDebug(shadowMapIndex);
        }
        renderShadowMap(shadowMapIndex);
    }
    debugfrustums = false;
    //restore setting for future rendering
    r.setFrameBuffer(viewPort.getOutputFrameBuffer());
    renderManager.setForcedMaterial(null);
    renderManager.setForcedTechnique(null);
    renderManager.setCamera(viewPort.getCamera(), false);
}

Example 3 with RenderQueue

use of com.jme3.renderer.queue.RenderQueue in project jmonkeyengine by jMonkeyEngine.

the class RenderManager method renderViewPortQueues.

/**
     * Render the given viewport queues.
     * <p>
     * Changes the {@link Renderer#setDepthRange(float, float) depth range}
     * appropriately as expected by each queue and then calls 
     * {@link RenderQueue#renderQueue(com.jme3.renderer.queue.RenderQueue.Bucket, com.jme3.renderer.RenderManager, com.jme3.renderer.Camera, boolean) }
     * on the queue. Makes sure to restore the depth range to [0, 1] 
     * at the end of the call.
     * Note that the {@link Bucket#Translucent translucent bucket} is NOT
     * rendered by this method. Instead the user should call 
     * {@link #renderTranslucentQueue(com.jme3.renderer.ViewPort) }
     * after this call.
     * 
     * @param vp the viewport of which queue should be rendered
     * @param flush If true, the queues will be cleared after
     * rendering.
     * 
     * @see RenderQueue
     * @see #renderTranslucentQueue(com.jme3.renderer.ViewPort) 
     */
public void renderViewPortQueues(ViewPort vp, boolean flush) {
    RenderQueue rq = vp.getQueue();
    Camera cam = vp.getCamera();
    boolean depthRangeChanged = false;
    // opaque objects are sorted front-to-back, reducing overdraw
    if (prof != null)
        prof.vpStep(VpStep.RenderBucket, vp, Bucket.Opaque);
    rq.renderQueue(Bucket.Opaque, this, cam, flush);
    // render the sky, with depth range set to the farthest
    if (!rq.isQueueEmpty(Bucket.Sky)) {
        if (prof != null)
            prof.vpStep(VpStep.RenderBucket, vp, Bucket.Sky);
        renderer.setDepthRange(1, 1);
        rq.renderQueue(Bucket.Sky, this, cam, flush);
        depthRangeChanged = true;
    }
    // back-to-front.
    if (!rq.isQueueEmpty(Bucket.Transparent)) {
        if (prof != null)
            prof.vpStep(VpStep.RenderBucket, vp, Bucket.Transparent);
        if (depthRangeChanged) {
            renderer.setDepthRange(0, 1);
            depthRangeChanged = false;
        }
        rq.renderQueue(Bucket.Transparent, this, cam, flush);
    }
    if (!rq.isQueueEmpty(Bucket.Gui)) {
        if (prof != null)
            prof.vpStep(VpStep.RenderBucket, vp, Bucket.Gui);
        renderer.setDepthRange(0, 0);
        setCamera(cam, true);
        rq.renderQueue(Bucket.Gui, this, cam, flush);
        setCamera(cam, false);
        depthRangeChanged = true;
    }
    // restore range to default
    if (depthRangeChanged) {
        renderer.setDepthRange(0, 1);
    }
}

Example 4 with RenderQueue

use of com.jme3.renderer.queue.RenderQueue in project jmonkeyengine by jMonkeyEngine.

the class RenderManager method renderViewPort.

/**
     * Renders the {@link ViewPort}.
     * <p>
     * If the ViewPort is {@link ViewPort#isEnabled() disabled}, this method
     * returns immediately. Otherwise, the ViewPort is rendered by 
     * the following process:<br>
     * <ul>
     * <li>All {@link SceneProcessor scene processors} that are attached
     * to the ViewPort are {@link SceneProcessor#initialize(com.jme3.renderer.RenderManager, com.jme3.renderer.ViewPort) initialized}.
     * </li>
     * <li>The SceneProcessors' {@link SceneProcessor#preFrame(float) } method 
     * is called.</li>
     * <li>The ViewPort's {@link ViewPort#getOutputFrameBuffer() output framebuffer}
     * is set on the Renderer</li>
     * <li>The camera is set on the renderer, including its view port parameters.
     * (see {@link #setCamera(com.jme3.renderer.Camera, boolean) })</li>
     * <li>Any buffers that the ViewPort requests to be cleared are cleared
     * and the {@link ViewPort#getBackgroundColor() background color} is set</li>
     * <li>Every scene that is attached to the ViewPort is flattened into 
     * the ViewPort's render queue 
     * (see {@link #renderViewPortQueues(com.jme3.renderer.ViewPort, boolean) })
     * </li>
     * <li>The SceneProcessors' {@link SceneProcessor#postQueue(com.jme3.renderer.queue.RenderQueue) }
     * method is called.</li>
     * <li>The render queue is sorted and then flushed, sending
     * rendering commands to the underlying Renderer implementation. 
     * (see {@link #flushQueue(com.jme3.renderer.ViewPort) })</li>
     * <li>The SceneProcessors' {@link SceneProcessor#postFrame(com.jme3.texture.FrameBuffer) }
     * method is called.</li>
     * <li>The translucent queue of the ViewPort is sorted and then flushed
     * (see {@link #renderTranslucentQueue(com.jme3.renderer.ViewPort) })</li>
     * <li>If any objects remained in the render queue, they are removed
     * from the queue. This is generally objects added to the 
     * {@link RenderQueue#renderShadowQueue(com.jme3.renderer.queue.RenderQueue.ShadowMode, com.jme3.renderer.RenderManager, com.jme3.renderer.Camera, boolean) 
     * shadow queue}
     * which were not rendered because of a missing shadow renderer.</li>
     * </ul>
     * 
     * @param vp View port to render
     * @param tpf Time per frame value
     */
public void renderViewPort(ViewPort vp, float tpf) {
    if (!vp.isEnabled()) {
        return;
    }
    if (prof != null)
        prof.vpStep(VpStep.BeginRender, vp, null);
    SafeArrayList<SceneProcessor> processors = vp.getProcessors();
    if (processors.isEmpty()) {
        processors = null;
    }
    if (processors != null) {
        if (prof != null)
            prof.vpStep(VpStep.PreFrame, vp, null);
        for (SceneProcessor proc : processors.getArray()) {
            if (!proc.isInitialized()) {
                proc.initialize(this, vp);
            }
            proc.setProfiler(this.prof);
            if (prof != null)
                prof.spStep(SpStep.ProcPreFrame, proc.getClass().getSimpleName());
            proc.preFrame(tpf);
        }
    }
    renderer.setFrameBuffer(vp.getOutputFrameBuffer());
    setCamera(vp.getCamera(), false);
    if (vp.isClearDepth() || vp.isClearColor() || vp.isClearStencil()) {
        if (vp.isClearColor()) {
            renderer.setBackgroundColor(vp.getBackgroundColor());
        }
        renderer.clearBuffers(vp.isClearColor(), vp.isClearDepth(), vp.isClearStencil());
    }
    if (prof != null)
        prof.vpStep(VpStep.RenderScene, vp, null);
    List<Spatial> scenes = vp.getScenes();
    for (int i = scenes.size() - 1; i >= 0; i--) {
        renderScene(scenes.get(i), vp);
    }
    if (processors != null) {
        if (prof != null)
            prof.vpStep(VpStep.PostQueue, vp, null);
        for (SceneProcessor proc : processors.getArray()) {
            if (prof != null)
                prof.spStep(SpStep.ProcPostQueue, proc.getClass().getSimpleName());
            proc.postQueue(vp.getQueue());
        }
    }
    if (prof != null)
        prof.vpStep(VpStep.FlushQueue, vp, null);
    flushQueue(vp);
    if (processors != null) {
        if (prof != null)
            prof.vpStep(VpStep.PostFrame, vp, null);
        for (SceneProcessor proc : processors.getArray()) {
            if (prof != null)
                prof.spStep(SpStep.ProcPostFrame, proc.getClass().getSimpleName());
            proc.postFrame(vp.getOutputFrameBuffer());
        }
        if (prof != null)
            prof.vpStep(VpStep.ProcEndRender, vp, null);
    }
    //renders the translucent objects queue after processors have been rendered
    renderTranslucentQueue(vp);
    // clear any remaining spatials that were not rendered.
    clearQueue(vp);
    if (prof != null)
        prof.vpStep(VpStep.EndRender, vp, null);
}

Example 5 with RenderQueue

use of com.jme3.renderer.queue.RenderQueue in project jmonkeyengine by jMonkeyEngine.

the class SSAOFilter method postQueue.

@Override
protected void postQueue(RenderQueue queue) {
    if (!approximateNormals) {
        Renderer r = renderManager.getRenderer();
        r.setFrameBuffer(normalPass.getRenderFrameBuffer());
        renderManager.getRenderer().clearBuffers(true, true, true);
        renderManager.setForcedTechnique("PreNormalPass");
        renderManager.renderViewPortQueues(viewPort, false);
        renderManager.setForcedTechnique(null);
        renderManager.getRenderer().setFrameBuffer(viewPort.getOutputFrameBuffer());
    }
}