#include <renderer.h>

Inheritance diagram for Beatmup::SceneRenderer:

Public Types
enum	OutputMapping { STRETCH = 0 , FIT_WIDTH_TO_TOP , FIT_WIDTH , FIT_HEIGHT }
	Scene coordinates to output (screen or bitmap) pixel coordinates mapping. More...

Public Types inherited from Beatmup::AbstractTask
enum class	TaskDeviceRequirement { CPU_ONLY , GPU_OR_CPU , GPU_ONLY }
	Specifies which device (CPU and/or GPU) is used to run the task. More...

Public Member Functions
	SceneRenderer ()

	~SceneRenderer ()

void	setOutput (AbstractBitmap *bitmap)
	Attaches a bitmap to the renderer output. More...

AbstractBitmap *	getOutput () const

void	resetOutput ()
	Removes a bitmap from the renderer output, if any, and switches to on-screen rendering. More...

const Scene *	getScene () const

void	setScene (Scene *scene)

void	setOutputMapping (const OutputMapping mapping)
	Specifies the output mapping specifying how the scene coordinates [0,1]² are mapped to the output (screen or bitmap) pixel coordinates. More...

OutputMapping	getOutputMapping () const
	Retrieves the output mapping specifying how the scene coordinates [0,1]² are mapped to the output (screen or bitmap) pixel coordinates. More...

void	setOutputReferenceWidth (int newWidth)
	Sets a value overriding output width for elements that have their size in pixels, in order to render a resolution-independent picture. More...

int	getOutputReferenceWidth () const

void	setOutputPixelsFetching (bool fetch)
	Specifies whether the output image data is pulled from GPU to CPU memory every time the rendering is done. More...

bool	getOutputPixelsFetching () const
	Reports whether the output bitmap pixels are automatically offloaded from GPU to CPU memory every time the rendering is done. More...

void	setBackgroundImage (AbstractBitmap *)
	Sets an image to pave the background. More...

AbstractBitmap *	getBackgroundImage () const

Scene::Layer *	pickLayer (float x, float y, bool inPixels) const
	Retrieves a scene layer visible at a given point, if any. More...

void	setRenderingEventListener (RenderingContext::EventListener *eventListener)

Public Member Functions inherited from Beatmup::AbstractTask
virtual void	afterProcessing (ThreadIndex threadCount, GraphicPipeline *gpu, bool aborted)
	Instruction called after the task is executed. More...

Public Member Functions inherited from Beatmup::Object
virtual	~Object ()

Protected Member Functions
bool	process (TaskThread &thread)
	Executes the task on CPU within a given thread. More...

bool	processOnGPU (GraphicPipeline &gpu, TaskThread &thread)
	Executes the task on GPU. More...

void	beforeProcessing (ThreadIndex threadCount, ProcessingTarget target, GraphicPipeline *gpu)
	Instruction called before the task is executed. More...

Private Member Functions
void	renderLayer (RenderingContext &context, TaskThread &thread, Scene::Layer &layer, const AffineMapping &base, unsigned int recursionLevel=0)

bool	doRender (GraphicPipeline &gpu, TaskThread &thread)

Private Attributes
Scene *	scene
	content to render More...

AbstractBitmap *	background
	used to pave the screen before rendering More...

AbstractBitmap *	output
	output bitmap More...

OutputMapping	outputMapping
	specifies how the scene coordinates [0,1] are mapped to the output (screen or bitmap) More...

AffineMapping	outputCoords
	the actual output mapping used during the last rendering More...

ImageResolution	resolution
	last rendered resolution More...

int	referenceWidth
	value overriding output width for elements that have their size in pixels, in order to render a resolution-independent picture More...

bool	outputPixelsFetching
	if `true`, the output bitmap data is fetched from GPU to CPU RAM every time the rendering is done More...

GL::TextureHandler *	cameraFrame
	last got camera frame; set to NULL before rendering, then asked from outside through eventListener More...

RenderingContext::EventListener *	eventListener

Static Private Attributes
static const unsigned int	MAX_RECURSION_LEVEL = 256

Additional Inherited Members
Static Public Member Functions inherited from Beatmup::AbstractTask
static ThreadIndex	validThreadCount (int number)
	Valid thread count from a given integer value. More...

Detailed Description

AbstractTask rendering a Scene.

The rendering may be done to a given bitmap or on screen, if the platform supports on-screen rendering.

Definition at line 29 of file renderer.h.

Member Enumeration Documentation

◆ OutputMapping

enum Beatmup::SceneRenderer::OutputMapping

Scene coordinates to output (screen or bitmap) pixel coordinates mapping.

Enumerator
STRETCH	output viewport covers entirely the scene axis span, aspect ratio is not preserved in general
FIT_WIDTH_TO_TOP	width is covered entirely, height is resized to keep aspect ratio, the top borders are aligned
FIT_WIDTH	width is covered entirely, height is resized to keep aspect ratio, point (0.5, 0.5) is mapped to the output center
FIT_HEIGHT	height is covered entirely, width is resized to keep aspect ratio, point (0.5, 0.5) is mapped to the output center

Definition at line 34 of file renderer.h.

                            {
             STRETCH = 0,        //!< output viewport covers entirely the scene axis span, aspect ratio is not preserved in general
             FIT_WIDTH_TO_TOP,   //!< width is covered entirely, height is resized to keep aspect ratio, the top borders are aligned
             FIT_WIDTH,          //!< width is covered entirely, height is resized to keep aspect ratio, point (0.5, 0.5) is mapped to the output center
             FIT_HEIGHT          //!< height is covered entirely, width is resized to keep aspect ratio, point (0.5, 0.5) is mapped to the output center
         };

Constructor & Destructor Documentation

◆ SceneRenderer()

SceneRenderer::SceneRenderer ( )

Definition at line 236 of file renderer.cpp.

                             :
     scene(nullptr), background(nullptr), output(nullptr),
     outputMapping(FIT_WIDTH_TO_TOP),
     referenceWidth(0),
     outputPixelsFetching(false),
     eventListener(nullptr)
 {}

◆ ~SceneRenderer()

SceneRenderer::~SceneRenderer ( )

Definition at line 245 of file renderer.cpp.

245 {}

Member Function Documentation

◆ renderLayer()

void SceneRenderer::renderLayer	(	RenderingContext &	context,
		TaskThread &	thread,
		Scene::Layer &	layer,
		const AffineMapping &	base,
		unsigned int	recursionLevel = `0`
	)

private

Definition at line 37 of file renderer.cpp.

                                                                                                                                                         {
     if (recursionLevel >= MAX_RECURSION_LEVEL)
         return;
  
     switch (layer.getType()) {
  
     case Scene::Layer::Type::SceneLayer: {
         const Scene& scene = layer.castTo<Scene::SceneLayer>().getScene();
         for (int i = 0; i < scene.getLayerCount() && !thread.isTaskAborted(); ++i) {
             Scene::Layer& l = scene.getLayer(i);
             if (l.isVisible())
                 renderLayer(context, thread, l, base * layer.getMapping(), recursionLevel + 1);
         }
     }
     break;
  
     default:
         context.setMapping(base * layer.getMapping());
         layer.render(context);
         break;
     }
 }

◆ doRender()

bool SceneRenderer::doRender	(	GraphicPipeline &	gpu,
		TaskThread &	thread
	)

private

Definition at line 147 of file renderer.cpp.

                                                                      {
     // check if there is the content to render
     if (!scene)
         return true;
  
     // init rendering context
     resolution = output ? output->getSize() : gpu.getDisplayResolution();
     RenderingContext context(gpu, eventListener,
         resolution,
         referenceWidth > 0 ? referenceWidth : resolution.getWidth(),
         output == nullptr);
  
     // set output
     if (output) {
         context.writeLock(&gpu, output, ProcessingTarget::GPU);
         gpu.bindOutput(*output);
     }
     else {
         gpu.unbindOutput();
     }
  
     // background
     if (background) {
         context.lockBitmap(background);
         gpu.getRenderingPrograms().paveBackground(&gpu, *background, output);
     }
  
     // enable blending
     gpu.switchMode(GraphicPipeline::Mode::RENDERING);
  
     // compute initial mapping
     outputCoords.setIdentity();
     switch (outputMapping) {
     case FIT_WIDTH_TO_TOP:
         outputCoords.matrix.scale(1.0f, resolution.getAspectRatio());
         break;
     case FIT_WIDTH:
         outputCoords.matrix.scale(1.0f, resolution.getAspectRatio());
         outputCoords.setCenterPosition(Point(0.5f, 0.5f));
         break;
     case FIT_HEIGHT:
         outputCoords.matrix.scale(resolution.getInvAspectRatio(), 1.0f);
         outputCoords.setCenterPosition(Point(0.5f, 0.5f));
         break;
     case STRETCH:
         // identity is okay
         break;
     }
  
     // go
     for (int i = 0; i < scene->getLayerCount() && !thread.isTaskAborted(); ++i) {
         Scene::Layer& layer = scene->getLayer(i);
         if (layer.isVisible())
             renderLayer(context, thread, layer, outputCoords);
     }
  
     // finalize output
     if (!thread.isTaskAborted()) {
         if (!output)
             gpu.swapBuffers();
         else if (outputPixelsFetching) {
             context.writeLock(&gpu, output, ProcessingTarget::CPU);
             gpu.pullPixels(*output);
             context.unlock(output);
         }
     }
  
     // unlock all
     context.unlockAll();
     return true;
 }

◆ process()

bool SceneRenderer::process ( TaskThread & thread )

protectedvirtual

Executes the task on CPU within a given thread.

Generally called by multiple threads.

Parameters

thread associated task execution context

Returns: true if the execution is finished correctly, false otherwise

Reimplemented from Beatmup::GpuTask.

Definition at line 230 of file renderer.cpp.

                                               {
     throw RuntimeError("GPU is required for rendering");
     return true;
 }

◆ processOnGPU()

bool SceneRenderer::processOnGPU	(	GraphicPipeline &	gpu,
		TaskThread &	thread
	)

protectedvirtual

Executes the task on GPU.

Parameters

gpu	graphic pipeline instance
thread	associated task execution context

Returns: true if the execution is finished correctly, false otherwise

Reimplemented from Beatmup::AbstractTask.

Definition at line 220 of file renderer.cpp.

                                                                          {
     if (!scene)
         return true;
     Scene::LockGuard lock(scene);
  
     // go
     return doRender(gpu, thread);
 }

◆ beforeProcessing()

void SceneRenderer::beforeProcessing	(	ThreadIndex	threadCount,
		ProcessingTarget	target,
		GraphicPipeline *	gpu
	)

protectedvirtual

Instruction called before the task is executed.

Parameters

threadCount	Number of threads used to perform the task
target	Device used to perform the task
gpu	A graphic pipeline instance; may be null.

Reimplemented from Beatmup::AbstractTask.

Definition at line 138 of file renderer.cpp.

                                                                                                            {
     if (eventListener)
         eventListener->onRenderingStart();
  
     // reset camera frame
     cameraFrame = nullptr;
 }

◆ setOutput()

void SceneRenderer::setOutput ( AbstractBitmap * bitmap )

Attaches a bitmap to the renderer output.

Definition at line 76 of file renderer.cpp.

                                                     {
     this->output = output;
 }

◆ getOutput()

AbstractBitmap * SceneRenderer::getOutput ( ) const

Returns: a pointer to output bitmap

Definition at line 66 of file renderer.cpp.

                                                {
     return output;
 }

◆ resetOutput()

void SceneRenderer::resetOutput ( )

Removes a bitmap from the renderer output, if any, and switches to on-screen rendering.

The rendering is done on the display currently connected to the Context running the rendering task.

Definition at line 81 of file renderer.cpp.

                                 {
     this->output = nullptr;
 }

◆ getScene()

const Scene * SceneRenderer::getScene ( ) const

Definition at line 61 of file renderer.cpp.

                                            {
     return scene;
 }

◆ setScene()

void SceneRenderer::setScene ( Scene * scene )

Definition at line 71 of file renderer.cpp.

                                          {
     this->scene = scene;
 }

◆ setOutputMapping()

void SceneRenderer::setOutputMapping ( const OutputMapping mapping )

Specifies the output mapping specifying how the scene coordinates [0,1]² are mapped to the output (screen or bitmap) pixel coordinates.

Parameters

mapping The coordinates mapping

Definition at line 86 of file renderer.cpp.

                                                                    {
     outputMapping = newMapping;
 }

◆ getOutputMapping()

SceneRenderer::OutputMapping SceneRenderer::getOutputMapping ( ) const

Retrieves the output mapping specifying how the scene coordinates [0,1]² are mapped to the output (screen or bitmap) pixel coordinates.

Returns: the mapping.

Definition at line 91 of file renderer.cpp.

                                                                  {
     return outputMapping;
 }

◆ setOutputReferenceWidth()

void SceneRenderer::setOutputReferenceWidth ( int newWidth )

Sets a value overriding output width for elements that have their size in pixels, in order to render a resolution-independent picture.

Parameters

newWidth The new reference width in pixels. If set negative or zero, the actual output image width is used.

Definition at line 96 of file renderer.cpp.

                                                         {
     referenceWidth = newWidth;
 }

◆ getOutputReferenceWidth()

int SceneRenderer::getOutputReferenceWidth ( ) const

Returns: value overriding output width for elements that have their size in pixels, in order to render a resolution-independent picture.

Definition at line 101 of file renderer.cpp.

                                                  {
     return referenceWidth;
 }

◆ setOutputPixelsFetching()

void SceneRenderer::setOutputPixelsFetching ( bool fetch )

Specifies whether the output image data is pulled from GPU to CPU memory every time the rendering is done.

This is convenient if the rendered image is an application output result, and is further stored or sent through the network. Otherwise, if the image is to be further processed inside Beatmup, the pixel transfer likely introduces an unnecessary latency and may cause FPS drop in real-time rendering. Has no effect in on-screen rendering.

Parameters

[in] fetch If true, pixels are pulled to CPU memory.

Definition at line 111 of file renderer.cpp.

                                                       {
     this->outputPixelsFetching = fetch;
 }

◆ getOutputPixelsFetching()

bool SceneRenderer::getOutputPixelsFetching ( ) const

Reports whether the output bitmap pixels are automatically offloaded from GPU to CPU memory every time the rendering is done.

Definition at line 116 of file renderer.cpp.

                                                   {
     return outputPixelsFetching;
 }

◆ setBackgroundImage()

void SceneRenderer::setBackgroundImage ( AbstractBitmap * bitmap )

Sets an image to pave the background.

Definition at line 106 of file renderer.cpp.

                                                              {
     background = bitmap;
 }

◆ getBackgroundImage()

AbstractBitmap* Beatmup::SceneRenderer::getBackgroundImage ( ) const

inline

Returns: the bitmap currently set to fill the background, null if not set.

Definition at line 132 of file renderer.h.

132 { return background; }

◆ pickLayer()

Scene::Layer * SceneRenderer::pickLayer	(	float	x,
		float	y,
		bool	inPixels
	)		const

Retrieves a scene layer visible at a given point, if any.

In contrast to Scene::getLayer() it takes into account the output mapping. "Phantom" layers are ignored.

Parameters

x	Horizontal coordinate.
y	Vertical coordinate.
inPixels	If `true`, the coordinates are taken in pixels.

Returns: the topmost layer at the given position if any, null if no layer found.

Definition at line 121 of file renderer.cpp.

                                                                           {
     if (scene == nullptr)
         return nullptr;
     if (inPixels) {
         const Point p = outputCoords.getInverse(x / resolution.getWidth(), y / resolution.getHeight());
         return scene->getLayer(p.x, p.y);
     }
     else
         return scene->getLayer(x, y);
 }

◆ setRenderingEventListener()

void SceneRenderer::setRenderingEventListener ( RenderingContext::EventListener * eventListener )

Definition at line 133 of file renderer.cpp.

                                                                                           {
     this->eventListener = eventListener;
 }

Member Data Documentation

◆ scene

Scene* Beatmup::SceneRenderer::scene

private

content to render

Definition at line 42 of file renderer.h.

◆ background

AbstractBitmap* Beatmup::SceneRenderer::background

private

used to pave the screen before rendering

Definition at line 43 of file renderer.h.

◆ output

AbstractBitmap* Beatmup::SceneRenderer::output

private

output bitmap

Definition at line 44 of file renderer.h.

◆ outputMapping

OutputMapping Beatmup::SceneRenderer::outputMapping

private

specifies how the scene coordinates [0,1] are mapped to the output (screen or bitmap)

Definition at line 45 of file renderer.h.

◆ outputCoords

AffineMapping Beatmup::SceneRenderer::outputCoords

private

the actual output mapping used during the last rendering

Definition at line 46 of file renderer.h.

◆ resolution

ImageResolution Beatmup::SceneRenderer::resolution

private

last rendered resolution

Definition at line 47 of file renderer.h.

◆ referenceWidth

int Beatmup::SceneRenderer::referenceWidth

private

value overriding output width for elements that have their size in pixels, in order to render a resolution-independent picture

Definition at line 48 of file renderer.h.

◆ outputPixelsFetching

bool Beatmup::SceneRenderer::outputPixelsFetching

private

if true, the output bitmap data is fetched from GPU to CPU RAM every time the rendering is done

Definition at line 49 of file renderer.h.

◆ cameraFrame

GL::TextureHandler* Beatmup::SceneRenderer::cameraFrame

private

last got camera frame; set to NULL before rendering, then asked from outside through eventListener

Definition at line 50 of file renderer.h.

◆ eventListener

RenderingContext::EventListener* Beatmup::SceneRenderer::eventListener

private

Definition at line 51 of file renderer.h.

◆ MAX_RECURSION_LEVEL

const unsigned int Beatmup::SceneRenderer::MAX_RECURSION_LEVEL = 256

staticprivate

Definition at line 54 of file renderer.h.

The documentation for this class was generated from the following files:

core/scene/renderer.h
core/scene/renderer.cpp

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ OutputMapping

Constructor & Destructor Documentation

◆ SceneRenderer()

◆ ~SceneRenderer()

Member Function Documentation

◆ renderLayer()

◆ doRender()

◆ process()

◆ processOnGPU()

◆ beforeProcessing()

◆ setOutput()

◆ getOutput()

◆ resetOutput()

◆ getScene()

◆ setScene()

◆ setOutputMapping()

◆ getOutputMapping()

◆ setOutputReferenceWidth()

◆ getOutputReferenceWidth()

◆ setOutputPixelsFetching()

◆ getOutputPixelsFetching()

◆ setBackgroundImage()

◆ getBackgroundImage()

◆ pickLayer()

◆ setRenderingEventListener()

Member Data Documentation

◆ scene

◆ background

◆ output

◆ outputMapping

◆ outputCoords

◆ resolution

◆ referenceWidth

◆ outputPixelsFetching

◆ cameraFrame

◆ eventListener

◆ MAX_RECURSION_LEVEL