Renderer.c

Go to the documentation of this file.

/*
 * ObjectivelyMVC: Object oriented MVC framework for SDL3 and C.
 * Copyright (C) 2014 Jay Dolan <jay@jaydolan.com>
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#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"
 
static Data *shaderResourceProvider(const char *name) {
 
  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;
}
 
#define _Class _Renderer
 
#pragma mark - Object
 
static void dealloc(Object *self) {
 
  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);
}
 
#pragma mark - Renderer
 
static void beginFrame(Renderer *self) {
  $(self, beginFrameWith, self->device->commands, self->device->framebuffer);
}
 
static void beginFrameWith(Renderer *self, CommandBuffer *commands, Framebuffer *framebuffer) {
 
  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);
}
 
static void drawLine(const Renderer *self, const SDL_Point *points, const SDL_Color *color) {
 
  assert(points);
 
  $(self, drawLines, points, 2, color);
}
 
static void drawLines(const Renderer *self, const SDL_Point *points, size_t count, const SDL_Color *color) {
 
  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);
}
 
static void drawRect(const Renderer *self, const SDL_Rect *rect, const SDL_Color *color) {
 
  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);
}
 
static void drawRectFilled(const Renderer *self, const SDL_Rect *rect, const SDL_Color *color) {
 
  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);
}
 
static void drawTexture(const Renderer *self, Texture *texture, const SDL_Rect *rect, const SDL_Color *color) {
 
  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);
}
 
static void drawView(Renderer *self, View *view) {
 
  assert(view);
 
  const SDL_Rect clippingFrame = $(view, clippingFrame);
  if (clippingFrame.w && clippingFrame.h) {
    $(self, setClippingFrame, &clippingFrame);
    $(view, render, self);
  }
}
 
static void endFrame(Renderer *self) {
 
  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;
}
 
static Renderer *initWithDevice(Renderer *self, RenderDevice *device) {
 
  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;
}
 
static void pushDrawArrays(const Renderer *self, const MVC_Vertex *verts, size_t count, Texture *texture, const SDL_Color *color) {
 
  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);
}
 
static void renderDeviceDidReset(Renderer *self) {
 
  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);
}
 
static void renderDeviceWillReset(Renderer *self) {
 
  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);
}
 
static void setClippingFrame(Renderer *self, const SDL_Rect *clippingFrame) {
 
  if (clippingFrame) {
    self->scissor = MVC_TransformToWindow(self->device->window, clippingFrame);
  } else {
    self->scissor = MakeRect(0, 0, self->framebuffer->size.w, self->framebuffer->size.h);
  }
}
 
#pragma mark - Class lifecycle
 
static void initialize(Class *clazz) {
 
  ((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);
}
 
Class *_Renderer(void) {
  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;
}
 
#undef _Class