Package com.jme3.renderer

Class RenderManager

java.lang.Object
com.jme3.renderer.RenderManager
public class RenderManager extends Object
A high-level rendering interface that is above the Renderer implementation. RenderManager takes care of rendering the scene graphs attached to each viewport and handling SceneProcessors.
See Also:

  • Constructor Details

    • RenderManager

      public RenderManager(Renderer renderer)
      Creates a high-level rendering interface over the low-level rendering interface.
      Parameters:
      renderer - (alias created)

  • Method Details

    • getPreView

      public ViewPort getPreView(String viewName)
      Returns the pre ViewPort with the given name.
      Parameters:
      viewName - The name of the pre ViewPort to look up
      Returns:
      The ViewPort, or null if not found.
      See Also:

    • removePreView

      public boolean removePreView(String viewName)
      Removes the pre ViewPort with the specified name.
      Parameters:
      viewName - The name of the pre ViewPort to remove
      Returns:
      True if the ViewPort was removed successfully.
      See Also:

    • removePreView

      public boolean removePreView(ViewPort view)
      Removes the specified pre ViewPort.
      Parameters:
      view - The pre ViewPort to remove
      Returns:
      True if the ViewPort was removed successfully.
      See Also:

    • getMainView

      public ViewPort getMainView(String viewName)
      Returns the main ViewPort with the given name.
      Parameters:
      viewName - The name of the main ViewPort to look up
      Returns:
      The ViewPort, or null if not found.
      See Also:

    • removeMainView

      public boolean removeMainView(String viewName)
      Removes the main ViewPort with the specified name.
      Parameters:
      viewName - The main ViewPort name to remove
      Returns:
      True if the ViewPort was removed successfully.
      See Also:

    • removeMainView

      public boolean removeMainView(ViewPort view)
      Removes the specified main ViewPort.
      Parameters:
      view - The main ViewPort to remove
      Returns:
      True if the ViewPort was removed successfully.
      See Also:

    • getPostView

      public ViewPort getPostView(String viewName)
      Returns the post ViewPort with the given name.
      Parameters:
      viewName - The name of the post ViewPort to look up
      Returns:
      The ViewPort, or null if not found.
      See Also:

    • removePostView

      public boolean removePostView(String viewName)
      Removes the post ViewPort with the specified name.
      Parameters:
      viewName - The post ViewPort name to remove
      Returns:
      True if the ViewPort was removed successfully.
      See Also:

    • removePostView

      public boolean removePostView(ViewPort view)
      Removes the specified post ViewPort.
      Parameters:
      view - The post ViewPort to remove
      Returns:
      True if the ViewPort was removed successfully.
      See Also:

    • getPreViews

      public List<ViewPort> getPreViews()
      Returns a read-only list of all pre ViewPorts.
      Returns:
      a read-only list of all pre ViewPorts
      See Also:

    • getMainViews

      public List<ViewPort> getMainViews()
      Returns a read-only list of all main ViewPorts.
      Returns:
      a read-only list of all main ViewPorts
      See Also:

    • getPostViews

      public List<ViewPort> getPostViews()
      Returns a read-only list of all post ViewPorts.
      Returns:
      a read-only list of all post ViewPorts
      See Also:

    • createPreView

      public ViewPort createPreView(String viewName, Camera cam)
      Creates a new pre ViewPort, to display the given camera's content.

      The view will be processed before the main and post viewports.

      Parameters:
      viewName - the desired viewport name
      cam - the Camera to use for rendering (alias created)
      Returns:
      a new instance

    • createMainView

      public ViewPort createMainView(String viewName, Camera cam)
      Creates a new main ViewPort, to display the given camera's content.

      The view will be processed before the post viewports but after the pre viewports.

      Parameters:
      viewName - the desired viewport name
      cam - the Camera to use for rendering (alias created)
      Returns:
      a new instance

    • createPostView

      public ViewPort createPostView(String viewName, Camera cam)
      Creates a new post ViewPort, to display the given camera's content.

      The view will be processed after the pre and main viewports.

      Parameters:
      viewName - the desired viewport name
      cam - the Camera to use for rendering (alias created)
      Returns:
      a new instance

    • notifyReshape

      public void notifyReshape(int w, int h)
      Internal use only. Updates the resolution of all on-screen cameras to match the given width and height.
      Parameters:
      w - the new width (in pixels)
      h - the new height (in pixels)

    • notifyRescale

      public void notifyRescale(float x, float y)
      Internal use only. Updates the scale of all on-screen ViewPorts
      Parameters:
      x - the new horizontal scale
      y - the new vertical scale

    • setForcedMaterial

      public void setForcedMaterial(Material mat)
      Sets the material to use to render all future objects. This overrides the material set on the geometry and renders with the provided material instead. Use null to clear the material and return renderer to normal functionality.
      Parameters:
      mat - The forced material to set, or null to return to normal

    • getForcedRenderState

      public RenderState getForcedRenderState()
      Returns the forced render state previously set with setForcedRenderState(com.jme3.material.RenderState).
      Returns:
      the forced render state

    • setForcedRenderState

      public void setForcedRenderState(RenderState forcedRenderState)
      Sets the render state to use for all future objects. This overrides the render state set on the material and instead forces this render state to be applied for all future materials rendered. Set to null to return to normal functionality.
      Parameters:
      forcedRenderState - The forced render state to set, or null to return to normal

    • setTimer

      public void setTimer(Timer timer)
      Sets the timer that should be used to query the time based UniformBindings for material world parameters.
      Parameters:
      timer - The timer to query time world parameters

    • setAppProfiler

      public void setAppProfiler(AppProfiler prof)
      Sets an AppProfiler hook that will be called back for specific steps within a single update frame. Value defaults to null.
      Parameters:
      prof - the AppProfiler to use (alias created, default=null)

    • getForcedTechnique

      public String getForcedTechnique()
      Returns the forced technique name set.
      Returns:
      the forced technique name set.
      See Also:

    • setForcedTechnique

      public void setForcedTechnique(String forcedTechnique)
      Sets the forced technique to use when rendering geometries.

      If the specified technique name is available on the geometry's material, then it is used, otherwise, the forced material is used. If a forced material is not set and the forced technique name cannot be found on the material, the geometry will not be rendered.

      Parameters:
      forcedTechnique - The forced technique name to use, set to null to return to normal functionality.
      See Also:

    • addForcedMatParam

      public void addForcedMatParam(MatParamOverride override)
      Adds a forced material parameter to use when rendering geometries.

      The provided parameter takes precedence over parameters set on the material or any overrides that exist in the scene graph that have the same name.

      Parameters:
      override - The override to add
      See Also:

    • removeForcedMatParam

      public void removeForcedMatParam(MatParamOverride override)
      Removes a forced material parameter previously added.
      Parameters:
      override - The override to remove.
      See Also:

    • getForcedMatParams

      public SafeArrayList<MatParamOverride> getForcedMatParams()
      Gets the forced material parameters applied to rendered geometries.

      Forced parameters can be added via addForcedMatParam(com.jme3.material.MatParamOverride) or removed via removeForcedMatParam(com.jme3.material.MatParamOverride).

      Returns:
      The forced material parameters.

    • setAlphaToCoverage

      public void setAlphaToCoverage(boolean value)
      Enables or disables alpha-to-coverage.

      When alpha to coverage is enabled and the renderer implementation supports it, then alpha blending will be replaced with alpha dissolve if multi-sampling is also set on the renderer. This feature allows avoiding of alpha blending artifacts due to lack of triangle-level back-to-front sorting.

      Parameters:
      value - True to enable alpha-to-coverage, false otherwise.

    • isHandleTranslucentBucket

      public boolean isHandleTranslucentBucket()
      True if the translucent bucket should automatically be rendered by the RenderManager.
      Returns:
      true if the translucent bucket is rendered
      See Also:

    • setHandleTranslucentBucket

      public void setHandleTranslucentBucket(boolean handleTranslucentBucket)
      Enables or disables rendering of the translucent bucket by the RenderManager. The default is enabled.
      Parameters:
      handleTranslucentBucket - true to render the translucent bucket

    • setWorldMatrix

      public void setWorldMatrix(Matrix4f mat)
      Internal use only. Sets the world matrix to use for future rendering. This has no effect unless objects are rendered manually using Material.render(com.jme3.scene.Geometry, com.jme3.renderer.RenderManager). Using renderGeometry(com.jme3.scene.Geometry) will override this value.
      Parameters:
      mat - The world matrix to set

    • updateUniformBindings

      public void updateUniformBindings(Shader shader)
      Internal use only. Updates the given list of uniforms with uniform bindings based on the current world state.
      Parameters:
      shader - (not null)

    • renderGeometry

      public void renderGeometry(Geometry geom)
      Renders the given geometry.

      First the proper world matrix is set, if the geometry's ignore transform feature is enabled, the identity world matrix is used, otherwise, the geometry's world transform matrix is used.

      Once the world matrix is applied, the proper material is chosen for rendering. If a forced material is set on this RenderManager, then it is used for rendering the geometry, otherwise, the geometry's material is used.

      If a forced technique is set on this RenderManager, then it is selected automatically on the geometry's material and is used for rendering. Otherwise, one of the default techniques is used.

      If a forced render state is set on this RenderManager, then it is used for rendering the material, and the material's own render state is ignored. Otherwise, the material's render state is used as intended.

      Parameters:
      geom - The geometry to render
      See Also:

    • renderGeometryList

      public void renderGeometryList(GeometryList gl)
      Renders the given GeometryList.

      For every geometry in the list, the renderGeometry(com.jme3.scene.Geometry) method is called.

      Parameters:
      gl - The geometry list to render.
      See Also:

    • preloadScene

      public void preloadScene(Spatial scene)
      Preloads a scene for rendering.

      After invocation of this method, the underlying renderer would have uploaded any textures, shaders and meshes used by the given scene to the video driver. Using this method is useful when wishing to avoid the initial pause when rendering a scene for the first time. Note that it is not guaranteed that the underlying renderer will actually choose to upload the data to the GPU so some pause is still to be expected.

      Parameters:
      scene - The scene to preload

    • renderScene

      public void renderScene(Spatial scene, ViewPort vp)
      Flattens the given scene graph into the ViewPort's RenderQueue, checking for culling as the call goes down the graph recursively.

      First, the scene is checked for culling based on the Spatials cull hint, if the camera frustum contains the scene, then this method is recursively called on its children.

      When the scene's leaves or geometries are reached, they are each enqueued into the ViewPort's render queue.

      In addition to enqueuing the visible geometries, this method also scenes which cast or receive shadows, by putting them into the RenderQueue's shadow queue. Each Spatial which has its shadow mode set to not off, will be put into the appropriate shadow queue, note that this process does not check for frustum culling on any shadow casters, as they don't have to be in the eye camera frustum to cast shadows on objects that are inside it.

      Parameters:
      scene - The scene to flatten into the queue
      vp - The ViewPort provides the camera used for culling and the queue used to contain the flattened scene graph.

    • getCurrentCamera

      public Camera getCurrentCamera()
      Returns the camera currently used for rendering.

      The camera can be set with setCamera(com.jme3.renderer.Camera, boolean).

      Returns:
      the camera currently used for rendering.

    • getRenderer

      public Renderer getRenderer()
      The renderer implementation used for rendering operations.
      Returns:
      The renderer implementation
      See Also:

    • flushQueue

      public void flushQueue(ViewPort vp)
      Flushes the ViewPort's render queue by rendering each of its visible buckets. By default, the queues will be cleared automatically after rendering, so there's no need to clear them manually.
      Parameters:
      vp - The ViewPort of which the queue will be flushed
      See Also:

    • clearQueue

      public void clearQueue(ViewPort vp)
      Clears the queue of the given ViewPort. Simply calls RenderQueue.clear() on the ViewPort's render queue.
      Parameters:
      vp - The ViewPort of which the queue will be cleared.
      See Also:

    • setLightFilter

      public void setLightFilter(LightFilter lightFilter)
      Sets the light filter to use when rendering lit Geometries.
      Parameters:
      lightFilter - The light filter. Set it to null if you want all lights to be rendered.
      See Also:

    • getLightFilter

      public LightFilter getLightFilter()
      Returns the current LightFilter.
      Returns:
      the current light filter

    • setPreferredLightMode

      public void setPreferredLightMode(TechniqueDef.LightMode preferredLightMode)
      Defines what light mode will be selected when a technique offers several light modes.
      Parameters:
      preferredLightMode - The light mode to use.

    • getPreferredLightMode

      public TechniqueDef.LightMode getPreferredLightMode()
      Returns the preferred light mode.
      Returns:
      the light mode.

    • getSinglePassLightBatchSize

      public int getSinglePassLightBatchSize()
      Returns the number of lights used for each pass when the light mode is single pass.
      Returns:
      the number of lights.

    • setSinglePassLightBatchSize

      public void setSinglePassLightBatchSize(int singlePassLightBatchSize)
      Sets the number of lights to use for each pass when the light mode is single pass.
      Parameters:
      singlePassLightBatchSize - the number of lights.

    • renderViewPortQueues

      public void renderViewPortQueues(ViewPort vp, boolean flush)
      Renders the given viewport queues.

      Changes the depth range appropriately as expected by each queue and then calls 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 translucent bucket is NOT rendered by this method. Instead, the user should call renderTranslucentQueue(com.jme3.renderer.ViewPort) after this call.

      Parameters:
      vp - the viewport of which queue should be rendered
      flush - If true, the queues will be cleared after rendering.
      See Also:

    • renderTranslucentQueue

      public void renderTranslucentQueue(ViewPort vp)
      Renders the translucent queue on the viewPort.

      This call does nothing unless setHandleTranslucentBucket(boolean) is set to true. This method clears the translucent queue after rendering it.

      Parameters:
      vp - The viewport of which the translucent queue should be rendered.
      See Also:

    • setCamera

      public void setCamera(Camera cam, boolean ortho)
      Sets the camera to use for rendering.

      First, the camera's view port parameters are applied. Then, the camera's view and projection matrices are set on the renderer. If ortho is true, then instead of using the camera's view and projection matrices, an ortho matrix is computed and used instead of the view projection matrix. The ortho matrix converts from the range (0 ~ Width, 0 ~ Height, -1 ~ +1) to the clip range (-1 ~ +1, -1 ~ +1, -1 ~ +1).

      Parameters:
      cam - The camera to set
      ortho - True if to use orthographic projection (for GUI rendering), false if to use the camera's view and projection matrices.

    • renderViewPortRaw

      public void renderViewPortRaw(ViewPort vp)
      Draws the viewport but without notifying scene processors of any rendering events.
      Parameters:
      vp - The ViewPort to render
      See Also:

    • renderViewPort

      public void renderViewPort(ViewPort vp, float tpf)
      Renders the ViewPort.

      If the ViewPort is disabled, this method returns immediately. Otherwise, the ViewPort is rendered by the following process:

      Parameters:
      vp - View port to render
      tpf - Time per frame value

    • render

      public void render(float tpf, boolean mainFrameBufferActive)
      Called by the application to render any ViewPorts added to this RenderManager.

      Renders any viewports that were added using the following methods:

      Parameters:
      tpf - Time per frame value
      mainFrameBufferActive - true to render viewports with no output FrameBuffer, false to skip them

    • getPassDrawBufferTargetIdToShaders

      public boolean getPassDrawBufferTargetIdToShaders()
      Returns true if the draw buffer target id is passed to the shader.
      Returns:
      True if the draw buffer target id is passed to the shaders.

    • setPassDrawBufferTargetIdToShaders

      public void setPassDrawBufferTargetIdToShaders(boolean v)
      Enable or disable passing the draw buffer target id to the shaders. This is needed to handle FrameBuffer.setTargetIndex correctly in some backends.
      Parameters:
      v - True to enable, false to disable (default is true)

    • setRenderFilter

      public void setRenderFilter(Predicate<Geometry> filter)
      Set a render filter. Every geometry will be tested against this filter before rendering and will only be rendered if the filter returns true.
      Parameters:
      filter -

    • getRenderFilter

      public Predicate<Geometry> getRenderFilter()
      Returns the render filter that the RenderManager is currently using
      Parameters:
      filter - the render filter