Renderer Struct Reference

Renderer extends Object with ObjectivelyMVC's UI rendering layer. More...

#include <Renderer.h>

Inheritance diagram for Renderer:

Public Member Functions
Class *	_Renderer (void)
	The Renderer archetype.
void	beginFrame (Renderer *self)
	Prepares this Renderer for a new frame using self->device's current command buffer and framebuffer.
void	beginFrameWith (Renderer *self, CommandBuffer *commands, Framebuffer *framebuffer)
	Prepares this Renderer for a new frame using the given command buffer and framebuffer.
void	drawLine (const Renderer *self, const SDL_Point *points, const SDL_Color *color)
	Records a line segment between two points.
void	drawLines (const Renderer *self, const SDL_Point *points, size_t count, const SDL_Color *color)
	Records a polyline through the given points.
void	drawRect (const Renderer *self, const SDL_Rect *rect, const SDL_Color *color)
	Records a rectangle outline.
void	drawRectFilled (const Renderer *self, const SDL_Rect *rect, const SDL_Color *color)
	Records a filled rectangle.
void	drawTexture (const Renderer *self, Texture *texture, const SDL_Rect *dest, const SDL_Color *color)
	Records a textured quad in the given destination rectangle.
void	drawView (Renderer *self, View *view)
	Sets the clipping frame and invokes View::render for the given View.
void	endFrame (Renderer *self)
	Uploads MVC vertices and executes the UI render pass into the Framebuffer given to beginFrame/beginFrameWith (LOAD_OP_LOAD).
Renderer *	initWithDevice (Renderer *self, RenderDevice *device)
	Initializes this Renderer with the given RenderDevice.
void	pushDrawArrays (const Renderer *self, const MVC_Vertex *verts, size_t count, Texture *texture, const SDL_Color *color)
	Appends raw vertices and a draw call record to the frame queue.
void	renderDeviceDidReset (Renderer *self)
	Recreates MVC GPU resources after the backing RenderDevice resets.
void	renderDeviceWillReset (Renderer *self)
	Releases MVC GPU resources before the backing RenderDevice resets.
void	setClippingFrame (Renderer *self, const SDL_Rect *clippingFrame)
	Sets the scissor rectangle for subsequent draw calls.

Data Fields
RenderDevice *	device
	The backing RenderDevice.
Object	object
	The superclass.

Protected Attributes
RendererInterface *	interface
	The interface.

Detailed Description

Renderer extends Object with ObjectivelyMVC's UI rendering layer.

Create a WindowController to instantiate a default Renderer.

Definition at line 70 of file Renderer.h.

Member Function Documentation

_Renderer()

Class * _Renderer

(

void

)

The Renderer archetype.

Returns

The Renderer Class.

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

void beginFrame

(

Renderer *

self

)

Prepares this Renderer for a new frame using self->device's current command buffer and framebuffer.

Convenience over beginFrameWith for the common case of rendering the UI into the device's own current frame. Equivalent to $(self, beginFrameWith, self->device->commands, self->device->framebuffer).

Parameters

self	The Renderer.

Definition at line 100 of file Renderer.c.

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

beginFrameWith()

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

Prepares this Renderer for a new frame using the given command buffer and framebuffer.

Parameters

self	The Renderer.
commands	The frame's CommandBuffer. The caller retains ownership and must submit and release it.
framebuffer	The target Framebuffer for this frame. Borrowed for the duration of the frame.

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

drawLine()

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

Records a line segment between two points.

Parameters

self	The Renderer.
points	Two points defining the line segment.
color	The line color.

Definition at line 126 of file Renderer.c.

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

drawLines()

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

Records a polyline through the given points.

Parameters

self	The Renderer.
points	The points.
count	The number of points.
color	The line color.

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

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

Records a rectangle outline.

Parameters

self	The Renderer.
rect	The rectangle.
color	The outline color.

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

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

Records a filled rectangle.

Parameters

self	The Renderer.
rect	The rectangle.
color	The fill color.

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

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

Records a textured quad in the given destination rectangle.

Parameters

self	The Renderer.
texture	The Texture to sample.
dest	The destination rectangle in logical screen coordinates.
color	The color multiplier (use &Colors.White for no tint).

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

void drawView	(	Renderer *	self,
		View *	view
	)

Sets the clipping frame and invokes View::render for the given View.

Parameters

self	The Renderer.
view	The View to render.

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

void endFrame

(

Renderer *

self

)

Uploads MVC vertices and executes the UI render pass into the Framebuffer given to beginFrame/beginFrameWith (LOAD_OP_LOAD).

The caller is responsible for submitting the command buffer after this returns.

Parameters

self	The Renderer.

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

initWithDevice()

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

Initializes this Renderer with the given RenderDevice.

Parameters

self	The Renderer.
device	The RenderDevice.

Returns

The initialized Renderer, or NULL on error.

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

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

Appends raw vertices and a draw call record to the frame queue.

Views that need full draw-call control can call this directly instead of going through the drawLine/drawRect/drawTexture helpers.

Parameters

self	The Renderer.
verts	The vertices to append (in logical screen coordinates).
count	The number of vertices.
texture	The texture to bind, or NULL to use the 1×1 white fallback.
color	The color multiplier applied in the fragment shader.

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

void renderDeviceDidReset

(

Renderer *

self

)

Recreates MVC GPU resources after the backing RenderDevice resets.

Parameters

self	The Renderer.

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

void renderDeviceWillReset

(

Renderer *

self

)

Releases MVC GPU resources before the backing RenderDevice resets.

Parameters

self	The Renderer.

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

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

Sets the scissor rectangle for subsequent draw calls.

Parameters

self	The Renderer.
clippingFrame	The clipping rectangle in logical screen coordinates, or NULL to disable clipping (full window scissor).

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

Field Documentation

device

RenderDevice* Renderer::device

The backing RenderDevice.

Definition at line 92 of file Renderer.h.

interface

RendererInterface* Renderer::interface

protected

The interface.

Definition at line 81 of file Renderer.h.

object

Object Renderer::object

The superclass.

Definition at line 75 of file Renderer.h.

---

The documentation for this struct was generated from the following files:

• Sources/ObjectivelyMVC/Renderer.h
• Sources/ObjectivelyMVC/Renderer.c