Renderer.c File Reference

#include <assert.h>
#include "Log.h"
#include "Renderer.h"
#include "View.h"
#include "Window.h"

Go to the source code of this file.

Macros
#define	_Class   _Renderer

Functions
Class *	_Renderer (void)
static void	beginFrame (Renderer *self)
static GLuint	createTexture (const Renderer *self, const SDL_Surface *surface)
static void	drawLine (const Renderer *self, const SDL_Point *points)
static void	drawLines (const Renderer *self, const SDL_Point *points, size_t count)
static void	drawRect (const Renderer *self, const SDL_Rect *rect)
static void	drawRectFilled (const Renderer *self, const SDL_Rect *rect)
static void	drawTexture (const Renderer *self, GLuint texture, const SDL_Rect *rect)
static void	drawView (Renderer *self, View *view)
static void	endFrame (Renderer *self)
static Renderer *	init (Renderer *self)
static void	initialize (Class *clazz)
static void	renderDeviceDidReset (Renderer *self)
static void	renderDeviceWillReset (Renderer *self)
static void	setClippingFrame (Renderer *self, const SDL_Rect *clippingFrame)
static void	setDrawColor (Renderer *self, const SDL_Color *color)

Macro Definition Documentation

_Class

#define _Class   _Renderer

Definition at line 31 of file Renderer.c.

Function Documentation

_Renderer()

Class * _Renderer

(

void

)

Definition at line 312 of file Renderer.c.

                       {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "Renderer",
            .superclass = _Object(),
            .instanceSize = sizeof(Renderer),
            .interfaceOffset = offsetof(Renderer, interface),
            .interfaceSize = sizeof(RendererInterface),
            .initialize = initialize,
        });
    });
 
    return clazz;
}

beginFrame()

static void beginFrame ( Renderer *  self )

static

Definition at line 39 of file Renderer.c.

                                       {
 
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    glEnable(GL_SCISSOR_TEST);
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
    $(self, setDrawColor, &Colors.White);
}

createTexture()

static GLuint createTexture ( const Renderer *  self, const SDL_Surface *  surface  )

static

Definition at line 56 of file Renderer.c.

                                                                              {
 
    assert(surface);
 
    GLenum format;
    switch (surface->format->BytesPerPixel) {
        case 1:
            format = GL_LUMINANCE;
            break;
        case 3:
            format = GL_RGB;
            break;
        case 4:
            format = GL_RGBA;
            break;
        default:
            MVC_LogError("Invalid surface format: %s\n", SDL_GetPixelFormatName(surface->format->format));
            return 0;
    }
 
    GLuint texture;
    glGenTextures(1, &texture);
 
    glBindTexture(GL_TEXTURE_2D, texture);
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
 
    glTexImage2D(GL_TEXTURE_2D, 0, format, surface->w, surface->h, 0, format, GL_UNSIGNED_BYTE, surface->pixels);
 
    return texture;
}

drawLine()

static void drawLine ( const Renderer *  self, const SDL_Point *  points  )

static

Definition at line 94 of file Renderer.c.

                                                                    {
 
    assert(points);
 
    $(self, drawLines, points, 2);
}

drawLines()

static void drawLines ( const Renderer *  self, const SDL_Point *  points, size_t  count  )

static

Definition at line 105 of file Renderer.c.

                                                                                   {
 
    assert(points);
 
    glVertexPointer(2, GL_INT, 0, points);
 
    glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
}

drawRect()

static void drawRect ( const Renderer *  self, const SDL_Rect *  rect  )

static

Definition at line 118 of file Renderer.c.

                                                                 {
 
    assert(rect);
 
    GLint verts[8];
 
    verts[0] = rect->x;
    verts[1] = rect->y;
 
    verts[2] = rect->x + rect->w;
    verts[3] = rect->y;
 
    verts[4] = rect->x + rect->w;
    verts[5] = rect->y + rect->h;
 
    verts[6] = rect->x;
    verts[7] = rect->y + rect->h;
 
    glVertexPointer(2, GL_INT, 0, verts);
    glDrawArrays(GL_LINE_LOOP, 0, 4);
}

drawRectFilled()

static void drawRectFilled ( const Renderer *  self, const SDL_Rect *  rect  )

static

Definition at line 144 of file Renderer.c.

                                                                       {
 
    assert(rect);
 
    glRecti(rect->x - 1, rect->y - 1, rect->x + rect->w + 1, rect->y + rect->h + 1);
}

drawTexture()

static void drawTexture ( const Renderer *  self, GLuint  texture, const SDL_Rect *  rect  )

static

Definition at line 155 of file Renderer.c.

                                                                                    {
 
    assert(rect);
 
    const GLfloat texcoords[] = {
        0.0, 0.0,
        1.0, 0.0,
        1.0, 1.0,
        0.0, 1.0
    };
 
    GLint verts[8];
 
    verts[0] = rect->x;
    verts[1] = rect->y;
 
    verts[2] = rect->x + rect->w;
    verts[3] = rect->y;
 
    verts[4] = rect->x + rect->w;
    verts[5] = rect->y + rect->h;
 
    verts[6] = rect->x;
    verts[7] = rect->y + rect->h;
 
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
 
    glVertexPointer(2, GL_INT, 0, verts);
    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
 
    glDrawArrays(GL_QUADS, 0, 4);
 
    glDisable(GL_TEXTURE_2D);
}

drawView()

static void drawView ( Renderer *  self, View *  view  )

static

Definition at line 195 of file Renderer.c.

                                                 {
 
    assert(view);
 
    const SDL_Rect clippingFrame = $(view, clippingFrame);
    if (clippingFrame.w && clippingFrame.h) {
 
        $(self, setClippingFrame, &clippingFrame);
 
        $(view, render, self);
    }
}

endFrame()

static void endFrame ( Renderer *  self )

static

Definition at line 212 of file Renderer.c.

                                     {
 
    $(self, setDrawColor, &Colors.White);
 
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 
    $(self, setClippingFrame, NULL);
 
    glDisable(GL_SCISSOR_TEST);
 
    glBlendFunc(GL_ONE, GL_ZERO);
    glDisable(GL_BLEND);
 
    const GLenum err = glGetError();
    if (err) {
        MVC_LogError("GL error: %d\n", err);
    }
}

init()

static Renderer * init ( Renderer *  self )

static

Definition at line 236 of file Renderer.c.

                                      {
    return (Renderer *) super(Object, self, init);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 290 of file Renderer.c.

                                     {
    
    ((RendererInterface *) clazz->interface)->beginFrame = beginFrame;
    ((RendererInterface *) clazz->interface)->createTexture = createTexture;
    ((RendererInterface *) clazz->interface)->drawLine = drawLine;
    ((RendererInterface *) clazz->interface)->drawLines = drawLines;
    ((RendererInterface *) clazz->interface)->drawRect = drawRect;
    ((RendererInterface *) clazz->interface)->drawRectFilled = drawRectFilled;
    ((RendererInterface *) clazz->interface)->drawTexture = drawTexture;
    ((RendererInterface *) clazz->interface)->drawView = drawView;
    ((RendererInterface *) clazz->interface)->endFrame = endFrame;
    ((RendererInterface *) clazz->interface)->init = init;
    ((RendererInterface *) clazz->interface)->renderDeviceDidReset = renderDeviceDidReset;
    ((RendererInterface *) clazz->interface)->renderDeviceWillReset = renderDeviceWillReset;
    ((RendererInterface *) clazz->interface)->setClippingFrame = setClippingFrame;
    ((RendererInterface *) clazz->interface)->setDrawColor = setDrawColor;
}

renderDeviceDidReset()

static void renderDeviceDidReset ( Renderer *  self )

static

Definition at line 244 of file Renderer.c.

                                                 {
 
}

renderDeviceWillReset()

static void renderDeviceWillReset ( Renderer *  self )

static

Definition at line 252 of file Renderer.c.

                                                  {
 
}

setClippingFrame()

static void setClippingFrame ( Renderer *  self, const SDL_Rect *  clippingFrame  )

static

Definition at line 260 of file Renderer.c.

                                                                            {
 
    SDL_Window *window = SDL_GL_GetCurrentWindow();
 
    SDL_Rect rect;
    if (clippingFrame) {
        rect = *clippingFrame;
    } else {
        rect = MakeRect(0, 0, 0, 0);
        SDL_GL_GetDrawableSize(window, &rect.w, &rect.h);
    }
 
    const SDL_Rect scissor = MVC_TransformToWindow(window, &rect);
 
    glScissor(scissor.x - 1, scissor.y - 1, scissor.w + 2, scissor.h + 2);
}

setDrawColor()

static void setDrawColor ( Renderer *  self, const SDL_Color *  color  )

static

Definition at line 281 of file Renderer.c.

                                                                 {
    glColor4ubv((const GLubyte *) color);
}