smk::RenderTarget Class Reference

#include <RenderTarget.hpp>

Inheritance diagram for smk::RenderTarget:

Description

A texture where things can be / a smk::Drawable can be drawn on.

Implemented by:

• Window
• Framebuffer.

Definition at line 25 of file RenderTarget.hpp.

Public Member Functions
	RenderTarget ()
	Build an invalid RenderTarget. It can be replaced later by using the move operator. More...
	RenderTarget (RenderTarget &&other) noexcept
	Constructor from temporary. More...
	RenderTarget (const RenderTarget &rhs)=delete
RenderTarget &	operator= (RenderTarget &&other) noexcept
	Move operator. More...
RenderTarget &	operator= (const RenderTarget &rhs)=delete
void	Clear (const glm::vec4 &color)
	Clear the surface with a single color. More...
void	SetView (const View &view)
	Set the View to use. More...
void	SetView (const glm::mat4 &mat)
	Set the View to use. More...
const View &	view () const
	Return the View currently assigned to this RenderTarget. More...
void	SetShaderProgram (ShaderProgram &shader_program)
	Set the ShaderProgram to be used. More...
ShaderProgram &	shader_program_2d ()
	Return the default predefined 2D shader program. It is bound by default. More...
ShaderProgram &	shader_program_3d ()
	Return the default predefined 3D shader program. More...
virtual void	Draw (const Drawable &drawable)
	Draw on the surface. More...
virtual void	Draw (RenderState &state)
	Draw on the surface. More...
glm::vec2	dimensions () const
	the dimension (width, height) of the drawing area. More...
int	width () const
	the width of the surface. More...
int	height () const
	the height of the surface. More...

Static Public Member Functions
static void	Bind (RenderTarget *target)

Protected Member Functions
void	InitRenderTarget ()

Protected Attributes
int	width_ = 0
int	height_ = 0
glm::mat4	projection_matrix_ = glm::mat4(1)
smk::View	view_
Shader	vertex_shader_2d_
Shader	fragment_shader_2d_
ShaderProgram	shader_program_2d_
Shader	vertex_shader_3d_
Shader	fragment_shader_3d_
ShaderProgram	shader_program_3d_
ShaderProgram	shader_program_
GLuint	frame_buffer_ = 0

Constructor & Destructor Documentation

RenderTarget() [1/2]

smk::RenderTarget::RenderTarget ( )

default

Build an invalid RenderTarget. It can be replaced later by using the move operator.

RenderTarget() [2/2]

smk::RenderTarget::RenderTarget ( RenderTarget &&  other )

noexcept

Constructor from temporary.

Definition at line 42 of file RenderTarget.cpp.

                                                        {
  operator=(std::move(other));
}

Member Function Documentation

Bind()

void smk::RenderTarget::Bind ( RenderTarget *  target )

static

Definition at line 28 of file RenderTarget.cpp.

                                            {
  if (render_target == target) {
    return;
  }
  render_target = target;
  glBindFramebuffer(GL_FRAMEBUFFER, render_target->frame_buffer_);
  glViewport(0, 0, render_target->width_, render_target->height_);
}

Clear()

void smk::RenderTarget::Clear

(

const glm::vec4 &

color

)

Clear the surface with a single color.

Parameters

color

An opaque color to fill the surface.

Definition at line 65 of file RenderTarget.cpp.

                                             {
  Bind(this);
  glClearColor(color.r, color.g, color.b, color.a);  // NOLINT
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  glDisable(GL_DEPTH_TEST);
  glDisable(GL_CULL_FACE);
}

dimensions()

glm::vec2 smk::RenderTarget::dimensions

(

)

const

the dimension (width, height) of the drawing area.

Returns

the dimensions in (pixels, pixels) of the surface.

Definition at line 219 of file RenderTarget.cpp.

                                       {
  return glm::vec2(width_, height_);
}

Draw() [1/2]

void smk::RenderTarget::Draw ( const Drawable &  drawable )

virtual

Draw on the surface.

Parameters

drawable

The object to be drawn on the surface.

Examples

sprite_move.cpp.

Definition at line 162 of file RenderTarget.cpp.

                                                {
  Bind(this);
  RenderState state;
  state.shader_program = shader_program_;
  state.view = glm::mat4(1.F);
  state.color = smk::Color::White;
  state.blend_mode = smk::BlendMode::Alpha;
  drawable.Draw(*this, state);
}

Draw() [2/2]

void smk::RenderTarget::Draw ( RenderState &  state )

virtual

Draw on the surface.

Parameters

state

The RenderState to be usd for drawing.

Definition at line 174 of file RenderTarget.cpp.

                                          {
  // Vertex Array
  if (cached_render_state_.vertex_array != state.vertex_array) {
    cached_render_state_.vertex_array = state.vertex_array;
    state.vertex_array.Bind();
  }
 
  // Shader
  if (cached_render_state_.shader_program != state.shader_program) {
    cached_render_state_.shader_program = state.shader_program;
    cached_render_state_.shader_program.Use();
  }
 
  // Color
  if (cached_render_state_.color != state.color) {
    cached_render_state_.color = state.color;
    cached_render_state_.shader_program.SetUniform("color", state.color);
  }
 
  // View (not cached)
  state.shader_program.SetUniform("projection", projection_matrix_);
  state.shader_program.SetUniform("view", state.view);
 
  // Texture
  const auto& texture = state.texture.id() ? state.texture : WhiteTexture();
  if (cached_render_state_.texture != texture || g_invalidate_textures) {
    cached_render_state_.texture = texture;
    texture.Bind();
    g_invalidate_textures = false;
  }
 
  if (cached_render_state_.blend_mode != state.blend_mode) {
    cached_render_state_.blend_mode = state.blend_mode;
    glEnable(GL_BLEND);
    glBlendEquationSeparate(state.blend_mode.equation_rgb,
                            state.blend_mode.equation_alpha);
    glBlendFuncSeparate(state.blend_mode.src_rgb, state.blend_mode.dst_rgb,
                        state.blend_mode.src_alpha, state.blend_mode.dst_alpha);
  }
 
  glDrawArrays(GL_TRIANGLES, 0, GLsizei(state.vertex_array.size()));
}

height()

int smk::RenderTarget::height

(

)

const

the height of the surface.

Returns

the height in pixels of the surface.

Definition at line 231 of file RenderTarget.cpp.

                               {
  return height_;
}

InitRenderTarget()

void smk::RenderTarget::InitRenderTarget ( )

protected

Definition at line 235 of file RenderTarget.cpp.

                                    {
  View default_view;
  default_view.SetCenter(float(width_) / 2.F, float(height_) / 2.F);  // NOLINT
  default_view.SetSize(float(width_), float(height_));
  SetView(default_view);
 
  vertex_shader_2d_ = Shader::FromString(R"(
    layout(location = 0) in vec2 space_position;
    layout(location = 1) in vec2 texture_position;
 
    uniform mat4 projection;
    uniform mat4 view;
 
    out vec2 f_texture_position;
 
    void main() {
      f_texture_position = texture_position;
      gl_Position = projection * view * vec4(space_position, 0.F, 1.F);
    }
  )",
                                         GL_VERTEX_SHADER);
 
  fragment_shader_2d_ = Shader::FromString(R"(
    in vec2 f_texture_position;
    uniform sampler2D texture_0;
    uniform vec4 color;
    out vec4 out_color;
 
    void main() {
      out_color = texture(texture_0, f_texture_position) * color;
    }
  )",
                                           GL_FRAGMENT_SHADER);
 
  shader_program_2d_.AddShader(vertex_shader_2d_);
  shader_program_2d_.AddShader(fragment_shader_2d_);
  shader_program_2d_.Link();
 
  vertex_shader_3d_ = Shader::FromString(R"(
    layout(location = 0) in vec3 space_position;
    layout(location = 1) in vec3 normal;
    layout(location = 2) in vec2 texture_position;
 
    uniform mat4 projection;
    uniform mat4 view;
 
    out vec4 fPosition;
    out vec2 fTexture;
    out vec3 fNormal;
 
    void main() {
      fTexture = texture_position;
      fPosition = view * vec4(space_position,1.F);
      fNormal = vec3(view * vec4(normal,0.F));
 
      gl_Position = projection * fPosition;
    }
  )",
                                         GL_VERTEX_SHADER);
 
  fragment_shader_3d_ = Shader::FromString(R"(
    uniform sampler2D texture_0;
    uniform vec4 color;
 
    uniform vec4 light_position;
    uniform float ambient;
    uniform float diffuse;
    uniform float specular;
    uniform float specular_power;
 
    in vec4 fPosition;
    in vec2 fTexture;
    in vec3 fNormal;
 
    out vec4 out_color;
 
    void main(void)
    {
      vec3 object_dir =-normalize(fPosition.xyz);
      vec3 normal_dir = normalize(fNormal);
      vec3 light_dir = normalize(light_position.xyz-fPosition.xyz);
      vec3 reflect_dir = -reflect(object_dir,normal_dir);
 
      float diffuse_strength = max(0.F, dot(normal_dir, light_dir));
      float specular_strength = pow(max(0.F, dot(reflect_dir, light_dir)),
                                    specular_power);
 
      out_color = texture(texture_0, fTexture);
      out_color.rgb *= ambient +
                       diffuse * diffuse_strength +
                       specular * specular_strength;
      out_color *= color;
    }
  )",
                                           GL_FRAGMENT_SHADER);
 
  shader_program_3d_.AddShader(vertex_shader_3d_);
  shader_program_3d_.AddShader(fragment_shader_3d_);
  shader_program_3d_.Link();
 
  shader_program_3d_.Use();
  constexpr auto default_light_position = glm::vec4(0.F, 5.F, 0.F, 1.F);
  constexpr auto default_ambient = 0.3F;
  constexpr auto default_diffuse = 0.5F;
  constexpr auto default_specular = 0.5F;
  constexpr auto default_specular_power = 4.F;
  shader_program_3d_.SetUniform("light_position", default_light_position);
  shader_program_3d_.SetUniform("ambient", default_ambient);
  shader_program_3d_.SetUniform("diffuse", default_diffuse);
  shader_program_3d_.SetUniform("specular", default_specular);
  shader_program_3d_.SetUniform("specular_power", default_specular_power);
 
  SetShaderProgram(shader_program_2d_);
}

operator=()

RenderTarget & smk::RenderTarget::operator= ( RenderTarget &&  other )

noexcept

Move operator.

Definition at line 47 of file RenderTarget.cpp.

                                                                   {
  std::swap(width_, other.width_);
  std::swap(height_, other.height_);
  std::swap(projection_matrix_, other.projection_matrix_);
  std::swap(view_, other.view_);
  std::swap(vertex_shader_2d_, other.vertex_shader_2d_);
  std::swap(fragment_shader_2d_, other.fragment_shader_2d_);
  std::swap(shader_program_2d_, other.shader_program_2d_);
  std::swap(vertex_shader_3d_, other.vertex_shader_3d_);
  std::swap(fragment_shader_3d_, other.fragment_shader_3d_);
  std::swap(shader_program_3d_, other.shader_program_3d_);
  std::swap(shader_program_, other.shader_program_);
  std::swap(frame_buffer_, other.frame_buffer_);
  return *this;
}

SetShaderProgram()

void smk::RenderTarget::SetShaderProgram

(

ShaderProgram &

shader_program

)

Set the ShaderProgram to be used.

Parameters

shader_program

The ShaderProgram to be used.

Example:

auto shader_vertex = Shader::FromString(R"(
  layout(location = 0) in vec2 space_position;
  layout(location = 1) in vec2 texture_position;
 
  uniform mat4 projection;
  uniform mat4 view;
 
  out vec2 f_texture_position;
 
  void main() {
    f_texture_position = texture_position;
    gl_Position = projection * view * vec4(space_position, 0.F, 1.F);
  }
)", GL_VERTEX_SHADER);
 
fragment_shader_2d_ = Shader::FromString(R"(
  in vec2 f_texture_position;
  uniform sampler2D texture_0;
  uniform vec4 color;
  out vec4 out_color;
 
  void main() {
    vec4 inverted_color = vec4(1.F) - color;
    out_color = texture(texture_0, f_texture_position) * inverted_color.
  }
)";
 
auto shader_program = smk::ShaderProgram>();
shader_program.AddShader(vertex_shader_2d_);
shader_program.AddShader(fragment_shader_2d_);
shader_program.Link();
 
window.SetShaderProgram(shader_program);

{

Definition at line 140 of file RenderTarget.cpp.

                                                                 {
  shader_program_ = shader_program;
  shader_program_.Use();
  shader_program_.SetUniform("texture_0", 0);
  shader_program_.SetUniform("color", glm::vec4(1.F, 1.F, 1.F, 1.F));
  shader_program_.SetUniform("projection", glm::mat4(1.F));
  shader_program_.SetUniform("view", glm::mat4(1.F));
}

SetView() [1/2]

void smk::RenderTarget::SetView

(

const glm::mat4 &

mat

)

Set the View to use.

Parameters

mat	The matrix to transform from/to the OpenGL space [-1,1]^3 to the screen space.

Definition at line 90 of file RenderTarget.cpp.

                                             {
  projection_matrix_ = mat;
}

SetView() [2/2]

void smk::RenderTarget::SetView

(

const View &

view

)

Set the View to use.

Parameters

view	The view to use.

Definition at line 75 of file RenderTarget.cpp.

                                           {
  view_ = view;
  float z_x = +2.F / view.width_;   // NOLINT [0, width]  -> [-1,1]
  float z_y = -2.F / view.height_;  // NOLINT [0, height] -> [-1,1]
  float t_x = -view.x_ * z_x;
  float t_y = -view.y_ * z_y;
  SetView(glm::mat4(z_x, 0.F, 0.F, 0.F,    //
                    0.F, z_y, 0.F, 0.F,    //
                    0.F, 0.F, 1.F, 0.F,    //
                    t_x, t_y, 0.F, 1.F));  //
}

shader_program_2d()

ShaderProgram & smk::RenderTarget::shader_program_2d

(

)

Return the default predefined 2D shader program. It is bound by default.

Definition at line 151 of file RenderTarget.cpp.

                                               {
  return shader_program_2d_;
};

shader_program_3d()

ShaderProgram & smk::RenderTarget::shader_program_3d

(

)

Return the default predefined 3D shader program.

Definition at line 156 of file RenderTarget.cpp.

                                               {
  return shader_program_3d_;
};

view()

const View & smk::RenderTarget::view

(

)

const

Return the View currently assigned to this RenderTarget.

Definition at line 95 of file RenderTarget.cpp.

                                     {
  return view_;
}

width()

int smk::RenderTarget::width

(

)

const

the width of the surface.

Returns

the height of the surface.

Definition at line 225 of file RenderTarget.cpp.

                              {
  return width_;
}

Member Data Documentation

fragment_shader_2d_

Shader smk::RenderTarget::fragment_shader_2d_

protected

Definition at line 71 of file RenderTarget.hpp.

fragment_shader_3d_

Shader smk::RenderTarget::fragment_shader_3d_

protected

Definition at line 75 of file RenderTarget.hpp.

frame_buffer_

GLuint smk::RenderTarget::frame_buffer_ = 0

protected

Definition at line 81 of file RenderTarget.hpp.

height_

int smk::RenderTarget::height_ = 0

protected

Definition at line 63 of file RenderTarget.hpp.

projection_matrix_

glm::mat4 smk::RenderTarget::projection_matrix_ = glm::mat4(1)

protected

Definition at line 66 of file RenderTarget.hpp.

shader_program_

ShaderProgram smk::RenderTarget::shader_program_

protected

Definition at line 79 of file RenderTarget.hpp.

shader_program_2d_

ShaderProgram smk::RenderTarget::shader_program_2d_

protected

Definition at line 72 of file RenderTarget.hpp.

shader_program_3d_

ShaderProgram smk::RenderTarget::shader_program_3d_

protected

Definition at line 76 of file RenderTarget.hpp.

vertex_shader_2d_

Shader smk::RenderTarget::vertex_shader_2d_

protected

Definition at line 70 of file RenderTarget.hpp.

vertex_shader_3d_

Shader smk::RenderTarget::vertex_shader_3d_

protected

Definition at line 74 of file RenderTarget.hpp.

view_

smk::View smk::RenderTarget::view_

protected

Definition at line 67 of file RenderTarget.hpp.

width_

int smk::RenderTarget::width_ = 0

protected

Definition at line 62 of file RenderTarget.hpp.

---

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

• /home/arthursonzogni/programmation/real/smk/include/smk/RenderTarget.hpp
• /home/arthursonzogni/programmation/real/smk/src/smk/RenderTarget.cpp