ruby2d-rpeck-windows 0.11.1

data/ext/ruby2d/gl3.c

@@ -0,0 +1,305 @@
+// OpenGL 3.3+
+
+#include "ruby2d.h"
+
+// Skip this file if OpenGL ES
+#if !GLES
+
+static GLuint vbo;  // our primary vertex buffer object (VBO)
+static GLuint vboSize;  // size of the VBO in bytes
+static GLfloat *vboData;  // pointer to the VBO data
+static GLfloat *vboDataCurrent;  // pointer to the data for the current vertices
+static GLuint vboDataIndex = 0;  // index of the current object being rendered
+static GLuint vboObjCapacity = 7500;  // number of objects the VBO can store
+static GLuint verticesTextureIds[7500]; // store the texture_id of each vertices
+static GLuint shaderProgram;  // triangle shader program
+static GLuint texShaderProgram;  // texture shader program
+
+
+/*
+ * Applies the projection matrix
+ */
+void R2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]) {
+
+  // Use the program object
+  glUseProgram(shaderProgram);
+
+  // Apply the projection matrix to the triangle shader
+  glUniformMatrix4fv(
+    glGetUniformLocation(shaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+
+  // Use the texture program object
+  glUseProgram(texShaderProgram);
+
+  // Apply the projection matrix to the texture shader
+  glUniformMatrix4fv(
+    glGetUniformLocation(texShaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+}
+
+
+/*
+ * Initalize OpenGL
+ */
+int R2D_GL3_Init() {
+
+  // Enable transparency
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // Vertex shader source string
+  GLchar vertexSource[] =
+    "#version 150 core\n"  // shader version
+
+    "uniform mat4 u_mvpMatrix;"  // projection matrix
+
+    // Input attributes to the vertex shader
+    "in vec4 position;"  // position value
+    "in vec4 color;"     // vertex color
+    "in vec2 texcoord;"  // texture coordinates
+
+    // Outputs to the fragment shader
+    "out vec4 Color;"     // vertex color
+    "out vec2 Texcoord;"  // texture coordinates
+
+    "void main() {"
+    // Send the color and texture coordinates right through to the fragment shader
+    "  Color = color;"
+    "  Texcoord = texcoord;"
+    // Transform the vertex position using the projection matrix
+    "  gl_Position = u_mvpMatrix * position;"
+    "}";
+
+  // Fragment shader source string
+  GLchar fragmentSource[] =
+    "#version 150 core\n"  // shader version
+    "in vec4 Color;"       // input color from vertex shader
+    "out vec4 outColor;"   // output fragment color
+
+    "void main() {"
+    "  outColor = Color;"  // pass the color right through
+    "}";
+
+  // Fragment shader source string for textures
+  GLchar texFragmentSource[] =
+    "#version 150 core\n"     // shader version
+    "in vec4 Color;"          // input color from vertex shader
+    "in vec2 Texcoord;"       // input texture coordinates
+    "out vec4 outColor;"      // output fragment color
+    "uniform sampler2D tex;"  // 2D texture unit
+
+    "void main() {"
+    // Apply the texture unit, texture coordinates, and color
+    "  outColor = texture(tex, Texcoord) * Color;"
+    "}";
+
+  // Create a vertex array object
+  GLuint vao;
+  glGenVertexArrays(1, &vao);
+  glBindVertexArray(vao);
+
+  // Create a vertex buffer object and allocate data
+  glGenBuffers(1, &vbo);
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+  vboSize = vboObjCapacity * sizeof(GLfloat) * 8;
+  vboData = (GLfloat *) malloc(vboSize);
+  vboDataCurrent = vboData;
+
+  // Create an element buffer object
+  GLuint ebo;
+  glGenBuffers(1, &ebo);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
+
+  // Load the vertex and fragment shaders
+  GLuint vertexShader      = R2D_GL_LoadShader(  GL_VERTEX_SHADER,      vertexSource, "GL3 Vertex");
+  GLuint fragmentShader    = R2D_GL_LoadShader(GL_FRAGMENT_SHADER,    fragmentSource, "GL3 Fragment");
+  GLuint texFragmentShader = R2D_GL_LoadShader(GL_FRAGMENT_SHADER, texFragmentSource, "GL3 Texture Fragment");
+
+  // Triangle Shader //
+
+  // Create the shader program object
+  shaderProgram = glCreateProgram();
+
+  // Check if program was created successfully
+  if (shaderProgram == 0) {
+    R2D_GL_PrintError("Failed to create shader program");
+    return GL_FALSE;
+  }
+
+  // Attach the shader objects to the program object
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+
+  // Bind the output color variable to the fragment shader color number
+  glBindFragDataLocation(shaderProgram, 0, "outColor");
+
+  // Link the shader program
+  glLinkProgram(shaderProgram);
+
+  // Check if linked
+  R2D_GL_CheckLinked(shaderProgram, "GL3 shader");
+
+  // Specify the layout of the position vertex data...
+  GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
+  glEnableVertexAttribArray(posAttrib);
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
+
+  // ...and the color vertex data
+  GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
+  glEnableVertexAttribArray(colAttrib);
+  glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
+
+  // Texture Shader //
+
+  // Create the texture shader program object
+  texShaderProgram = glCreateProgram();
+
+  // Check if program was created successfully
+  if (texShaderProgram == 0) {
+    R2D_GL_PrintError("Failed to create shader program");
+    return GL_FALSE;
+  }
+
+  // Attach the shader objects to the program object
+  glAttachShader(texShaderProgram, vertexShader);
+  glAttachShader(texShaderProgram, texFragmentShader);
+
+  // Bind the output color variable to the fragment shader color number
+  glBindFragDataLocation(texShaderProgram, 0, "outColor");
+
+  // Link the shader program
+  glLinkProgram(texShaderProgram);
+
+  // Check if linked
+  R2D_GL_CheckLinked(texShaderProgram, "GL3 texture shader");
+
+  // Specify the layout of the position vertex data...
+  posAttrib = glGetAttribLocation(texShaderProgram, "position");
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
+  glEnableVertexAttribArray(posAttrib);
+
+  // ...and the color vertex data...
+  colAttrib = glGetAttribLocation(texShaderProgram, "color");
+  glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(colAttrib);
+
+  // ...and the texture coordinates
+  GLint texAttrib = glGetAttribLocation(texShaderProgram, "texcoord");
+  glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(6 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(texAttrib);
+
+  // Clean up
+  glDeleteShader(vertexShader);
+  glDeleteShader(fragmentShader);
+  glDeleteShader(texFragmentShader);
+
+  // If successful, return true
+  return GL_TRUE;
+}
+
+
+/*
+ * Render the vertex buffer and reset it
+ */
+void R2D_GL3_FlushBuffers() {
+  // Bind to the vertex buffer object and update its data
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+  glBufferData(GL_ARRAY_BUFFER, vboSize, NULL, GL_DYNAMIC_DRAW);
+  glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * vboDataIndex * 8, vboData);
+
+  GLuint verticesOffset = 0;
+  GLuint lastTextureId = verticesTextureIds[0];
+
+  for (GLuint i = 0; i <= vboDataIndex; i++) {
+    if(lastTextureId != verticesTextureIds[i] || i == vboDataIndex) {
+      // A texture ID of 0 represents no texture (render a triangle)
+      if(lastTextureId == 0) {
+
+        // Use the triangle shader program
+        glUseProgram(shaderProgram);
+
+      // A number other than 0 represents a texture_id
+      } else {
+
+        // Use the texture shader program
+        glUseProgram(texShaderProgram);
+
+        // Bind the texture using the provided ID
+        glBindTexture(GL_TEXTURE_2D, lastTextureId);
+      }
+
+      glDrawArrays(GL_TRIANGLES, verticesOffset, i - verticesOffset);
+
+      lastTextureId = verticesTextureIds[i];
+      verticesOffset = i;
+    }
+  }
+
+  // Reset the buffer object index and data pointer
+  vboDataIndex = 0;
+  vboDataCurrent = vboData;
+}
+
+
+/*
+ * Draw triangle
+ */
+void R2D_GL3_DrawTriangle(GLfloat x1, GLfloat y1,
+                          GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
+                          GLfloat x2, GLfloat y2,
+                          GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
+                          GLfloat x3, GLfloat y3,
+                          GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3) {
+
+  // If buffer is full, flush it
+  if (vboDataIndex + 3 >= vboObjCapacity) R2D_GL3_FlushBuffers();
+
+  // Set the triangle data into a formatted array
+  GLfloat vertices[24] =
+    { x1, y1, r1, g1, b1, a1, 0, 0,
+      x2, y2, r2, g2, b2, a2, 0, 0,
+      x3, y3, r3, g3, b3, a3, 0, 0 };
+
+  // Copy the vertex data into the current position of the buffer
+  memcpy(vboDataCurrent, vertices, sizeof(vertices));
+
+  // Increment the buffer object index and the vertex data pointer for next use
+  verticesTextureIds[vboDataIndex] = verticesTextureIds[vboDataIndex + 1] = verticesTextureIds[vboDataIndex + 2] = 0;
+  vboDataIndex += 3;
+  vboDataCurrent = (GLfloat *)((char *)vboDataCurrent + (sizeof(GLfloat) * 24));
+}
+
+
+/*
+ * Draw a texture (New method with vertices pre-calculated)
+ */
+void R2D_GL3_DrawTexture(GLfloat coordinates[], GLfloat texture_coordinates[], GLfloat color[], int texture_id) {
+  // If buffer is full, flush it
+  if (vboDataIndex + 6 >= vboObjCapacity) R2D_GL3_FlushBuffers();
+
+  // There are 6 vertices for a square as we are rendering two Triangles to make up our square:
+  // Triangle one: Top left, Top right, Bottom right
+  // Triangle two: Bottom right, Bottom left, Top left
+  GLfloat vertices[48] = {
+    coordinates[0], coordinates[1], color[0], color[1], color[2], color[3], texture_coordinates[0], texture_coordinates[1],
+    coordinates[2], coordinates[3], color[0], color[1], color[2], color[3], texture_coordinates[2], texture_coordinates[3],
+    coordinates[4], coordinates[5], color[0], color[1], color[2], color[3], texture_coordinates[4], texture_coordinates[5],
+    coordinates[4], coordinates[5], color[0], color[1], color[2], color[3], texture_coordinates[4], texture_coordinates[5],
+    coordinates[6], coordinates[7], color[0], color[1], color[2], color[3], texture_coordinates[6], texture_coordinates[7],
+    coordinates[0], coordinates[1], color[0], color[1], color[2], color[3], texture_coordinates[0], texture_coordinates[1],
+  };
+
+  // Copy the vertex data into the current position of the buffer
+  memcpy(vboDataCurrent, vertices, sizeof(vertices));
+
+  verticesTextureIds[vboDataIndex] = verticesTextureIds[vboDataIndex + 1] = verticesTextureIds[vboDataIndex + 2] = verticesTextureIds[vboDataIndex + 3] = verticesTextureIds[vboDataIndex + 4] = verticesTextureIds[vboDataIndex + 5] = texture_id;
+  vboDataIndex += 6;
+  vboDataCurrent = (GLfloat *)((char *)vboDataCurrent + (sizeof(GLfloat) * 48));
+}
+
+
+#endif

data/ext/ruby2d/gles.c

@@ -0,0 +1,249 @@
+// OpenGL ES 2.0
+
+#include "ruby2d.h"
+
+#if GLES
+
+// Triangle shader
+static GLuint shaderProgram;
+static GLuint positionLocation;
+static GLuint colorLocation;
+
+// Texture shader
+static GLuint texShaderProgram;
+static GLuint texPositionLocation;
+static GLuint texColorLocation;
+static GLuint texCoordLocation;
+static GLuint samplerLocation;
+
+static GLushort indices[] =
+  { 0, 1, 2,
+    2, 3, 0 };
+
+
+/*
+ * Applies the projection matrix
+ */
+void R2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]) {
+
+  // Use the program object
+  glUseProgram(shaderProgram);
+
+  glUniformMatrix4fv(
+    glGetUniformLocation(shaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+
+  // Use the texture program object
+  glUseProgram(texShaderProgram);
+
+  glUniformMatrix4fv(
+    glGetUniformLocation(texShaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+}
+
+
+/*
+ * Initalize OpenGL ES
+ */
+int R2D_GLES_Init() {
+
+  // Enable transparency
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // Vertex shader source string
+  GLchar vertexSource[] =
+    // uniforms used by the vertex shader
+    "uniform mat4 u_mvpMatrix;"   // projection matrix
+
+    // attributes input to the vertex shader
+    "attribute vec4 a_position;"  // position value
+    "attribute vec4 a_color;"     // input vertex color
+    "attribute vec2 a_texcoord;"  // input texture
+
+    // varying variables, input to the fragment shader
+    "varying vec4 v_color;"       // output vertex color
+    "varying vec2 v_texcoord;"    // output texture
+
+    "void main()"
+    "{"
+    "  v_color = a_color;"
+    "  v_texcoord = a_texcoord;"
+    "  gl_Position = u_mvpMatrix * a_position;"
+    "}";
+
+  // Fragment shader source string
+  GLchar fragmentSource[] =
+    "precision mediump float;"
+    // input vertex color from vertex shader
+    "varying vec4 v_color;"
+
+    "void main()"
+    "{"
+    "  gl_FragColor = v_color;"
+    "}";
+
+  // Fragment shader source string for textures
+  GLchar texFragmentSource[] =
+    "precision mediump float;"
+    // input vertex color from vertex shader
+    "varying vec4 v_color;"
+    "varying vec2 v_texcoord;"
+    "uniform sampler2D s_texture;"
+
+    "void main()"
+    "{"
+    "  gl_FragColor = texture2D(s_texture, v_texcoord) * v_color;"
+    "}";
+
+  // Load the vertex and fragment shaders
+  GLuint vertexShader      = R2D_GL_LoadShader(  GL_VERTEX_SHADER,      vertexSource, "GLES Vertex");
+  GLuint fragmentShader    = R2D_GL_LoadShader(GL_FRAGMENT_SHADER,    fragmentSource, "GLES Fragment");
+  GLuint texFragmentShader = R2D_GL_LoadShader(GL_FRAGMENT_SHADER, texFragmentSource, "GLES Texture Fragment");
+
+  // Triangle Shader //
+
+  // Create the shader program object
+  shaderProgram = glCreateProgram();
+
+  // Check if program was created successfully
+  if (shaderProgram == 0) {
+    R2D_GL_PrintError("Failed to create shader program");
+    return GL_FALSE;
+  }
+
+  // Attach the shader objects to the program object
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+
+  // Link the shader program
+  glLinkProgram(shaderProgram);
+
+  // Check if linked
+  R2D_GL_CheckLinked(shaderProgram, "GLES shader");
+
+  // Get the attribute locations
+  positionLocation = glGetAttribLocation(shaderProgram, "a_position");
+  colorLocation    = glGetAttribLocation(shaderProgram, "a_color");
+
+  // Texture Shader //
+
+  // Create the texture shader program object
+  texShaderProgram = glCreateProgram();
+
+  // Check if program was created successfully
+  if (texShaderProgram == 0) {
+    R2D_GL_PrintError("Failed to create shader program");
+    return GL_FALSE;
+  }
+
+  // Attach the shader objects to the program object
+  glAttachShader(texShaderProgram, vertexShader);
+  glAttachShader(texShaderProgram, texFragmentShader);
+
+  // Link the shader program
+  glLinkProgram(texShaderProgram);
+
+  // Check if linked
+  R2D_GL_CheckLinked(texShaderProgram, "GLES texture shader");
+
+  // Get the attribute locations
+  texPositionLocation = glGetAttribLocation(texShaderProgram, "a_position");
+  texColorLocation    = glGetAttribLocation(texShaderProgram, "a_color");
+  texCoordLocation    = glGetAttribLocation(texShaderProgram, "a_texcoord");
+
+  // Get the sampler location
+  samplerLocation = glGetUniformLocation(texShaderProgram, "s_texture");
+
+  // Clean up
+  glDeleteShader(vertexShader);
+  glDeleteShader(fragmentShader);
+  glDeleteShader(texFragmentShader);
+
+  return GL_TRUE;
+}
+
+
+/*
+ * Draw triangle
+ */
+void R2D_GLES_DrawTriangle(GLfloat x1, GLfloat y1,
+                           GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
+                           GLfloat x2, GLfloat y2,
+                           GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
+                           GLfloat x3, GLfloat y3,
+                           GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3) {
+
+  GLfloat vertices[] =
+    { x1, y1, 0.f,
+      x2, y2, 0.f,
+      x3, y3, 0.f };
+
+  GLfloat colors[] =
+    { r1, g1, b1, a1,
+      r2, g2, b2, a2,
+      r3, g3, b3, a3 };
+
+  glUseProgram(shaderProgram);
+
+  // Load the vertex position
+  glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, vertices);
+  glEnableVertexAttribArray(positionLocation);
+
+  // Load the colors
+  glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors);
+  glEnableVertexAttribArray(colorLocation);
+
+  // draw
+  glDrawArrays(GL_TRIANGLES, 0, 3);
+}
+
+
+/*
+ * Draw a texture (New method with vertices pre-calculated)
+ */
+void R2D_GLES_DrawTexture(GLfloat coordinates[], GLfloat texture_coordinates[], GLfloat color[], int texture_id);
+  GLfloat vertices[] =
+  //  x, y coords | x, y texture coords
+  {
+    coordinates[0], coordinates[1], 0.f, texture_coordinates[0], texture_coordinates[1],
+    coordinates[2], coordinates[3], 0.f, texture_coordinates[2], texture_coordinates[3],
+    coordinates[4], coordinates[5], 0.f, texture_coordinates[4], texture_coordinates[5],
+    coordinates[6], coordinates[7], 0.f, texture_coordinates[6], texture_coordinates[7] };
+
+  GLfloat colors[] =
+    { color[0], color[1], color[2], color[3],
+    color[0], color[1], color[2], color[3],
+    color[0], color[1], color[2], color[3],
+    color[0], color[1], color[2], color[3] };
+
+  glUseProgram(texShaderProgram);
+
+  // Load the vertex position
+  glVertexAttribPointer(texPositionLocation, 3, GL_FLOAT, GL_FALSE,
+                        5 * sizeof(GLfloat), vertices);
+  glEnableVertexAttribArray(texPositionLocation);
+
+  // Load the colors
+  glVertexAttribPointer(texColorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors);
+  glEnableVertexAttribArray(texColorLocation);
+
+  // Load the texture coordinate
+  glVertexAttribPointer(texCoordLocation, 2, GL_FLOAT, GL_FALSE,
+                        5 * sizeof(GLfloat), &vertices[3]);
+  glEnableVertexAttribArray(texCoordLocation);
+
+  // Bind the texture
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, texture_id);
+
+  // Set the sampler texture unit to 0
+  glUniform1i(samplerLocation, 0);
+
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
+}
+
+
+#endif

data/ext/ruby2d/image.c

@@ -0,0 +1,58 @@
+// image.c
+
+#include "ruby2d.h"
+
+
+SDL_Surface *R2D_CreateImageSurface(const char *path) {
+  R2D_Init();
+
+  // Check if image file exists
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateImageSurface", "Image file `%s` not found", path);
+    return NULL;
+  }
+
+  // Load image from file as SDL_Surface
+  SDL_Surface *surface = IMG_Load(path);
+
+  int bits_per_color = surface->format->Amask == 0 ?
+    surface->format->BitsPerPixel / 3 :
+    surface->format->BitsPerPixel / 4;
+
+  if (bits_per_color < 8) {
+    R2D_Log(R2D_WARN, "`%s` has less than 8 bits per color and will likely not render correctly", path, bits_per_color);
+  }
+
+  return surface;
+}
+
+void R2D_ImageConvertToRGB(SDL_Surface *surface) {
+  Uint32 r = surface->format->Rmask;
+  Uint32 g = surface->format->Gmask;
+  Uint32 a = surface->format->Amask;
+
+  if (r&0xFF000000 || r&0xFF0000) {
+    char *p = (char *)surface->pixels;
+    int bpp = surface->format->BytesPerPixel;
+    int w = surface->w;
+    int h = surface->h;
+    char tmp;
+    for (int i = 0; i < bpp * w * h; i += bpp) {
+      if (a&0xFF) {
+        tmp = p[i];
+        p[i] = p[i+3];
+        p[i+3] = tmp;
+      }
+      if (g&0xFF0000) {
+        tmp = p[i+1];
+        p[i+1] = p[i+2];
+        p[i+2] = tmp;
+      }
+      if (r&0xFF0000) {
+        tmp = p[i];
+        p[i] = p[i+2];
+        p[i+2] = tmp;
+      }
+    }
+  }
+}

data/ext/ruby2d/input.c

@@ -0,0 +1,48 @@
+// input.c
+
+#include "ruby2d.h"
+
+
+/*
+ * Get the mouse coordinates relative to the viewport
+ */
+void R2D_GetMouseOnViewport(R2D_Window *window, int wx, int wy, int *x, int *y) {
+
+  double scale;  // viewport scale factor
+  int w, h;      // width and height of scaled viewport
+
+  switch (window->viewport.mode) {
+
+    case R2D_FIXED: case R2D_EXPAND:
+      *x = wx / (window->orig_width  / (double)window->viewport.width);
+      *y = wy / (window->orig_height / (double)window->viewport.height);
+      break;
+
+    case R2D_SCALE:
+      R2D_GL_GetViewportScale(window, &w, &h, &scale);
+      *x = wx * 1 / scale - (window->width  - w) / (2.0 * scale);
+      *y = wy * 1 / scale - (window->height - h) / (2.0 * scale);
+      break;
+
+    case R2D_STRETCH:
+      *x = wx * window->viewport.width  / (double)window->width;
+      *y = wy * window->viewport.height / (double)window->height;
+      break;
+  }
+}
+
+
+/*
+ * Show the cursor over the window
+ */
+void R2D_ShowCursor() {
+  SDL_ShowCursor(SDL_ENABLE);
+}
+
+
+/*
+ * Hide the cursor over the window
+ */
+void R2D_HideCursor() {
+  SDL_ShowCursor(SDL_DISABLE);
+}