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	drawBevel (const Renderer *self, const SDL_Rect *rect, int radius, int width, const SDL_Color *topLeft, const SDL_Color *bottomRight)
	Records a rounded rectangle outline split diagonally into two colors.
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	drawPolygon (const Renderer *self, const SDL_Point *points, size_t count, int width, const SDL_Color *color)
	Records a closed polygon outline of the given width.
void	drawPolygonFilled (const Renderer *self, const SDL_Point *points, size_t count, int angle, const SDL_Color *from, const SDL_Color *to)
	Records a filled convex polygon, optionally with a linear gradient.
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	drawRoundedRect (const Renderer *self, const SDL_Rect *rect, int radius, int width, const SDL_Color *color)
	Records a rounded rectangle outline of the given width, drawn inside rect.
void	drawRoundedRectFilled (const Renderer *self, const SDL_Rect *rect, int radius, const SDL_Color *color)
	Records a filled rounded rectangle.
void	drawRoundedRectGradientFilled (const Renderer *self, const SDL_Rect *rect, int radius, int angle, const SDL_Color *from, const SDL_Color *to)
	Records a rounded rectangle filled with a linear gradient.
void	drawRoundedTexture (const Renderer *self, Texture *texture, const SDL_FRect *dest, int radius, const SDL_Color *color)
	Records a textured quad clipped to a rounded rectangle.
void	drawRoundedTextureRegion (const Renderer *self, Texture *texture, const SDL_Rect *src, const SDL_FRect *dest, int radius, const SDL_Color *color)
	Records a region of a texture as a quad clipped to a rounded rectangle.
void	drawTexture (const Renderer *self, Texture *texture, const SDL_FRect *dest, const SDL_Color *color)
	Records a textured quad in the given destination rectangle.
void	drawTextureRegion (const Renderer *self, Texture *texture, const SDL_Rect *src, const SDL_FRect *dest, const SDL_Color *color)
	Records a region of a texture as a 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 [0]
	The interface type.

Detailed Description

Renderer extends Object with ObjectivelyMVC's UI rendering layer.

Create a WindowController to instantiate a default Renderer.

Definition at line 75 of file Renderer.h.

Member Function Documentation

_Renderer()

Class * _Renderer

(

void

)

The Renderer archetype.

Returns

The Renderer Class.

Definition at line 890 of file Renderer.c.

                       {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name            = "Renderer",
      .superclass      = _Object(),
      .instanceSize    = sizeof(Renderer),
      .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 101 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 109 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);
}

drawBevel()

void drawBevel	(	const Renderer *	self,
		const SDL_Rect *	rect,
		int	radius,
		int	width,
		const SDL_Color *	topLeft,
		const SDL_Color *	bottomRight
	)

Records a rounded rectangle outline split diagonally into two colors.

The outline is drawn inside rect. The half above the bottom-left to top-right diagonal takes topLeft; the other half takes bottomRight.

Parameters

self	The Renderer.
rect	The rectangle.
radius	The corner radius.
width	The outline width.
topLeft	The color of the top and left edges.
bottomRight	The color of the bottom and right edges.

Definition at line 247 of file Renderer.c.

                                                                              {
 
  assert(rect);
 
  SDL_FRect frect;
  SDL_RectToFRect(rect, &frect);
 
  MVC_Vertex verts[6];
  roundedRectVertices(verts, &frect, radius, width, NULL);
 
  $(self, pushDrawArrays, verts, 3, NULL, topLeft);
  $(self, pushDrawArrays, verts + 3, 3, NULL, bottomRight);
}

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 266 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 277 of file Renderer.c.

                                                                                                           {
 
  assert(points);
  assert(color);
 
  if (count < 2) {
    return;
  }
 
  strokePolyline(self, points, count, false, 1.f, color);
}

drawPolygon()

void drawPolygon	(	const Renderer *	self,
		const SDL_Point *	points,
		size_t	count,
		int	width,
		const SDL_Color *	color
	)

Records a closed polygon outline of the given width.

The stroke is centered on each edge. Joints are not mitered, so a width well above the one or two pixels a border uses will notch at sharp corners.

Parameters

self	The Renderer.
points	The points, in order; the last is joined back to the first.
count	The number of points; fewer than three draws nothing.
width	The stroke width.
color	The outline color.

Definition at line 293 of file Renderer.c.

                                                {
 
  assert(points);
  assert(color);
 
  if (count < 3 || width < 1) {
    return;
  }
 
  strokePolyline(self, points, count, true, (float) width, color);
}

drawPolygonFilled()

void drawPolygonFilled	(	const Renderer *	self,
		const SDL_Point *	points,
		size_t	count,
		int	angle,
		const SDL_Color *	from,
		const SDL_Color *	to
	)

Records a filled convex polygon, optionally with a linear gradient.

The polygon is triangulated as a fan from its first vertex, so it MUST be convex. It is drawn without the rounded rectangle shader, and so without its anti-aliasing: diagonal edges are hard.

Parameters

self	The Renderer.
points	The points, in order.
count	The number of points; fewer than three draws nothing.
angle	The gradient angle in degrees, clockwise from south. Ignored when to is NULL.
from	The fill color, and the near color of the gradient.
to	The far color of the gradient, or NULL to fill flat with from.

Definition at line 310 of file Renderer.c.

                                                                                     {
 
  assert(points);
  assert(from);
 
  if (count < 3) {
    return;
  }
 
  SDL_FRect bounds = { (float) points[0].x, (float) points[0].y, 0.f, 0.f };
  float x2 = bounds.x, y2 = bounds.y;
 
  for (size_t i = 1; i < count; i++) {
    bounds.x = min(bounds.x, (float) points[i].x);
    bounds.y = min(bounds.y, (float) points[i].y);
    x2 = max(x2, (float) points[i].x);
    y2 = max(y2, (float) points[i].y);
  }
 
  bounds.w = x2 - bounds.x;
  bounds.h = y2 - bounds.y;
 
  // a convex polygon triangulates as a fan from its first vertex
  const size_t triangles = count - 2;
 
  MVC_Vertex verts[16 * 3];
  const size_t batchSize = lengthof(verts) / 3;
 
  for (size_t t = 0; t < triangles; ) {
 
    const size_t batch = min(triangles - t, batchSize);
 
    for (size_t i = 0; i < batch; i++, t++) {
 
      const SDL_Point *p[3] = { &points[0], &points[t + 1], &points[t + 2] };
 
      for (size_t j = 0; j < 3; j++) {
 
        const float x = (float) p[j]->x, y = (float) p[j]->y;
 
        verts[i * 3 + j] = (MVC_Vertex) { { { x, y } }, { { 0.f, 0.f } },
          to ? gradientColor(x, y, &bounds, angle, from, to) : *from
        };
      }
    }
 
    $(self, pushDrawArrays, verts, batch * 3, NULL, NULL);
  }
}

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

drawRoundedRect()

void drawRoundedRect	(	const Renderer *	self,
		const SDL_Rect *	rect,
		int	radius,
		int	width,
		const SDL_Color *	color
	)

Records a rounded rectangle outline of the given width, drawn inside rect.

Parameters

self	The Renderer.
rect	The rectangle.
radius	The corner radius.
width	The outline width.
color	The outline color.

Definition at line 407 of file Renderer.c.

                                                                                                                       {
 
  assert(rect);
 
  SDL_FRect frect;
  SDL_RectToFRect(rect, &frect);
 
  MVC_Vertex verts[6];
  roundedRectVertices(verts, &frect, radius, width, NULL);
 
  $(self, pushDrawArrays, verts, 6, NULL, color);
}

drawRoundedRectFilled()

void drawRoundedRectFilled	(	const Renderer *	self,
		const SDL_Rect *	rect,
		int	radius,
		const SDL_Color *	color
	)

Records a filled rounded rectangle.

Parameters

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

Definition at line 424 of file Renderer.c.

                                                                                                                  {
 
  assert(rect);
 
  SDL_FRect frect;
  SDL_RectToFRect(rect, &frect);
 
  MVC_Vertex verts[6];
  roundedRectVertices(verts, &frect, radius, 0, NULL);
 
  $(self, pushDrawArrays, verts, 6, NULL, color);
}

drawRoundedRectGradientFilled()

void drawRoundedRectGradientFilled	(	const Renderer *	self,
		const SDL_Rect *	rect,
		int	radius,
		int	angle,
		const SDL_Color *	from,
		const SDL_Color *	to
	)

Records a rounded rectangle filled with a linear gradient.

Parameters

self	The Renderer.
rect	The rectangle.
radius	The corner radius.
angle	The gradient angle in degrees, clockwise from south: 0 fills downwards, 90 to the right, 180 upwards.
from	The near color of the gradient.
to	The far color of the gradient.

Definition at line 441 of file Renderer.c.

                                                                                                 {
 
  assert(rect);
  assert(from);
  assert(to);
 
  SDL_FRect frect;
  SDL_RectToFRect(rect, &frect);
 
  MVC_Vertex verts[6];
  roundedRectVertices(verts, &frect, radius, 0, NULL);
 
  for (size_t i = 0; i < lengthof(verts); i++) {
    verts[i].color = gradientColor(verts[i].position.x, verts[i].position.y, &frect, angle, from, to);
  }
 
  $(self, pushDrawArrays, verts, lengthof(verts), NULL, NULL);
}

drawRoundedTexture()

void drawRoundedTexture	(	const Renderer *	self,
		Texture *	texture,
		const SDL_FRect *	dest,
		int	radius,
		const SDL_Color *	color
	)

Records a textured quad clipped to a rounded rectangle.

Parameters

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

Definition at line 465 of file Renderer.c.

                                                                                                                                  {
  $(self, drawRoundedTextureRegion, texture, NULL, dest, radius, color);
}

drawRoundedTextureRegion()

void drawRoundedTextureRegion	(	const Renderer *	self,
		Texture *	texture,
		const SDL_Rect *	src,
		const SDL_FRect *	dest,
		int	radius,
		const SDL_Color *	color
	)

Records a region of a texture as a quad clipped to a rounded rectangle.

Parameters

self	The Renderer.
texture	The Texture to sample.
src	The region of texture to sample, in texels, or NULL for all of it.
dest	The destination rectangle in logical screen coordinates.
radius	The corner radius.
color	The color multiplier (use &Colors.White for no tint).

Definition at line 473 of file Renderer.c.

                                                                                                                                                             {
 
  assert(dest);
 
  const SDL_FRect uv = textureRegion(texture, src);
 
  MVC_Vertex verts[6];
  roundedRectVertices(verts, dest, radius, 0, &uv);
 
  $(self, pushDrawArrays, verts, 6, texture, color);
}

drawTexture()

void drawTexture	(	const Renderer *	self,
		Texture *	texture,
		const SDL_FRect *	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.

Remarks

dest is a sub-pixel-precise SDL_FRect, not SDL_Rect: a caller that needs the texture drawn at its exact native resolution (e.g. Text, to avoid a fractional stretch that shifts every glyph as the string's pixel width changes) must pass an unrounded size here, since rounding it to the nearest integer logical unit first is precisely what reintroduces that stretch.

Parameters

color

The color multiplier (use &Colors.White for no tint).

Definition at line 489 of file Renderer.c.

                                                                                                               {
  $(self, drawTextureRegion, texture, NULL, dest, color);
}

drawTextureRegion()

void drawTextureRegion	(	const Renderer *	self,
		Texture *	texture,
		const SDL_Rect *	src,
		const SDL_FRect *	dest,
		const SDL_Color *	color
	)

Records a region of a texture as a quad in the given destination rectangle.

This is how an AtlasImage is drawn: src is its rect within the atlas sheet.

Parameters

self	The Renderer.
texture	The Texture to sample.
src	The region of texture to sample, in texels, or NULL for all of it.
dest	The destination rectangle in logical screen coordinates.
color	The color multiplier (use &Colors.White for no tint).

Definition at line 497 of file Renderer.c.

                                                                                                                                          {
 
  assert(dest);
 
  const float x1 = dest->x,            y1 = dest->y;
  const float x2 = dest->x + dest->w,  y2 = dest->y + dest->h;
 
  const SDL_FRect uv = textureRegion(texture, src);
 
  const float u1 = uv.x,         v1 = uv.y;
  const float u2 = uv.x + uv.w,  v2 = uv.y + uv.h;
 
  const MVC_Vertex verts[6] = {
    { { { x1, y1 } }, { { u1, v1 } }, { 0 } },
    { { { x2, y1 } }, { { u2, v1 } }, { 0 } },
    { { { x1, y2 } }, { { u1, v2 } }, { 0 } },
    { { { x2, y1 } }, { { u2, v1 } }, { 0 } },
    { { { x2, y2 } }, { { u2, v2 } }, { 0 } },
    { { { x1, y2 } }, { { u1, v2 } }, { 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.

A View whose View::clippingFrame is empty is culled. Otherwise the scissor is set to the View::clippingFrame of the nearest ancestor with clipsSubviews set, or to the full framebuffer when there is none. A View is therefore NOT clipped to its own frame: one that draws outside its bounds does so visibly, and a container that wants to clip its contents MUST set clipsSubviews.

Parameters

self	The Renderer.
view	The View to render.

Definition at line 525 of file Renderer.c.

                                                 {
 
  assert(view);
 
  const SDL_Rect clippingFrame = $(view, clippingFrame);
  if (clippingFrame.w && clippingFrame.h) {
 
    // The scissor enforces clipsSubviews, so it comes from the nearest clipping ancestor
    // rather than from this View's own frame: siblings then share a scissor, which is one of
    // the two conditions under which pushDrawArrays merges their draw calls.
    const View *superview = view->superview;
    while (superview && !superview->clipsSubviews) {
      superview = superview->superview;
    }
 
    if (superview) {
      const SDL_Rect scissor = $(superview, clippingFrame);
      $(self, setClippingFrame, &scissor);
    } else {
      $(self, setClippingFrame, NULL);
    }
 
    $(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 555 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);
 
  // the vertex buffer is created only once something has been drawn into the frame, so a
  // frame that drew nothing has none to bind
  if (vertexCount) {
 
    $(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 639 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. Consecutive calls that share both texture and the current scissor are merged into one draw call. Only the immediately preceding record is considered, so draw order matters: a quad from another texture between two same-texture quads breaks the run.

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 to apply to every vertex, or NULL to keep the colors the vertices already carry. MVC_Vertex::color is interpolated across the triangle, so NULL is how a caller draws a gradient.

Definition at line 660 of file Renderer.c.

                                                                                                                                  {
 
  assert(verts);
 
  const MVC_DrawArrays draw = {
    .firstVertex = (Uint32) self->vertices->count,
    .vertexCount = (Uint32) count,
    .texture     = texture ? texture : self->white,
    .scissor     = self->scissor,
  };
 
  Vector *vertices = self->vertices;
 
  if (vertices->count + count > vertices->capacity) {
    $(vertices, resize, max(vertices->capacity * 2, vertices->count + count));
  }
 
  MVC_Vertex *out = VectorElement(vertices, MVC_Vertex, vertices->count);
  for (size_t i = 0; i < count; i++) {
    out[i] = verts[i];
    if (color) {
      out[i].color = *color;
    }
  }
 
  vertices->count += count;
 
  // If this drawArrays is contiguous with the last one, combine them into a single call
  
  if (self->drawArrays->count) {
    MVC_DrawArrays *last = VectorElement(self->drawArrays, MVC_DrawArrays, self->drawArrays->count - 1);
    if (last->texture == draw.texture && SDL_RectsEqual(&last->scissor, &draw.scissor)) {
      last->vertexCount += draw.vertexCount;
    } else {
      $(self->drawArrays, add, (MVC_DrawArrays *) &draw);
    }
  } else {
    $(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 705 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)
        },
        {
          .location = 3,
          .buffer_slot = 0,
          .format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4,
          .offset = offsetof(MVC_Vertex, rect)
        },
        {
          .location = 4,
          .buffer_slot = 0,
          .format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2,
          .offset = offsetof(MVC_Vertex, shape)
        },
      },
      .num_vertex_attributes = 5,
    },
    .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 820 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 841 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 97 of file Renderer.h.

interface

RendererInterface* Renderer::interface[0]

protected

The interface type.

Definition at line 86 of file Renderer.h.

object

Object Renderer::object

The superclass.

Definition at line 80 of file Renderer.h.

---

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

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