Renderer.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <Objectively/Vector.h>
#include <ObjectivelyGPU/CopyPass.h>
#include <ObjectivelyGPU/Mathlib.h>
#include <ObjectivelyGPU/RenderPass.h>
#include "Renderer.h"
#include "View.h"
#include "Window.h"
#include "../Assets/Renderer.frag.dxil.h"
#include "../Assets/Renderer.frag.metal.h"
#include "../Assets/Renderer.frag.spv.h"
#include "../Assets/Renderer.vert.dxil.h"
#include "../Assets/Renderer.vert.metal.h"
#include "../Assets/Renderer.vert.spv.h"

Go to the source code of this file.

Macros
#define	_Class   _Renderer

Functions
Class *	_Renderer (void)
static void	beginFrame (Renderer *self)
static void	beginFrameWith (Renderer *self, CommandBuffer *commands, Framebuffer *framebuffer)
static void	dealloc (Object *self)
static void	drawLine (const Renderer *self, const SDL_Point *points, const SDL_Color *color)
static void	drawLines (const Renderer *self, const SDL_Point *points, size_t count, const SDL_Color *color)
static void	drawRect (const Renderer *self, const SDL_Rect *rect, const SDL_Color *color)
static void	drawRectFilled (const Renderer *self, const SDL_Rect *rect, const SDL_Color *color)
static void	drawTexture (const Renderer *self, Texture *texture, const SDL_Rect *rect, const SDL_Color *color)
static void	drawView (Renderer *self, View *view)
static void	endFrame (Renderer *self)
static void	initialize (Class *clazz)
static Renderer *	initWithDevice (Renderer *self, RenderDevice *device)
static void	pushDrawArrays (const Renderer *self, const MVC_Vertex *verts, size_t count, Texture *texture, const SDL_Color *color)
static void	renderDeviceDidReset (Renderer *self)
static void	renderDeviceWillReset (Renderer *self)
static void	setClippingFrame (Renderer *self, const SDL_Rect *clippingFrame)
static Data *	shaderResourceProvider (const char *name)
	ResourceProvider for loading shaders from xxd headers.

Macro Definition Documentation

_Class

#define _Class   _Renderer

Definition at line 68 of file Renderer.c.

Function Documentation

_Renderer()

Class * _Renderer

(

void

)

Definition at line 549 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 100 of file Renderer.c.

                                       {
  $(self, beginFrameWith, self->device->commands, self->device->framebuffer);
}

beginFrameWith()

static void beginFrameWith ( Renderer *  self, CommandBuffer *  commands, Framebuffer *  framebuffer  )

static

Definition at line 108 of file Renderer.c.

                                                                                              {
 
  assert(commands);
  assert(framebuffer);
 
  self->commands = commands;
  self->framebuffer = framebuffer;
 
  $(self->vertices, removeAll);
  $(self->drawArrays, removeAll);
 
  self->scissor = MakeRect(0, 0, framebuffer->size.w, framebuffer->size.h);
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 75 of file Renderer.c.

                                  {
 
  Renderer *this = (Renderer *) self;
 
  this->commands = NULL;
 
  release(this->white);
  release(this->sampler);
  release(this->vertexBuffer);
  release(this->transferBuffer);
  release(this->pipeline);
 
  release(this->vertices);
  release(this->drawArrays);
  release(this->device);
 
  super(Object, self, dealloc);
}

drawLine()

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

static

Definition at line 126 of file Renderer.c.

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

drawLines()

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

static

Definition at line 137 of file Renderer.c.

                                                                                                           {
 
  assert(points);
  assert(color);
 
  if (count < 2) {
    return;
  }
 
  const size_t segCount = count - 1;
  MVC_Vertex *verts = malloc(segCount * 6 * sizeof(MVC_Vertex));
  assert(verts);
 
  for (size_t i = 0; i < segCount; i++) {
    const float ax = (float) points[i].x,     ay = (float) points[i].y;
    const float bx = (float) points[i+1].x,   by = (float) points[i+1].y;
 
    const float dx = bx - ax, dy = by - ay;
    const float len = sqrtf(dx * dx + dy * dy);
 
    float nx = 0.0f, ny = 0.0f;
    if (len > 0.001f) {
      nx = (-dy / len) * 0.5f;
      ny = ( dx / len) * 0.5f;
    }
 
    MVC_Vertex *v = &verts[i * 6];
    v[0] = (MVC_Vertex) { { { ax - nx, ay - ny } }, { { 0.0f, 0.0f } }, { 0 } };
    v[1] = (MVC_Vertex) { { { ax + nx, ay + ny } }, { { 0.0f, 0.0f } }, { 0 } };
    v[2] = (MVC_Vertex) { { { bx - nx, by - ny } }, { { 0.0f, 0.0f } }, { 0 } };
    v[3] = (MVC_Vertex) { { { ax + nx, ay + ny } }, { { 0.0f, 0.0f } }, { 0 } };
    v[4] = (MVC_Vertex) { { { bx + nx, by + ny } }, { { 0.0f, 0.0f } }, { 0 } };
    v[5] = (MVC_Vertex) { { { bx - nx, by - ny } }, { { 0.0f, 0.0f } }, { 0 } };
  }
 
  $(self, pushDrawArrays, verts, segCount * 6, NULL, color);
 
  free(verts);
}

drawRect()

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

static

Definition at line 181 of file Renderer.c.

                                                                                         {
 
  assert(rect);
 
  const SDL_Point points[5] = {
    { rect->x,           rect->y           },
    { rect->x + rect->w, rect->y           },
    { rect->x + rect->w, rect->y + rect->h },
    { rect->x,           rect->y + rect->h },
    { rect->x,           rect->y           },
  };
 
  $(self, drawLines, points, 5, color);
}

drawRectFilled()

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

static

Definition at line 200 of file Renderer.c.

                                                                                               {
 
  assert(rect);
 
  const float x1 = (float) rect->x,           y1 = (float) rect->y;
  const float x2 = (float) rect->x + rect->w, y2 = (float) rect->y + rect->h;
 
  const MVC_Vertex verts[6] = {
    { { { x1, y1 } }, { { 0.0f, 0.0f } }, { 0 } },
    { { { x2, y1 } }, { { 0.0f, 0.0f } }, { 0 } },
    { { { x1, y2 } }, { { 0.0f, 0.0f } }, { 0 } },
    { { { x2, y1 } }, { { 0.0f, 0.0f } }, { 0 } },
    { { { x2, y2 } }, { { 0.0f, 0.0f } }, { 0 } },
    { { { x1, y2 } }, { { 0.0f, 0.0f } }, { 0 } },
  };
 
  $(self, pushDrawArrays, verts, 6, NULL, color);
}

drawTexture()

static void drawTexture ( const Renderer *  self, Texture *  texture, const SDL_Rect *  rect, const SDL_Color *  color  )

static

Definition at line 223 of file Renderer.c.

                                                                                                              {
 
  assert(rect);
 
  const float x1 = (float) rect->x,           y1 = (float) rect->y;
  const float x2 = (float) rect->x + rect->w, y2 = (float) rect->y + rect->h;
 
  const MVC_Vertex verts[6] = {
    { { { x1, y1 } }, { { 0.0f, 0.0f } }, { 0 } },
    { { { x2, y1 } }, { { 1.0f, 0.0f } }, { 0 } },
    { { { x1, y2 } }, { { 0.0f, 1.0f } }, { 0 } },
    { { { x2, y1 } }, { { 1.0f, 0.0f } }, { 0 } },
    { { { x2, y2 } }, { { 1.0f, 1.0f } }, { 0 } },
    { { { x1, y2 } }, { { 0.0f, 1.0f } }, { 0 } },
  };
 
  $(self, pushDrawArrays, verts, 6, texture, color);
}

drawView()

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

static

Definition at line 246 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 261 of file Renderer.c.

                                     {
 
  Framebuffer *framebuffer = self->framebuffer;
  assert(framebuffer);
 
  const SDL_GPUColorTargetInfo colorTarget = $(framebuffer, colorTargetInfo, 0, SDL_GPU_LOADOP_LOAD, SDL_GPU_STOREOP_STORE);
 
  const size_t vertexCount = self->vertices->count;
 
  CopyPass *copyPass = $(self->commands, beginCopyPass);
 
  if (vertexCount > 0) {
    const Uint32 vertexSize = (Uint32) (vertexCount * sizeof(MVC_Vertex));
 
    if (vertexCount > self->vertexBufferCapacity) {
      release(self->vertexBuffer);
      self->vertexBuffer = $(self->device, createBuffer, &(SDL_GPUBufferCreateInfo) {
        .usage = SDL_GPU_BUFFERUSAGE_VERTEX,
        .size = vertexSize
      });
 
      release(self->transferBuffer);
      self->transferBuffer = $(self->device, createTransferBuffer, &(SDL_GPUTransferBufferCreateInfo) {
        .usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD,
        .size = vertexSize,
      });
 
      self->vertexBufferCapacity = (Uint32) vertexCount;
    }
 
    $(self->transferBuffer, write, self->vertices->elements, vertexSize, true);
 
    $(copyPass, uploadBuffer,
      &(SDL_GPUTransferBufferLocation) { .transfer_buffer = self->transferBuffer->buffer },
      &(SDL_GPUBufferRegion) { .buffer = self->vertexBuffer->buffer, .size = vertexSize },
      true);
  }
 
  release(copyPass);
 
  RenderPass *renderPass = $(self->commands, beginRenderPass, &colorTarget, 1, NULL);
 
  $(renderPass, setViewport, &(SDL_GPUViewport){
    .x = 0.0f, .y = 0.0f,
    .w = (float) framebuffer->size.w, .h = (float) framebuffer->size.h,
    .min_depth = 0.0f, .max_depth = 1.0f,
  });
 
  int winW, winH;
  SDL_GetWindowSize(self->device->window, &winW, &winH);
  const mat4 projection = mat4_ortho(0.f, (float) winW, (float) winH, 0.f, -1.f, 1.f);
  $(self->commands, pushVertexUniformData, 0, projection.f, sizeof(projection));
 
  $(renderPass, bindPipeline, self->pipeline);
  $(renderPass, bindVertexBuffers, 0, &(SDL_GPUBufferBinding) { .buffer = self->vertexBuffer->buffer }, 1);
 
  for (size_t i = 0; i < self->drawArrays->count; i++) {
    const MVC_DrawArrays *draw = VectorElement(self->drawArrays, MVC_DrawArrays, i);
 
    $(renderPass, setScissor, &draw->scissor);
 
    $(renderPass, bindFragmentSamplers, 0, &(SDL_GPUTextureSamplerBinding) {
      .texture = draw->texture->texture, .sampler = self->sampler->sampler,
    }, 1);
 
    $(renderPass, drawPrimitives, draw->vertexCount, 1, draw->firstVertex, 0);
  }
 
  release(renderPass);
 
  self->commands = NULL;
  self->framebuffer = NULL;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 523 of file Renderer.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
  ((RendererInterface *) clazz->interface)->beginFrame = beginFrame;
  ((RendererInterface *) clazz->interface)->beginFrameWith = beginFrameWith;
  ((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)->initWithDevice = initWithDevice;
  ((RendererInterface *) clazz->interface)->pushDrawArrays = pushDrawArrays;
  ((RendererInterface *) clazz->interface)->renderDeviceDidReset = renderDeviceDidReset;
  ((RendererInterface *) clazz->interface)->renderDeviceWillReset = renderDeviceWillReset;
  ((RendererInterface *) clazz->interface)->setClippingFrame = setClippingFrame;
 
  $$(Resource, addResourceProvider, shaderResourceProvider);
}

initWithDevice()

static Renderer * initWithDevice ( Renderer *  self, RenderDevice *  device  )

static

Definition at line 339 of file Renderer.c.

                                                                      {
 
  self = (Renderer *) super(Object, self, init);
  if (self) {
    self->device = retain(device);
    assert(self->device);
 
    self->vertices = $(alloc(Vector), initWithSize, sizeof(MVC_Vertex));
    assert(self->vertices);
 
    self->drawArrays = $(alloc(Vector), initWithSize, sizeof(MVC_DrawArrays));
    assert(self->drawArrays);
  }
 
  return self;
}

pushDrawArrays()

static void pushDrawArrays ( const Renderer *  self, const MVC_Vertex *  verts, size_t  count, Texture *  texture, const SDL_Color *  color  )

static

Definition at line 360 of file Renderer.c.

                                                                                                                                  {
 
  assert(verts);
  assert(color);
 
  const MVC_DrawArrays draw = {
    .firstVertex = (Uint32) self->vertices->count,
    .vertexCount = (Uint32) count,
    .texture     = texture ? texture : self->white,
    .scissor     = self->scissor,
  };
 
  for (size_t i = 0; i < count; i++) {
    MVC_Vertex v = verts[i];
    v.color = *color;
    $(self->vertices, add, &v);
  }
 
  $(self->drawArrays, add, (MVC_DrawArrays *) &draw);
}

renderDeviceDidReset()

static void renderDeviceDidReset ( Renderer *  self )

static

Definition at line 385 of file Renderer.c.

                                                 {
 
  Shader *vertexShader = $(self->device, loadShader, "Renderer.vert", &(SDL_GPUShaderCreateInfo) {
    .stage = SDL_GPU_SHADERSTAGE_VERTEX,
    .num_uniform_buffers = 1,
  });
 
  Shader *fragmentShader = $(self->device, loadShader, "Renderer.frag", &(SDL_GPUShaderCreateInfo) {
    .stage = SDL_GPU_SHADERSTAGE_FRAGMENT,
    .num_samplers = 1,
  });
 
  const SDL_GPUVertexBufferDescription vertexBufferInfo = {
    .slot = 0,
    .pitch = sizeof(MVC_Vertex),
    .input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX,
    .instance_step_rate = 0,
  };
 
  const SDL_GPUColorTargetDescription colorTarget = {
    .format = $(self->device, getSwapchainTextureFormat),
    .blend_state = {
      .enable_blend = true,
      .color_blend_op = SDL_GPU_BLENDOP_ADD,
      .alpha_blend_op = SDL_GPU_BLENDOP_ADD,
      .src_color_blendfactor = SDL_GPU_BLENDFACTOR_SRC_ALPHA,
      .dst_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA,
      .src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE,
      .dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA,
    },
  };
 
  const SDL_GPUGraphicsPipelineCreateInfo pipelineInfo = {
    .vertex_shader = vertexShader->shader,
    .fragment_shader = fragmentShader->shader,
    .vertex_input_state = {
      .vertex_buffer_descriptions = &vertexBufferInfo,
      .num_vertex_buffers = 1,
      .vertex_attributes = (SDL_GPUVertexAttribute[]) {
        {
          .location = 0,
          .buffer_slot = 0,
          .format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2,
          .offset = offsetof(MVC_Vertex, position)
        },
        {
          .location = 1,
          .buffer_slot = 0,
          .format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2,
          .offset = offsetof(MVC_Vertex, uv)
        },
        {
          .location = 2,
          .buffer_slot = 0,
          .format = SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM,
          .offset = offsetof(MVC_Vertex, color)
        },
      },
      .num_vertex_attributes = 3,
    },
    .primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST,
    .rasterizer_state = {
      .fill_mode = SDL_GPU_FILLMODE_FILL,
      .cull_mode = SDL_GPU_CULLMODE_NONE,
      .front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE,
    },
    .target_info = {
      .color_target_descriptions = &colorTarget,
      .num_color_targets = 1,
    },
  };
 
  self->pipeline = $(self->device, createGraphicsPipeline, &pipelineInfo);
 
  release(vertexShader);
  release(fragmentShader);
 
  self->sampler = $(self->device, createSampler, &(const SDL_GPUSamplerCreateInfo) {
    .min_filter = SDL_GPU_FILTER_LINEAR,
    .mag_filter = SDL_GPU_FILTER_LINEAR,
    .mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_LINEAR,
    .address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE,
    .address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE,
    .address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE,
  });
 
  const Uint8 white[4] = { 255, 255, 255, 255 };
 
  self->white = $(self->device, createTexture, &(const SDL_GPUTextureCreateInfo) {
    .type = SDL_GPU_TEXTURETYPE_2D,
    .format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM,
    .usage = SDL_GPU_TEXTUREUSAGE_SAMPLER,
    .width = 1,
    .height = 1,
    .layer_count_or_depth = 1,
    .num_levels = 1,
  }, white);
}

renderDeviceWillReset()

static void renderDeviceWillReset ( Renderer *  self )

static

Definition at line 488 of file Renderer.c.

                                                  {
 
  self->commands = NULL;
 
  self->white = release(self->white);
  self->sampler = release(self->sampler);
 
  self->vertexBuffer = release(self->vertexBuffer);
  self->transferBuffer = release(self->transferBuffer);
  self->vertexBufferCapacity = 0;
 
  self->pipeline = release(self->pipeline);
 
  $(self->vertices, removeAll);
  $(self->drawArrays, removeAll);
}

setClippingFrame()

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

static

Definition at line 509 of file Renderer.c.

                                                                            {
 
  if (clippingFrame) {
    self->scissor = MVC_TransformToWindow(self->device->window, clippingFrame);
  } else {
    self->scissor = MakeRect(0, 0, self->framebuffer->size.w, self->framebuffer->size.h);
  }
}

shaderResourceProvider()

static Data * shaderResourceProvider ( const char *  name )

static

ResourceProvider for loading shaders from xxd headers.

Definition at line 47 of file Renderer.c.

                                                      {
 
  Data *data = NULL;
 
  if (!strcmp("Renderer.frag.dxil", name)) {
    data = $(alloc(Data), initWithConstMemory, Renderer_frag_dxil, Renderer_frag_dxil_len);
  } else if (!strcmp("Renderer.frag.metal", name)) {
    data = $(alloc(Data), initWithConstMemory, Renderer_frag_metal, Renderer_frag_metal_len);
  } else if (!strcmp("Renderer.frag.spv", name)) {
    data = $(alloc(Data), initWithConstMemory, Renderer_frag_spv, Renderer_frag_spv_len);
  } else if (!strcmp("Renderer.vert.dxil", name)) {
    data = $(alloc(Data), initWithConstMemory, Renderer_vert_dxil, Renderer_vert_dxil_len);
  } else if (!strcmp("Renderer.vert.metal", name)) {
    data = $(alloc(Data), initWithConstMemory, Renderer_vert_metal, Renderer_vert_metal_len);
  } else if (!strcmp("Renderer.vert.spv", name)) {
    data = $(alloc(Data), initWithConstMemory, Renderer_vert_spv, Renderer_vert_spv_len);
  }
 
  return data;
}