smk::Window Class Reference

#include <Window.hpp>

Inheritance diagram for smk::Window:

A window. You can draw objects on the window. More...

Description

A window. You can draw objects on the window.

Example:

auto window = smk::Window(640, 480, "Window title");

Examples

bezier.cpp, framebuffer.cpp, rounded_rectangle.cpp, shape_2d.cpp, shape_3d.cpp, sound.cpp, sprite.cpp, sprite_move.cpp, text.cpp, texture_subrectangle.cpp, touch.cpp, and vibrate.cpp.

Definition at line 31 of file Window.hpp.

Public Member Functions
	Window ()
	A null window. More...
	Window (int width, int height, const std::string &title)
	The window construtor. More...
GLFWwindow *	window () const
	The window handle. More...
float	time () const
	The last time Window::PoolEvent() was called. More...
Input &	input ()
	Return an object for querying the input state. More...
void	ExecuteMainLoop (const std::function< void(void)> &loop)
	Helper function. Execute the main loop of the application. On web based application: registers the loop in 'requestAnimationFrame'. On desktop based applications: This is a simple 'while' loop. The loop stops when the user presses the 'escape' button or when the |loop| function returns 'false'. More...
void	ExecuteMainLoopUntil (const std::function< bool(void)> &loop)
	Helper function. Execute the main loop of the application. On web based application: registers the loop in 'requestAnimationFrame'. On desktop based applications: This is a simple 'while' loop. The loop stops when the user presses the 'escape' button or when the |loop| function returns 'false'. More...
void	PoolEvents ()
	Handle all the new input events. This update the input() object. More...
void	Display ()
	Present what has been draw to the screen. More...
void	LimitFrameRate (float fps)
bool	ShouldClose ()
	Returns true when the user wants to close the window. More...
	Window (Window &&) noexcept
	Window (const Window &)=delete
Window &	operator= (Window &&) noexcept
Window &	operator= (const Window &)=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

Window() [1/3]

smk::Window::Window

(

)

A null window.

Definition at line 117 of file Window.cpp.

               {
  id_ = ++g_next_id;
  window_by_id[id_] = this;
}

Window() [2/3]

smk::Window::Window	(	int	width,
		int	height,
		const std::string &	title
	)

The window construtor.

Parameters

width	The desired width of the window.
height	The desired height of the window.
title	The window's title.

Definition at line 126 of file Window.cpp.

                                                            {
  input_ = std::make_unique<InputImpl>();
  id_ = ++g_next_id;
  window_by_id[id_] = this;
  width_ = width;
  height_ = height;
 
  glfwSetErrorCallback(GLFWErrorCallback);
  // initialize the GLFW library
  if (!glfwInit()) {
    throw std::runtime_error("Couldn't init GLFW");
  }
 
  // setting the opengl version
#ifdef __EMSCRIPTEN__
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
#else
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
 
  glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
  glfwWindowHint(GLFW_SAMPLES, 4);
 
  // create the window_
  window_ = glfwCreateWindow(width_, height_, title.c_str(), nullptr, nullptr);
  if (!window_) {
    glfwTerminate();
    throw std::runtime_error("Couldn't create a window_");
  }
  window_by_glfw_window[window_] = this;
 
  glfwMakeContextCurrent(window_);
 
#ifndef __EMSCRIPTEN__
  glewExperimental = GL_TRUE;
  GLenum err = glewInit();
 
  if (err != GLEW_OK) {
    glfwTerminate();
    std::string error = (const char*)glewGetErrorString(err);  // NOLINT
    throw std::runtime_error("Could initialize GLEW, error = " + error);
  }
#endif
 
#if !defined NDEBUG && !defined __EMSCRIPTEN__ && __linux__
  glEnable(GL_DEBUG_OUTPUT);
  glDebugMessageCallback(OpenGLDebugMessageCallback, 0);
#endif
 
  // get version info
  const GLubyte* renderer = glGetString(GL_RENDERER);
  const GLubyte* version = glGetString(GL_VERSION);
  std::cout << "Renderer: " << renderer << std::endl;
  std::cout << "OpenGL version supported " << version << std::endl;
 
  // Alpha transparency.
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
  InitRenderTarget();
 
#ifndef __EMSCRIPTEN__
  if (GLEW_KHR_parallel_shader_compile) {
    glMaxShaderCompilerThreadsKHR(4);
    g_khr_parallel_shader = true;
  }
#else
  g_khr_parallel_shader = emscripten_webgl_enable_extension(
      emscripten_webgl_get_current_context(), "KHR_parallel_shader_compile");
 
  MakeCanvasSelectable(id_);
 
  module_canvas_selector_ = "[smk='" + std::to_string(id_) + "']";
 
  emscripten_set_touchstart_callback(module_canvas_selector_.c_str(),
                                     (void*)id_, true, OnTouchEvent);
  emscripten_set_touchend_callback(module_canvas_selector_.c_str(), (void*)id_,
                                   true, OnTouchEvent);
  emscripten_set_touchmove_callback(module_canvas_selector_.c_str(), (void*)id_,
                                    true, OnTouchEvent);
  emscripten_set_touchcancel_callback(module_canvas_selector_.c_str(),
                                      (void*)id_, true, OnTouchEvent);
#endif
  glfwSetScrollCallback(window_, GLFWScrollCallback);
  glfwSetCharCallback(window_, GLFWCharCallback);
}

~Window()

smk::Window::~Window

(

)

Definition at line 254 of file Window.cpp.

                {
  window_by_id.erase(id_);
  // glfwTerminate(); // Needed? What about multiple windows?
}

Window() [3/3]

smk::Window::Window ( Window &&  window )

noexcept

Definition at line 217 of file Window.cpp.

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

Member Function Documentation

Bind()

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

staticinherited

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 )

inherited

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

inherited

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_);
}

Display()

void smk::Window::Display

(

)

Present what has been draw to the screen.

Definition at line 244 of file Window.cpp.

                     {
  // Swap Front and Back buffers (double buffering)
  glfwSwapBuffers(window_);
 
  // Detect window_ related changes
  UpdateDimensions();
 
  time_ = static_cast<float>(glfwGetTime());
}

Draw() [1/2]

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

virtualinherited

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 )

virtualinherited

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()));
}

ExecuteMainLoop()

void smk::Window::ExecuteMainLoop

(

const std::function< void(void)> &

loop

)

Helper function. Execute the main loop of the application. On web based application: registers the loop in 'requestAnimationFrame'. On desktop based applications: This is a simple 'while' loop. The loop stops when the user presses the 'escape' button or when the |loop| function returns 'false'.

Parameters

loop	The function to be called for each new frame.

Definition at line 297 of file Window.cpp.

                                                                {
#ifdef __EMSCRIPTEN__
  main_loop = loop;
  emscripten_set_main_loop(&MainLoop, 0, 1);
#else
  while (!input().IsKeyPressed(GLFW_KEY_ESCAPE) && !ShouldClose()) {
    loop();
    LimitFrameRate(60.F); // NOLINT
  };
#endif
}

ExecuteMainLoopUntil()

void smk::Window::ExecuteMainLoopUntil

(

const std::function< bool(void)> &

loop

)

Helper function. Execute the main loop of the application. On web based application: registers the loop in 'requestAnimationFrame'. On desktop based applications: This is a simple 'while' loop. The loop stops when the user presses the 'escape' button or when the |loop| function returns 'false'.

Parameters

loop	The function to be called for each new frame.

Definition at line 280 of file Window.cpp.

                                                                     {
#ifdef __EMSCRIPTEN__
  main_loop = [my_loop = loop] { (void)my_loop(); };
  emscripten_set_main_loop(&MainLoop, 0, 1);
#else
  while (loop()) {
    LimitFrameRate(60.F); // NOLINT
  }
#endif
}

height()

int smk::RenderTarget::height ( ) const

inherited

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 ( )

protectedinherited

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_);
}

input()

Input & smk::Window::input

(

)

Return an object for querying the input state.

Definition at line 270 of file Window.cpp.

                     {
  return *(input_.get());
}

LimitFrameRate()

void smk::Window::LimitFrameRate

(

float

fps

)

If needed, insert pause in the execution to maintain a given framerate.

Parameters

fps	the desired frame rate.

Definition at line 327 of file Window.cpp.

                                     {
  const float delta = static_cast<float>(glfwGetTime()) - time_last_sleep_;
  const float target = 1.f / fps;
  float sleep_duration = target - delta;
  sleep_duration = std::min(target, sleep_duration);
  if (sleep_duration > 0.f) {
    std::this_thread::sleep_for(
        std::chrono::microseconds(int(sleep_duration * 1'000'000)));  // NOLINT
  }
  time_last_sleep_ = static_cast<float>(glfwGetTime());
}

operator=()

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

noexcept

Definition at line 221 of file Window.cpp.

                                                 {
  if (&other == this) {
    return *this;
  }
  std::swap(window_, other.window_);
  std::swap(time_, other.time_);
  std::swap(time_last_sleep_, other.time_last_sleep_);
  std::swap(input_, other.input_);
  std::swap(id_, other.id_);
  std::swap(module_canvas_selector_, other.module_canvas_selector_);
  RenderTarget::operator=(std::move(other));
  window_by_id[id_] = this;
  window_by_glfw_window[window_] = this;
  return *this;
}

PoolEvents()

void smk::Window::PoolEvents

(

)

Handle all the new input events. This update the input() object.

Definition at line 238 of file Window.cpp.

                        {
  glfwPollEvents();
  input_->Update(window_);
}

SetShaderProgram()

void smk::RenderTarget::SetShaderProgram ( ShaderProgram &  shader_program )

inherited

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 )

inherited

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 )

inherited

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 ( )

inherited

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 ( )

inherited

Return the default predefined 3D shader program.

Definition at line 156 of file RenderTarget.cpp.

                                               {
  return shader_program_3d_;
};

ShouldClose()

bool smk::Window::ShouldClose

(

)

Returns true when the user wants to close the window.

Definition at line 340 of file Window.cpp.

                         {
  return glfwWindowShouldClose(window_);
}

time()

float smk::Window::time

(

)

const

The last time Window::PoolEvent() was called.

Definition at line 265 of file Window.cpp.

                         {
  return time_;
}

view()

const View & smk::RenderTarget::view ( ) const

inherited

Return the View currently assigned to this RenderTarget.

Definition at line 95 of file RenderTarget.cpp.

                                     {
  return view_;
}

width()

int smk::RenderTarget::width ( ) const

inherited

the width of the surface.

Returns

the height of the surface.

Definition at line 225 of file RenderTarget.cpp.

                              {
  return width_;
}

window()

GLFWwindow * smk::Window::window

(

)

const

The window handle.

Definition at line 260 of file Window.cpp.

                                 {
  return window_;
}

Member Data Documentation

fragment_shader_2d_

Shader smk::RenderTarget::fragment_shader_2d_

protectedinherited

Definition at line 71 of file RenderTarget.hpp.

fragment_shader_3d_

Shader smk::RenderTarget::fragment_shader_3d_

protectedinherited

Definition at line 75 of file RenderTarget.hpp.

frame_buffer_

GLuint smk::RenderTarget::frame_buffer_ = 0

protectedinherited

Definition at line 81 of file RenderTarget.hpp.

height_

int smk::RenderTarget::height_ = 0

protectedinherited

Definition at line 63 of file RenderTarget.hpp.

projection_matrix_

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

protectedinherited

Definition at line 66 of file RenderTarget.hpp.

shader_program_

ShaderProgram smk::RenderTarget::shader_program_

protectedinherited

Definition at line 79 of file RenderTarget.hpp.

shader_program_2d_

ShaderProgram smk::RenderTarget::shader_program_2d_

protectedinherited

Definition at line 72 of file RenderTarget.hpp.

shader_program_3d_

ShaderProgram smk::RenderTarget::shader_program_3d_

protectedinherited

Definition at line 76 of file RenderTarget.hpp.

vertex_shader_2d_

Shader smk::RenderTarget::vertex_shader_2d_

protectedinherited

Definition at line 70 of file RenderTarget.hpp.

vertex_shader_3d_

Shader smk::RenderTarget::vertex_shader_3d_

protectedinherited

Definition at line 74 of file RenderTarget.hpp.

view_

smk::View smk::RenderTarget::view_

protectedinherited

Definition at line 67 of file RenderTarget.hpp.

width_

int smk::RenderTarget::width_ = 0

protectedinherited

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/Window.hpp
• /home/arthursonzogni/programmation/real/smk/src/smk/Window.cpp