I3T

Appearance

Vp::GameObject ​

Regular world object entity. More...

#include "Viewport/entity/GameObject.h"

Inherits from Vp::Entity

Inherited by Vp::ColoredObject, Vp::GridObject, Vp::TexturedObject

Public Functions ​

Name
GameObject() =default<br>Creates an empty GameObject.
GameObject(Core::Mesh * mesh, ObjectShader * shader)
virtual voiddispose() override
virtual voidprepareRenderContext(RenderContext & context, const DisplayOptions & displayOptions) override
voidrender(const glm::mat4 & model, const glm::mat4 & view, const glm::mat4 & projection, const DisplayOptions & displayOptions)<br>Renders the entity with default rendering parameters.
virtual voidrender(const glm::mat4 & model, const glm::mat4 & view, const glm::mat4 & projection, const RenderContext & context) override<br>IMPLEMENTATION NOTE: Derived entity classes should expect a certain kind of shader and be able to directly static cast to it.
virtual voidrender(const glm::mat4 & model, const glm::mat4 & view, const glm::mat4 & projection, const RenderContext & context)<br>IMPLEMENTATION NOTE: Derived entity classes should expect a certain kind of shader and be able to directly static cast to it.
virtual voidupdate(Scene & scene) override

Public Attributes ​

Name
Core::Mesh *m_mesh
floatm_opacity

Additional inherited members ​

Public Classes inherited from Vp::Entity

Name
structRenderContext

Public Types inherited from Vp::Entity

Name
enum classRenderType { NORMAL, CUSTOM, SILHOUETTE}

Public Functions inherited from Vp::Entity

Name
Entity()
virtual~Entity() =default
RenderContextcreateRenderContext(const DisplayOptions & displayOptions)
DisplayTypegetDisplayType() const
glm::vec3getHighlightColor() const
boolisHighlighted() const
virtual voidonSceneAdd(Scene & scene)<br>Called when the entity is added to a scene.
virtual voidonSceneRemove(Scene & scene)<br>Called when the entity is removed from a scene.
voidsetDisplayType(DisplayType type)
voidsetHighlightColor(glm::vec3 highlightColor)
voidsetHighlighted(bool highlight)

Public Attributes inherited from Vp::Entity

Name
boolm_backFaceCull
unsigned intm_explicitTransparencyOrder <br>Explicit order for ordered transparency.
boolm_highlight <br>Whether to paint this entity with an outline, can be used for selection or just highlighting.
glm::vec3m_highlightColor
boolm_highlightUseDepth <br>Whether the highlight outline should respect the scene's depth buffer.
boolm_ignoreReferenceSpace <br>When true, the "global"/"reference space" model matrix passed to viewport drawing methods is ignored.
boolm_ignoreUserClipping <br>Whether to ignore user clip planes defined in DisplayOptions.
glm::mat4m_lastModelMatrix <br>Potentially modifed model matrix last passed to the shader.
glm::mat4m_modelMatrix <br>Model "world" transformation of the entity.
glm::mat4m_modMatrix <br>Modification transformation, precedes any other transformations, modifies entity vertex data as if the modified data came directly from a source (model file).
boolm_opaque
boolm_selectable <br>Whether this entity should be written into the selection stencil buffer.
intm_selectionId <br>Id of the object, -1 if not assigned, for selection purposes.
Shader *m_shader
boolm_visible
boolm_wboit <br>Whether this entity should be rendered using order independent transparency, relevant if using a shader that supports wboit.
intm_wboitFunc <br>Index of the weight function to be used in wboit.

Protected Attributes inherited from Vp::Entity

Name
DisplayTypem_displayType

Detailed Description ​

cpp
class Vp::GameObject;
class Vp::GameObject;

Regular world object entity.

Represents a physical drawable object.

Public Functions Documentation ​

function GameObject ​

cpp
GameObject() =default
GameObject() =default

Creates an empty GameObject.

Before rendering a mesh and a shader need to be set!

function GameObject ​

cpp
GameObject(
    Core::Mesh * mesh,
    ObjectShader * shader
)
GameObject(
    Core::Mesh * mesh,
    ObjectShader * shader
)

function dispose ​

cpp
virtual void dispose() override
virtual void dispose() override

Reimplements: Vp::Entity::dispose

function prepareRenderContext ​

cpp
virtual void prepareRenderContext(
    RenderContext & context,
    const DisplayOptions & displayOptions
) override
virtual void prepareRenderContext(
    RenderContext & context,
    const DisplayOptions & displayOptions
) override

Reimplements: Vp::Entity::prepareRenderContext

Reimplemented by: Vp::GridObject::prepareRenderContext, Vp::TexturedObject::prepareRenderContext

function render ​

cpp
void render(
    const glm::mat4 & model,
    const glm::mat4 & view,
    const glm::mat4 & projection,
    const DisplayOptions & displayOptions
)
void render(
    const glm::mat4 & model,
    const glm::mat4 & view,
    const glm::mat4 & projection,
    const DisplayOptions & displayOptions
)

Renders the entity with default rendering parameters.

Parameters:

  • model Implicit model matrix, multiplies the entity's model transform from the left.
  • view View matrix
  • projection Projection matrix

function render ​

cpp
virtual void render(
    const glm::mat4 & model,
    const glm::mat4 & view,
    const glm::mat4 & projection,
    const RenderContext & context
) override
virtual void render(
    const glm::mat4 & model,
    const glm::mat4 & view,
    const glm::mat4 & projection,
    const RenderContext & context
) override

IMPLEMENTATION NOTE: Derived entity classes should expect a certain kind of shader and be able to directly static cast to it.

Parameters:

  • model Implicit model matrix, multiplies the entity's model transform from the left.
  • view View matrix
  • projection Projection matrix
  • context Additional per-instance rendering parameters generated by createRenderContext() or prepareRenderContext().

Reimplements: Vp::Entity::render

Reimplemented by: Vp::GridObject::render, Vp::SceneCamera::render, Vp::SceneModel::render

Currently there is no error checking and wrongly passed shader type will CAUSE UNDEFINED BEHAVIOUR!

Using dynamic casts instead might be undesirable (slow) here (this might just be a premature optimalization) Generally the shader passed to this method is the m_shader of this entity. However we need functionality that allows us to change the shader temporarily (like for drawing silhouettes) Because of this the shader can also sometimes be something else, usually some derived type of the one the entity expects. I couldn't find a way to inform what kinds of shaders an entity is able to use in its render methods. The type of the shader must be the base Shader class and so some kind of casting must occur.

Another option could be to use some kind of a typeid/enum system that tells us what type a shader is (rather than use dynamic cast). But that approach ignores inheritance which we need and having multiple types of shaders and entity member variable seems very inflexible.

The true elegant solution probably doesn't involve inheritance at all and rather uses composition, together with an ECS or something. But it was decided to not dive into that realm and so we are stuck with this seemingly simple but not very flexible inheritance structure.

function render ​

cpp
virtual void render(
    const glm::mat4 & model,
    const glm::mat4 & view,
    const glm::mat4 & projection,
    const RenderContext & context
)
virtual void render(
    const glm::mat4 & model,
    const glm::mat4 & view,
    const glm::mat4 & projection,
    const RenderContext & context
)

IMPLEMENTATION NOTE: Derived entity classes should expect a certain kind of shader and be able to directly static cast to it.

Parameters:

  • model Implicit model matrix, multiplies the entity's model transform from the left.
  • view View matrix
  • projection Projection matrix
  • context Additional per-instance rendering parameters generated by createRenderContext() or prepareRenderContext().

Reimplements: Vp::Entity::render

Reimplemented by: Vp::GridObject::render, Vp::SceneCamera::render, Vp::SceneModel::render

Currently there is no error checking and wrongly passed shader type will CAUSE UNDEFINED BEHAVIOUR!

Using dynamic casts instead might be undesirable (slow) here (this might just be a premature optimalization) Generally the shader passed to this method is the m_shader of this entity. However we need functionality that allows us to change the shader temporarily (like for drawing silhouettes) Because of this the shader can also sometimes be something else, usually some derived type of the one the entity expects. I couldn't find a way to inform what kinds of shaders an entity is able to use in its render methods. The type of the shader must be the base Shader class and so some kind of casting must occur.

Another option could be to use some kind of a typeid/enum system that tells us what type a shader is (rather than use dynamic cast). But that approach ignores inheritance which we need and having multiple types of shaders and entity member variable seems very inflexible.

The true elegant solution probably doesn't involve inheritance at all and rather uses composition, together with an ECS or something. But it was decided to not dive into that realm and so we are stuck with this seemingly simple but not very flexible inheritance structure.

function update ​

cpp
virtual void update(
    Scene & scene
) override
virtual void update(
    Scene & scene
) override

Reimplements: Vp::Entity::update

Reimplemented by: Vp::SceneCamera::update, Vp::SceneModel::update, Vp::SceneScreen::update

Public Attributes Documentation ​

variable m_mesh ​

cpp
Core::Mesh * m_mesh;
Core::Mesh * m_mesh;

variable m_opacity ​

cpp
float m_opacity {0.5f};
float m_opacity {0.5f};

Updated on 2025-05-31 at 12:55:31 +0000