hmn
/
orca
5
Fork 2
Code Issues 21 Pull Requests 1 Packages Projects Releases Wiki Activity
orca/src/graphics/gl_canvas.c

1842 lines
64 KiB
C
Raw Blame History

/************************************************************/ /**
*
* @file: gl_canvas.c
* @author: Martin Fouilleul
* @date: 29/01/2023
* @revision:
*
*****************************************************************/
#include "gl_api.h"
#include "glsl_shaders.h"
#include "graphics_surface.h"
#include "util/macros.h"
typedef struct oc_gl_image
{
oc_image_data interface;
GLuint texture;
} oc_gl_image;
enum oc_gl_cmd_enum
{
OC_GL_FILL,
OC_GL_STROKE,
};
typedef int oc_gl_cmd;
typedef struct oc_gl_path
{
float uvTransform[12];
oc_vec4 color;
oc_vec4 box;
oc_vec4 clip;
oc_gl_cmd cmd;
int textureID;
u8 pad[8];
} oc_gl_path;
enum oc_gl_seg_kind_enum
{
OC_GL_LINE = 1,
OC_GL_QUADRATIC,
OC_GL_CUBIC,
};
typedef int oc_gl_seg_kind;
typedef struct oc_gl_path_elt
{
oc_vec2 p[4];
int pathIndex;
oc_gl_seg_kind kind;
} oc_gl_path_elt;
typedef struct oc_gl_dispatch_indirect_command
{
u32 num_groups_x;
u32 num_groups_y;
u32 num_groups_z;
} oc_gl_dispatch_indirect_command;
////////////////////////////////////////////////////////////
//NOTE: these are just here for the sizes...
#define OC_GL_LAYOUT_FIRST(name, type) \
OC_GL_##name##_OFFSET = 0, \
OC_GL_##name##_SIZE = OC_GL_##type##_SIZE,
#define OC_GL_LAYOUT_NEXT(name, type, prev) \
OC_GL_##name##_OFFSET = oc_align_up_pow2(OC_GL_##prev##_OFFSET + OC_GL_##prev##_SIZE, OC_GL_##type##_ALIGN), \
OC_GL_##name##_SIZE = OC_GL_##type##_SIZE,
#define OC_GL_LAYOUT_SIZE(name, last, maxAlignType) \
OC_GL_##name##_ALIGN = oc_align_up_pow2(OC_GL_##maxAlignType##_ALIGN, OC_GL_VEC4_ALIGN), \
OC_GL_##name##_SIZE = oc_align_up_pow2(OC_GL_##last##_OFFSET + OC_GL_##last##_SIZE, OC_GL_##name##_ALIGN),
enum
{
OC_GL_I32_SIZE = sizeof(i32),
OC_GL_I32_ALIGN = sizeof(i32),
OC_GL_F32_SIZE = sizeof(f32),
OC_GL_F32_ALIGN = sizeof(f32),
OC_GL_VEC2_SIZE = 2 * sizeof(f32),
OC_GL_VEC2_ALIGN = 2 * sizeof(f32),
OC_GL_VEC3_SIZE = 4 * sizeof(f32),
OC_GL_VEC3_ALIGN = 4 * sizeof(f32),
OC_GL_VEC4_SIZE = 4 * sizeof(f32),
OC_GL_VEC4_ALIGN = 4 * sizeof(f32),
OC_GL_MAT3_SIZE = 3 * 3 * OC_GL_VEC3_SIZE,
OC_GL_MAT3_ALIGN = OC_GL_VEC3_ALIGN,
OC_GL_LAYOUT_FIRST(SEGMENT_KIND, I32)
OC_GL_LAYOUT_NEXT(SEGMENT_PATH_INDEX, I32, SEGMENT_KIND)
OC_GL_LAYOUT_NEXT(SEGMENT_CONFIG, I32, SEGMENT_PATH_INDEX)
OC_GL_LAYOUT_NEXT(SEGMENT_WINDING, I32, SEGMENT_CONFIG)
OC_GL_LAYOUT_NEXT(SEGMENT_BOX, VEC4, SEGMENT_WINDING)
OC_GL_LAYOUT_NEXT(SEGMENT_IMPLICIT_MATRIX, MAT3, SEGMENT_BOX)
OC_GL_LAYOUT_NEXT(SEGMENT_HULL_VERTEX, VEC2, SEGMENT_IMPLICIT_MATRIX)
OC_GL_LAYOUT_NEXT(SEGMENT_SIGN, F32, SEGMENT_HULL_VERTEX)
OC_GL_LAYOUT_SIZE(SEGMENT, SEGMENT_SIGN, MAT3)
OC_GL_LAYOUT_FIRST(PATH_QUEUE_AREA, VEC4)
OC_GL_LAYOUT_NEXT(PATH_QUEUE_TILE_QUEUES, I32, PATH_QUEUE_AREA)
OC_GL_LAYOUT_SIZE(PATH_QUEUE, PATH_QUEUE_TILE_QUEUES, VEC4)
OC_GL_LAYOUT_FIRST(TILE_OP_KIND, I32)
OC_GL_LAYOUT_NEXT(TILE_OP_NEXT, I32, TILE_OP_KIND)
OC_GL_LAYOUT_NEXT(TILE_OP_INDEX, I32, TILE_OP_NEXT)
OC_GL_LAYOUT_NEXT(TILE_OP_WINDING, I32, TILE_OP_INDEX)
OC_GL_LAYOUT_SIZE(TILE_OP, TILE_OP_WINDING, I32)
OC_GL_LAYOUT_FIRST(TILE_QUEUE_WINDING, I32)
OC_GL_LAYOUT_NEXT(TILE_QUEUE_FIRST, I32, TILE_QUEUE_WINDING)
OC_GL_LAYOUT_NEXT(TILE_QUEUE_LAST, I32, TILE_QUEUE_FIRST)
OC_GL_LAYOUT_SIZE(TILE_QUEUE, TILE_QUEUE_LAST, I32)
OC_GL_LAYOUT_FIRST(SCREEN_TILE_COORD, VEC2)
OC_GL_LAYOUT_NEXT(SCREEN_TILE_FIRST, I32, SCREEN_TILE_COORD)
OC_GL_LAYOUT_SIZE(SCREEN_TILE, SCREEN_TILE_FIRST, VEC2)
};
enum
{
OC_GL_INPUT_BUFFERS_COUNT = 3,
OC_GL_TILE_SIZE = 16,
OC_GL_MSAA_COUNT = 8,
OC_GL_MAX_IMAGES_PER_BATCH = 8,
};
typedef struct oc_gl_mapped_buffer
{
GLuint buffer;
int size;
char* contents;
} oc_gl_mapped_buffer;
typedef struct oc_gl_canvas_backend
{
oc_canvas_backend interface;
oc_wgl_surface* surface;
int msaaCount;
oc_vec2 frameSize;
// gl stuff
GLuint vao;
GLuint pathSetup;
GLuint segmentSetup;
GLuint backprop;
GLuint merge;
GLuint balanceWorkgroups;
GLuint raster;
GLuint blit;
GLuint outTexture;
int bufferIndex;
GLsync bufferSync[OC_GL_INPUT_BUFFERS_COUNT];
oc_gl_mapped_buffer pathBuffer[OC_GL_INPUT_BUFFERS_COUNT];
oc_gl_mapped_buffer elementBuffer[OC_GL_INPUT_BUFFERS_COUNT];
GLuint segmentBuffer;
GLuint segmentCountBuffer;
GLuint pathQueueBuffer;
GLuint tileQueueBuffer;
GLuint tileQueueCountBuffer;
GLuint tileOpBuffer;
GLuint tileOpCountBuffer;
GLuint screenTilesBuffer;
GLuint screenTilesCountBuffer;
GLuint rasterDispatchBuffer;
GLuint dummyVertexBuffer;
//encoding context
int pathCount;
int eltCount;
int pathBatchStart;
int eltBatchStart;
oc_primitive* primitive;
oc_vec4 pathScreenExtents;
oc_vec4 pathUserExtents;
int maxTileQueueCount;
int maxSegmentCount;
int currentImageIndex;
} oc_gl_canvas_backend;
static void oc_update_path_extents(oc_vec4* extents, oc_vec2 p)
{
extents->x = oc_min(extents->x, p.x);
extents->y = oc_min(extents->y, p.y);
extents->z = oc_max(extents->z, p.x);
extents->w = oc_max(extents->w, p.y);
}
void oc_gl_grow_input_buffer(oc_gl_mapped_buffer* buffer, int copyStart, int copySize, int newSize)
{
oc_gl_mapped_buffer newBuffer = { 0 };
newBuffer.size = newSize;
glGenBuffers(1, &newBuffer.buffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, newBuffer.buffer);
glBufferStorage(GL_SHADER_STORAGE_BUFFER, newBuffer.size, 0, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
newBuffer.contents = glMapBufferRange(GL_SHADER_STORAGE_BUFFER,
0,
newBuffer.size,
GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_FLUSH_EXPLICIT_BIT);
memcpy(newBuffer.contents + copyStart, buffer->contents + copyStart, copySize);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer->buffer);
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
glDeleteBuffers(1, &buffer->buffer);
*buffer = newBuffer;
}
void oc_gl_canvas_encode_element(oc_gl_canvas_backend* backend, oc_path_elt_type kind, oc_vec2* p)
{
int bufferIndex = backend->bufferIndex;
int bufferCap = backend->elementBuffer[bufferIndex].size / sizeof(oc_gl_path_elt);
if(backend->eltCount >= bufferCap)
{
int newBufferCap = (int)(bufferCap * 1.5);
int newBufferSize = newBufferCap * sizeof(oc_gl_path_elt);
oc_log_info("growing element buffer to %i elements\n", newBufferCap);
oc_gl_grow_input_buffer(&backend->elementBuffer[bufferIndex],
backend->eltBatchStart * sizeof(oc_gl_path_elt),
backend->eltCount * sizeof(oc_gl_path_elt),
newBufferSize);
}
oc_gl_path_elt* elementData = (oc_gl_path_elt*)backend->elementBuffer[bufferIndex].contents;
oc_gl_path_elt* elt = &elementData[backend->eltCount];
backend->eltCount++;
elt->pathIndex = backend->pathCount - backend->pathBatchStart;
int count = 0;
switch(kind)
{
case OC_PATH_LINE:
backend->maxSegmentCount += 1;
elt->kind = OC_GL_LINE;
count = 2;
break;
case OC_PATH_QUADRATIC:
backend->maxSegmentCount += 3;
elt->kind = OC_GL_QUADRATIC;
count = 3;
break;
case OC_PATH_CUBIC:
backend->maxSegmentCount += 7;
elt->kind = OC_GL_CUBIC;
count = 4;
break;
default:
break;
}
for(int i = 0; i < count; i++)
{
oc_update_path_extents(&backend->pathUserExtents, p[i]);
oc_vec2 screenP = oc_mat2x3_mul(backend->primitive->attributes.transform, p[i]);
elt->p[i] = (oc_vec2){ screenP.x, screenP.y };
oc_update_path_extents(&backend->pathScreenExtents, screenP);
}
}
void oc_gl_canvas_encode_path(oc_gl_canvas_backend* backend, oc_primitive* primitive, f32 scale)
{
int bufferIndex = backend->bufferIndex;
int bufferCap = backend->pathBuffer[bufferIndex].size / sizeof(oc_gl_path);
if(backend->pathCount >= bufferCap)
{
int newBufferCap = (int)(bufferCap * 1.5);
int newBufferSize = newBufferCap * sizeof(oc_gl_path);
oc_log_info("growing path buffer to %i elements\n", newBufferCap);
oc_gl_grow_input_buffer(&backend->pathBuffer[bufferIndex],
backend->pathBatchStart * sizeof(oc_gl_path),
backend->eltCount * sizeof(oc_gl_path),
newBufferSize);
}
oc_gl_path* pathData = (oc_gl_path*)backend->pathBuffer[backend->bufferIndex].contents;
oc_gl_path* path = &pathData[backend->pathCount];
backend->pathCount++;
path->cmd = (oc_gl_cmd)primitive->cmd;
path->box = (oc_vec4){
backend->pathScreenExtents.x,
backend->pathScreenExtents.y,
backend->pathScreenExtents.z,
backend->pathScreenExtents.w
};
path->clip = (oc_vec4){
primitive->attributes.clip.x,
primitive->attributes.clip.y,
primitive->attributes.clip.x + primitive->attributes.clip.w,
primitive->attributes.clip.y + primitive->attributes.clip.h
};
path->color = (oc_vec4){
primitive->attributes.color.r,
primitive->attributes.color.g,
primitive->attributes.color.b,
primitive->attributes.color.a
};
oc_rect srcRegion = primitive->attributes.srcRegion;
oc_rect destRegion = {
backend->pathUserExtents.x,
backend->pathUserExtents.y,
backend->pathUserExtents.z - backend->pathUserExtents.x,
backend->pathUserExtents.w - backend->pathUserExtents.y
};
if(!oc_image_is_nil(primitive->attributes.image))
{
oc_vec2 texSize = oc_image_size(primitive->attributes.image);
oc_mat2x3 srcRegionToImage = {
1 / texSize.x, 0, srcRegion.x / texSize.x,
0, 1 / texSize.y, srcRegion.y / texSize.y
};
oc_mat2x3 destRegionToSrcRegion = {
srcRegion.w / destRegion.w, 0, 0,
0, srcRegion.h / destRegion.h, 0
};
oc_mat2x3 userToDestRegion = {
1, 0, -destRegion.x,
0, 1, -destRegion.y
};
oc_mat2x3 screenToUser = oc_mat2x3_inv(primitive->attributes.transform);
oc_mat2x3 uvTransform = srcRegionToImage;
uvTransform = oc_mat2x3_mul_m(uvTransform, destRegionToSrcRegion);
uvTransform = oc_mat2x3_mul_m(uvTransform, userToDestRegion);
uvTransform = oc_mat2x3_mul_m(uvTransform, screenToUser);
//NOTE: mat3 std430 layout is an array of oc_vec3, which are padded to _oc_vec4_ alignment
path->uvTransform[0] = uvTransform.m[0] / scale;
path->uvTransform[1] = uvTransform.m[3] / scale;
path->uvTransform[2] = 0;
path->uvTransform[3] = 0;
path->uvTransform[4] = uvTransform.m[1] / scale;
path->uvTransform[5] = uvTransform.m[4] / scale;
path->uvTransform[6] = 0;
path->uvTransform[7] = 0;
path->uvTransform[8] = uvTransform.m[2];
path->uvTransform[9] = uvTransform.m[5];
path->uvTransform[10] = 1;
path->uvTransform[11] = 0;
path->textureID = backend->currentImageIndex;
}
else
{
path->textureID = -1;
}
int firstTileX = path->box.x * scale / OC_GL_TILE_SIZE;
int firstTileY = path->box.y * scale / OC_GL_TILE_SIZE;
int lastTileX = path->box.z * scale / OC_GL_TILE_SIZE;
int lastTileY = path->box.w * scale / OC_GL_TILE_SIZE;
int nTilesX = lastTileX - firstTileX + 1;
int nTilesY = lastTileY - firstTileY + 1;
backend->maxTileQueueCount += (nTilesX * nTilesY);
}
static bool oc_intersect_hull_legs(oc_vec2 p0, oc_vec2 p1, oc_vec2 p2, oc_vec2 p3, oc_vec2* intersection)
{
/*NOTE: check intersection of lines (p0-p1) and (p2-p3)
P = p0 + u(p1-p0)
P = p2 + w(p3-p2)
*/
bool found = false;
f32 den = (p0.x - p1.x) * (p2.y - p3.y) - (p0.y - p1.y) * (p2.x - p3.x);
if(fabs(den) > 0.0001)
{
f32 u = ((p0.x - p2.x) * (p2.y - p3.y) - (p0.y - p2.y) * (p2.x - p3.x)) / den;
f32 w = ((p0.x - p2.x) * (p0.y - p1.y) - (p0.y - p2.y) * (p0.x - p1.x)) / den;
intersection->x = p0.x + u * (p1.x - p0.x);
intersection->y = p0.y + u * (p1.y - p0.y);
found = true;
}
return (found);
}
static bool oc_offset_hull(int count, oc_vec2* p, oc_vec2* result, f32 offset)
{
//NOTE: we should have no more than two coincident points here. This means the leg between
// those two points can't be offset, but we can set a double point at the start of first leg,
// end of first leg, or we can join the first and last leg to create a missing middle one
oc_vec2 legs[3][2] = { 0 };
bool valid[3] = { 0 };
for(int i = 0; i < count - 1; i++)
{
oc_vec2 n = { p[i].y - p[i + 1].y,
p[i + 1].x - p[i].x };
f32 norm = sqrt(n.x * n.x + n.y * n.y);
if(norm >= 1e-6)
{
n = oc_vec2_mul(offset / norm, n);
legs[i][0] = oc_vec2_add(p[i], n);
legs[i][1] = oc_vec2_add(p[i + 1], n);
valid[i] = true;
}
}
//NOTE: now we find intersections
// first point is either the start of the first or second leg
if(valid[0])
{
result[0] = legs[0][0];
}
else
{
OC_ASSERT(valid[1]);
result[0] = legs[1][0];
}
for(int i = 1; i < count - 1; i++)
{
//NOTE: we're computing the control point i, at the end of leg (i-1)
if(!valid[i - 1])
{
OC_ASSERT(valid[i]);
result[i] = legs[i][0];
}
else if(!valid[i])
{
OC_ASSERT(valid[i - 1]);
result[i] = legs[i - 1][0];
}
else
{
if(!oc_intersect_hull_legs(legs[i - 1][0], legs[i - 1][1], legs[i][0], legs[i][1], &result[i]))
{
// legs don't intersect.
return (false);
}
}
}
if(valid[count - 2])
{
result[count - 1] = legs[count - 2][1];
}
else
{
OC_ASSERT(valid[count - 3]);
result[count - 1] = legs[count - 3][1];
}
return (true);
}
static oc_vec2 oc_quadratic_get_point(oc_vec2 p[3], f32 t)
{
oc_vec2 r;
f32 oneMt = 1 - t;
f32 oneMt2 = oc_square(oneMt);
f32 t2 = oc_square(t);
r.x = oneMt2 * p[0].x + 2 * oneMt * t * p[1].x + t2 * p[2].x;
r.y = oneMt2 * p[0].y + 2 * oneMt * t * p[1].y + t2 * p[2].y;
return (r);
}
static void oc_quadratic_split(oc_vec2 p[3], f32 t, oc_vec2 outLeft[3], oc_vec2 outRight[3])
{
//NOTE(martin): split bezier curve p at parameter t, using De Casteljau's algorithm
// the q_n are the points along the hull's segments at parameter t
// s is the split point.
f32 oneMt = 1 - t;
oc_vec2 q0 = { oneMt * p[0].x + t * p[1].x,
oneMt * p[0].y + t * p[1].y };
oc_vec2 q1 = { oneMt * p[1].x + t * p[2].x,
oneMt * p[1].y + t * p[2].y };
oc_vec2 s = { oneMt * q0.x + t * q1.x,
oneMt * q0.y + t * q1.y };
outLeft[0] = p[0];
outLeft[1] = q0;
outLeft[2] = s;
outRight[0] = s;
outRight[1] = q1;
outRight[2] = p[2];
}
static oc_vec2 oc_cubic_get_point(oc_vec2 p[4], f32 t)
{
oc_vec2 r;
f32 oneMt = 1 - t;
f32 oneMt2 = oc_square(oneMt);
f32 oneMt3 = oneMt2 * oneMt;
f32 t2 = oc_square(t);
f32 t3 = t2 * t;
r.x = oneMt3 * p[0].x + 3 * oneMt2 * t * p[1].x + 3 * oneMt * t2 * p[2].x + t3 * p[3].x;
r.y = oneMt3 * p[0].y + 3 * oneMt2 * t * p[1].y + 3 * oneMt * t2 * p[2].y + t3 * p[3].y;
return (r);
}
static void oc_cubic_split(oc_vec2 p[4], f32 t, oc_vec2 outLeft[4], oc_vec2 outRight[4])
{
//NOTE(martin): split bezier curve p at parameter t, using De Casteljau's algorithm
// the q_n are the points along the hull's segments at parameter t
// the r_n are the points along the (q_n, q_n+1) segments at parameter t
// s is the split point.
oc_vec2 q0 = { (1 - t) * p[0].x + t * p[1].x,
(1 - t) * p[0].y + t * p[1].y };
oc_vec2 q1 = { (1 - t) * p[1].x + t * p[2].x,
(1 - t) * p[1].y + t * p[2].y };
oc_vec2 q2 = { (1 - t) * p[2].x + t * p[3].x,
(1 - t) * p[2].y + t * p[3].y };
oc_vec2 r0 = { (1 - t) * q0.x + t * q1.x,
(1 - t) * q0.y + t * q1.y };
oc_vec2 r1 = { (1 - t) * q1.x + t * q2.x,
(1 - t) * q1.y + t * q2.y };
oc_vec2 s = { (1 - t) * r0.x + t * r1.x,
(1 - t) * r0.y + t * r1.y };
;
outLeft[0] = p[0];
outLeft[1] = q0;
outLeft[2] = r0;
outLeft[3] = s;
outRight[0] = s;
outRight[1] = r1;
outRight[2] = q2;
outRight[3] = p[3];
}
void oc_gl_encode_stroke_line(oc_gl_canvas_backend* backend, oc_vec2* p)
{
f32 width = backend->primitive->attributes.width;
oc_vec2 v = { p[1].x - p[0].x, p[1].y - p[0].y };
oc_vec2 n = { v.y, -v.x };
f32 norm = sqrt(n.x * n.x + n.y * n.y);
oc_vec2 offset = oc_vec2_mul(0.5 * width / norm, n);
oc_vec2 left[2] = { oc_vec2_add(p[0], offset), oc_vec2_add(p[1], offset) };
oc_vec2 right[2] = { oc_vec2_add(p[1], oc_vec2_mul(-1, offset)), oc_vec2_add(p[0], oc_vec2_mul(-1, offset)) };
oc_vec2 joint0[2] = { oc_vec2_add(p[0], oc_vec2_mul(-1, offset)), oc_vec2_add(p[0], offset) };
oc_vec2 joint1[2] = { oc_vec2_add(p[1], offset), oc_vec2_add(p[1], oc_vec2_mul(-1, offset)) };
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, right);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, left);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, joint0);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, joint1);
}
enum
{
OC_HULL_CHECK_SAMPLE_COUNT = 5
};
void oc_gl_encode_stroke_quadratic(oc_gl_canvas_backend* backend, oc_vec2* p)
{
f32 width = backend->primitive->attributes.width;
f32 tolerance = oc_min(backend->primitive->attributes.tolerance, 0.5 * width);
//NOTE: check for degenerate line case
const f32 equalEps = 1e-3;
if(oc_vec2_close(p[0], p[1], equalEps))
{
oc_gl_encode_stroke_line(backend, p + 1);
return;
}
else if(oc_vec2_close(p[1], p[2], equalEps))
{
oc_gl_encode_stroke_line(backend, p);
return;
}
oc_vec2 leftHull[3];
oc_vec2 rightHull[3];
if(!oc_offset_hull(3, p, leftHull, width / 2)
|| !oc_offset_hull(3, p, rightHull, -width / 2))
{
//TODO split and recurse
//NOTE: offsetting the hull failed, split the curve
oc_vec2 splitLeft[3];
oc_vec2 splitRight[3];
oc_quadratic_split(p, 0.5, splitLeft, splitRight);
oc_gl_encode_stroke_quadratic(backend, splitLeft);
oc_gl_encode_stroke_quadratic(backend, splitRight);
}
else
{
f32 checkSamples[OC_HULL_CHECK_SAMPLE_COUNT] = { 1. / 6, 2. / 6, 3. / 6, 4. / 6, 5. / 6 };
f32 d2LowBound = oc_square(0.5 * width - tolerance);
f32 d2HighBound = oc_square(0.5 * width + tolerance);
f32 maxOvershoot = 0;
f32 maxOvershootParameter = 0;
for(int i = 0; i < OC_HULL_CHECK_SAMPLE_COUNT; i++)
{
f32 t = checkSamples[i];
oc_vec2 c = oc_quadratic_get_point(p, t);
oc_vec2 cp = oc_quadratic_get_point(leftHull, t);
oc_vec2 cn = oc_quadratic_get_point(rightHull, t);
f32 positiveDistSquare = oc_square(c.x - cp.x) + oc_square(c.y - cp.y);
f32 negativeDistSquare = oc_square(c.x - cn.x) + oc_square(c.y - cn.y);
f32 positiveOvershoot = oc_max(positiveDistSquare - d2HighBound, d2LowBound - positiveDistSquare);
f32 negativeOvershoot = oc_max(negativeDistSquare - d2HighBound, d2LowBound - negativeDistSquare);
f32 overshoot = oc_max(positiveOvershoot, negativeOvershoot);
if(overshoot > maxOvershoot)
{
maxOvershoot = overshoot;
maxOvershootParameter = t;
}
}
if(maxOvershoot > 0)
{
oc_vec2 splitLeft[3];
oc_vec2 splitRight[3];
oc_quadratic_split(p, maxOvershootParameter, splitLeft, splitRight);
oc_gl_encode_stroke_quadratic(backend, splitLeft);
oc_gl_encode_stroke_quadratic(backend, splitRight);
}
else
{
oc_vec2 tmp = leftHull[0];
leftHull[0] = leftHull[2];
leftHull[2] = tmp;
oc_gl_canvas_encode_element(backend, OC_PATH_QUADRATIC, rightHull);
oc_gl_canvas_encode_element(backend, OC_PATH_QUADRATIC, leftHull);
oc_vec2 joint0[2] = { rightHull[2], leftHull[0] };
oc_vec2 joint1[2] = { leftHull[2], rightHull[0] };
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, joint0);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, joint1);
}
}
}
void oc_gl_encode_stroke_cubic(oc_gl_canvas_backend* backend, oc_vec2* p)
{
f32 width = backend->primitive->attributes.width;
f32 tolerance = oc_min(backend->primitive->attributes.tolerance, 0.5 * width);
//NOTE: check degenerate line cases
f32 equalEps = 1e-3;
if((oc_vec2_close(p[0], p[1], equalEps) && oc_vec2_close(p[2], p[3], equalEps))
|| (oc_vec2_close(p[0], p[1], equalEps) && oc_vec2_close(p[1], p[2], equalEps))
|| (oc_vec2_close(p[1], p[2], equalEps) && oc_vec2_close(p[2], p[3], equalEps)))
{
oc_vec2 line[2] = { p[0], p[3] };
oc_gl_encode_stroke_line(backend, line);
return;
}
else if(oc_vec2_close(p[0], p[1], equalEps) && oc_vec2_close(p[1], p[3], equalEps))
{
oc_vec2 line[2] = { p[0], oc_vec2_add(oc_vec2_mul(5. / 9, p[0]), oc_vec2_mul(4. / 9, p[2])) };
oc_gl_encode_stroke_line(backend, line);
return;
}
else if(oc_vec2_close(p[0], p[2], equalEps) && oc_vec2_close(p[2], p[3], equalEps))
{
oc_vec2 line[2] = { p[0], oc_vec2_add(oc_vec2_mul(5. / 9, p[0]), oc_vec2_mul(4. / 9, p[1])) };
oc_gl_encode_stroke_line(backend, line);
return;
}
oc_vec2 leftHull[4];
oc_vec2 rightHull[4];
if(!oc_offset_hull(4, p, leftHull, width / 2)
|| !oc_offset_hull(4, p, rightHull, -width / 2))
{
//TODO split and recurse
//NOTE: offsetting the hull failed, split the curve
oc_vec2 splitLeft[4];
oc_vec2 splitRight[4];
oc_cubic_split(p, 0.5, splitLeft, splitRight);
oc_gl_encode_stroke_cubic(backend, splitLeft);
oc_gl_encode_stroke_cubic(backend, splitRight);
}
else
{
f32 checkSamples[OC_HULL_CHECK_SAMPLE_COUNT] = { 1. / 6, 2. / 6, 3. / 6, 4. / 6, 5. / 6 };
f32 d2LowBound = oc_square(0.5 * width - tolerance);
f32 d2HighBound = oc_square(0.5 * width + tolerance);
f32 maxOvershoot = 0;
f32 maxOvershootParameter = 0;
for(int i = 0; i < OC_HULL_CHECK_SAMPLE_COUNT; i++)
{
f32 t = checkSamples[i];
oc_vec2 c = oc_cubic_get_point(p, t);
oc_vec2 cp = oc_cubic_get_point(leftHull, t);
oc_vec2 cn = oc_cubic_get_point(rightHull, t);
f32 positiveDistSquare = oc_square(c.x - cp.x) + oc_square(c.y - cp.y);
f32 negativeDistSquare = oc_square(c.x - cn.x) + oc_square(c.y - cn.y);
f32 positiveOvershoot = oc_max(positiveDistSquare - d2HighBound, d2LowBound - positiveDistSquare);
f32 negativeOvershoot = oc_max(negativeDistSquare - d2HighBound, d2LowBound - negativeDistSquare);
f32 overshoot = oc_max(positiveOvershoot, negativeOvershoot);
if(overshoot > maxOvershoot)
{
maxOvershoot = overshoot;
maxOvershootParameter = t;
}
}
if(maxOvershoot > 0)
{
oc_vec2 splitLeft[4];
oc_vec2 splitRight[4];
oc_cubic_split(p, maxOvershootParameter, splitLeft, splitRight);
oc_gl_encode_stroke_cubic(backend, splitLeft);
oc_gl_encode_stroke_cubic(backend, splitRight);
}
else
{
oc_vec2 tmp = leftHull[0];
leftHull[0] = leftHull[3];
leftHull[3] = tmp;
tmp = leftHull[1];
leftHull[1] = leftHull[2];
leftHull[2] = tmp;
oc_gl_canvas_encode_element(backend, OC_PATH_CUBIC, rightHull);
oc_gl_canvas_encode_element(backend, OC_PATH_CUBIC, leftHull);
oc_vec2 joint0[2] = { rightHull[3], leftHull[0] };
oc_vec2 joint1[2] = { leftHull[3], rightHull[0] };
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, joint0);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, joint1);
}
}
}
void oc_gl_encode_stroke_element(oc_gl_canvas_backend* backend,
oc_path_elt* element,
oc_vec2 currentPoint,
oc_vec2* startTangent,
oc_vec2* endTangent,
oc_vec2* endPoint)
{
oc_vec2 controlPoints[4] = { currentPoint, element->p[0], element->p[1], element->p[2] };
int endPointIndex = 0;
switch(element->type)
{
case OC_PATH_LINE:
oc_gl_encode_stroke_line(backend, controlPoints);
endPointIndex = 1;
break;
case OC_PATH_QUADRATIC:
oc_gl_encode_stroke_quadratic(backend, controlPoints);
endPointIndex = 2;
break;
case OC_PATH_CUBIC:
oc_gl_encode_stroke_cubic(backend, controlPoints);
endPointIndex = 3;
break;
case OC_PATH_MOVE:
OC_ASSERT(0, "should be unreachable");
break;
}
//NOTE: ensure tangents are properly computed even in presence of coincident points
//TODO: see if we can do this in a less hacky way
for(int i = 1; i < 4; i++)
{
if(controlPoints[i].x != controlPoints[0].x
|| controlPoints[i].y != controlPoints[0].y)
{
*startTangent = (oc_vec2){ .x = controlPoints[i].x - controlPoints[0].x,
.y = controlPoints[i].y - controlPoints[0].y };
break;
}
}
*endPoint = controlPoints[endPointIndex];
for(int i = endPointIndex - 1; i >= 0; i++)
{
if(controlPoints[i].x != endPoint->x
|| controlPoints[i].y != endPoint->y)
{
*endTangent = (oc_vec2){ .x = endPoint->x - controlPoints[i].x,
.y = endPoint->y - controlPoints[i].y };
break;
}
}
OC_DEBUG_ASSERT(startTangent->x != 0 || startTangent->y != 0);
}
void oc_gl_stroke_cap(oc_gl_canvas_backend* backend,
oc_vec2 p0,
oc_vec2 direction)
{
oc_attributes* attributes = &backend->primitive->attributes;
//NOTE(martin): compute the tangent and normal vectors (multiplied by half width) at the cap point
f32 dn = sqrt(oc_square(direction.x) + oc_square(direction.y));
f32 alpha = 0.5 * attributes->width / dn;
oc_vec2 n0 = { -alpha * direction.y,
alpha * direction.x };
oc_vec2 m0 = { alpha * direction.x,
alpha * direction.y };
oc_vec2 points[] = { { p0.x + n0.x, p0.y + n0.y },
{ p0.x + n0.x + m0.x, p0.y + n0.y + m0.y },
{ p0.x - n0.x + m0.x, p0.y - n0.y + m0.y },
{ p0.x - n0.x, p0.y - n0.y },
{ p0.x + n0.x, p0.y + n0.y } };
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 1);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 2);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 3);
}
void oc_gl_stroke_joint(oc_gl_canvas_backend* backend,
oc_vec2 p0,
oc_vec2 t0,
oc_vec2 t1)
{
oc_attributes* attributes = &backend->primitive->attributes;
//NOTE(martin): compute the normals at the joint point
f32 norm_t0 = sqrt(oc_square(t0.x) + oc_square(t0.y));
f32 norm_t1 = sqrt(oc_square(t1.x) + oc_square(t1.y));
oc_vec2 n0 = { -t0.y, t0.x };
n0.x /= norm_t0;
n0.y /= norm_t0;
oc_vec2 n1 = { -t1.y, t1.x };
n1.x /= norm_t1;
n1.y /= norm_t1;
//NOTE(martin): the sign of the cross product determines if the normals are facing outwards or inwards the angle.
// we flip them to face outwards if needed
f32 crossZ = n0.x * n1.y - n0.y * n1.x;
if(crossZ > 0)
{
n0.x *= -1;
n0.y *= -1;
n1.x *= -1;
n1.y *= -1;
}
//NOTE(martin): use the same code as hull offset to find mitter point...
/*NOTE(martin): let vector u = (n0+n1) and vector v = pIntersect - p1
then v = u * (2*offset / norm(u)^2)
(this can be derived from writing the pythagoras theorems in the triangles of the joint)
*/
f32 halfW = 0.5 * attributes->width;
oc_vec2 u = { n0.x + n1.x, n0.y + n1.y };
f32 uNormSquare = u.x * u.x + u.y * u.y;
f32 alpha = attributes->width / uNormSquare;
oc_vec2 v = { u.x * alpha, u.y * alpha };
f32 excursionSquare = uNormSquare * oc_square(alpha - attributes->width / 4);
if(attributes->joint == OC_JOINT_MITER
&& excursionSquare <= oc_square(attributes->maxJointExcursion))
{
//NOTE(martin): add a mitter joint
oc_vec2 points[] = { p0,
{ p0.x + n0.x * halfW, p0.y + n0.y * halfW },
{ p0.x + v.x, p0.y + v.y },
{ p0.x + n1.x * halfW, p0.y + n1.y * halfW },
p0 };
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 1);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 2);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 3);
}
else
{
//NOTE(martin): add a bevel joint
oc_vec2 points[] = { p0,
{ p0.x + n0.x * halfW, p0.y + n0.y * halfW },
{ p0.x + n1.x * halfW, p0.y + n1.y * halfW },
p0 };
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 1);
oc_gl_canvas_encode_element(backend, OC_PATH_LINE, points + 2);
}
}
u32 oc_gl_encode_stroke_subpath(oc_gl_canvas_backend* backend,
oc_path_elt* elements,
oc_path_descriptor* path,
u32 startIndex,
oc_vec2 startPoint)
{
u32 eltCount = path->count;
OC_DEBUG_ASSERT(startIndex < eltCount);
oc_vec2 currentPoint = startPoint;
oc_vec2 endPoint = { 0, 0 };
oc_vec2 previousEndTangent = { 0, 0 };
oc_vec2 firstTangent = { 0, 0 };
oc_vec2 startTangent = { 0, 0 };
oc_vec2 endTangent = { 0, 0 };
//NOTE(martin): encode first element and compute first tangent
oc_gl_encode_stroke_element(backend, elements + startIndex, currentPoint, &startTangent, &endTangent, &endPoint);
firstTangent = startTangent;
previousEndTangent = endTangent;
currentPoint = endPoint;
//NOTE(martin): encode subsequent elements along with their joints
oc_attributes* attributes = &backend->primitive->attributes;
u32 eltIndex = startIndex + 1;
for(;
eltIndex < eltCount && elements[eltIndex].type != OC_PATH_MOVE;
eltIndex++)
{
oc_gl_encode_stroke_element(backend, elements + eltIndex, currentPoint, &startTangent, &endTangent, &endPoint);
if(attributes->joint != OC_JOINT_NONE)
{
oc_gl_stroke_joint(backend, currentPoint, previousEndTangent, startTangent);
}
previousEndTangent = endTangent;
currentPoint = endPoint;
}
u32 subPathEltCount = eltIndex - startIndex;
//NOTE(martin): draw end cap / joint. We ensure there's at least two segments to draw a closing joint
if(subPathEltCount > 1
&& startPoint.x == endPoint.x
&& startPoint.y == endPoint.y)
{
if(attributes->joint != OC_JOINT_NONE)
{
//NOTE(martin): add a closing joint if the path is closed
oc_gl_stroke_joint(backend, endPoint, endTangent, firstTangent);
}
}
else if(attributes->cap == OC_CAP_SQUARE)
{
//NOTE(martin): add start and end cap
oc_gl_stroke_cap(backend, startPoint, (oc_vec2){ -startTangent.x, -startTangent.y });
oc_gl_stroke_cap(backend, endPoint, endTangent);
}
return (eltIndex);
}
void oc_gl_encode_stroke(oc_gl_canvas_backend* backend,
oc_path_elt* elements,
oc_path_descriptor* path)
{
u32 eltCount = path->count;
OC_DEBUG_ASSERT(eltCount);
oc_vec2 startPoint = path->startPoint;
u32 startIndex = 0;
while(startIndex < eltCount)
{
//NOTE(martin): eliminate leading moves
while(startIndex < eltCount && elements[startIndex].type == OC_PATH_MOVE)
{
startPoint = elements[startIndex].p[0];
startIndex++;
}
if(startIndex < eltCount)
{
startIndex = oc_gl_encode_stroke_subpath(backend, elements, path, startIndex, startPoint);
}
}
}
void oc_gl_grow_buffer_if_needed(GLuint buffer, i32 wantedSize, const char* name)
{
i32 oldSize = 0;
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
glGetBufferParameteriv(GL_SHADER_STORAGE_BUFFER, GL_BUFFER_SIZE, &oldSize);
if(oldSize < wantedSize)
{
oc_log_info("growing %s buffer\n", name);
int newSize = wantedSize * 1.2;
glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, newSize, 0, GL_DYNAMIC_COPY);
}
}
void oc_gl_render_batch(oc_gl_canvas_backend* backend,
oc_wgl_surface* surface,
oc_image* images,
int tileSize,
int nTilesX,
int nTilesY,
oc_vec2 viewportSize,
f32 scale)
{
GLuint pathBuffer = backend->pathBuffer[backend->bufferIndex].buffer;
GLuint elementBuffer = backend->elementBuffer[backend->bufferIndex].buffer;
int pathBufferOffset = backend->pathBatchStart * sizeof(oc_gl_path);
int elementBufferOffset = backend->eltBatchStart * sizeof(oc_gl_path_elt);
int pathCount = backend->pathCount - backend->pathBatchStart;
int eltCount = backend->eltCount - backend->eltBatchStart;
if(!pathCount || !eltCount)
{
return;
}
//NOTE: update intermediate buffers size if needed
//TODO: compute correct sizes
oc_gl_grow_buffer_if_needed(backend->pathQueueBuffer, pathCount * OC_GL_PATH_QUEUE_SIZE, "path queues");
oc_gl_grow_buffer_if_needed(backend->tileQueueBuffer, backend->maxTileQueueCount * OC_GL_TILE_QUEUE_SIZE, "tile queues");
oc_gl_grow_buffer_if_needed(backend->segmentBuffer, backend->maxSegmentCount * OC_GL_SEGMENT_SIZE, "segments");
oc_gl_grow_buffer_if_needed(backend->screenTilesBuffer, nTilesX * nTilesY * OC_GL_SCREEN_TILE_SIZE, "screen tiles");
oc_gl_grow_buffer_if_needed(backend->tileOpBuffer, backend->maxSegmentCount * 30 * OC_GL_TILE_OP_SIZE, "tile ops");
//NOTE: make the buffers visible to gl
glBindBuffer(GL_SHADER_STORAGE_BUFFER, pathBuffer);
glFlushMappedBufferRange(GL_SHADER_STORAGE_BUFFER, pathBufferOffset, pathCount * sizeof(oc_gl_path));
glBindBuffer(GL_SHADER_STORAGE_BUFFER, elementBuffer);
glFlushMappedBufferRange(GL_SHADER_STORAGE_BUFFER, elementBufferOffset, eltCount * sizeof(oc_gl_path_elt));
//NOTE: clear out texture
u8 clearColor[4] = { 0 };
glClearTexImage(backend->outTexture, 0, GL_RGBA, GL_BYTE, clearColor);
//NOTE: clear counters
int zero = 0;
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->segmentCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), &zero, GL_DYNAMIC_COPY);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->tileQueueCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), &zero, GL_DYNAMIC_COPY);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->tileOpCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), &zero, GL_DYNAMIC_COPY);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->rasterDispatchBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(oc_gl_dispatch_indirect_command), &zero, GL_DYNAMIC_COPY);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->screenTilesCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), &zero, GL_DYNAMIC_COPY);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
int err = glGetError();
if(err)
{
oc_log_error("gl error %i\n", err);
}
//NOTE: path setup pass
int maxWorkGroupCount = 0;
glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &maxWorkGroupCount);
//NOTE: glDispatchCompute errors if work group count is greater _or equal_ to GL_MAX_COMPUTE_WORK_GROUP_COUNT
// so the maximum _allowed_ group count is one less.
maxWorkGroupCount--;
glUseProgram(backend->pathSetup);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, backend->tileQueueCountBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, backend->tileQueueBuffer);
glUniform1i(0, tileSize);
glUniform1f(1, scale);
for(int i = 0; i < pathCount; i += maxWorkGroupCount)
{
int count = oc_min(maxWorkGroupCount, pathCount - i);
glUniform1i(2, backend->pathBatchStart + i);
glUniform1i(3, i);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, pathBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, backend->pathQueueBuffer);
glDispatchCompute(count, 1, 1);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
}
if(!err)
{
err = glGetError();
if(err)
{
oc_log_error("gl error %i\n", err);
}
}
//NOTE: segment setup pass
glUseProgram(backend->segmentSetup);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, backend->segmentCountBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, backend->segmentBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, backend->pathQueueBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, backend->tileQueueBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, backend->tileOpCountBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, backend->tileOpBuffer);
glUniform1f(0, scale);
glUniform1ui(1, tileSize);
for(int i = 0; i < eltCount; i += maxWorkGroupCount)
{
int offset = elementBufferOffset + i * sizeof(oc_gl_path_elt);
int count = oc_min(maxWorkGroupCount, eltCount - i);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, elementBuffer);
glUniform1i(2, (backend->eltBatchStart + i));
glDispatchCompute(count, 1, 1);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
}
if(!err)
{
err = glGetError();
if(err)
{
oc_log_error("gl error %i\n", err);
}
}
//NOTE: backprop pass
glUseProgram(backend->backprop);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, backend->tileQueueBuffer);
for(int i = 0; i < pathCount; i += maxWorkGroupCount)
{
int count = oc_min(maxWorkGroupCount, pathCount - i);
glUniform1i(0, i);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, backend->pathQueueBuffer);
glDispatchCompute(count, 1, 1);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
}
if(!err)
{
err = glGetError();
if(err)
{
oc_log_error("gl error %i\n", err);
}
}
//NOTE: merge pass
glUseProgram(backend->merge);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, pathBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, backend->pathQueueBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, backend->tileQueueBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, backend->tileOpCountBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, backend->tileOpBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, backend->screenTilesBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, backend->screenTilesCountBuffer);
glUniform1i(0, tileSize);
glUniform1f(1, scale);
glUniform1i(2, pathCount);
glUniform1i(3, backend->pathBatchStart);
glDispatchCompute(nTilesX, nTilesY, 1);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
if(!err)
{
err = glGetError();
if(err)
{
oc_log_error("gl error %i\n", err);
}
}
//NOTE: balance work groups
glUseProgram(backend->balanceWorkgroups);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, backend->screenTilesCountBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, backend->rasterDispatchBuffer);
glUniform1ui(0, maxWorkGroupCount);
glDispatchCompute(1, 1, 1);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
//NOTE: raster pass
glUseProgram(backend->raster);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, pathBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, backend->segmentBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, backend->tileOpBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, backend->screenTilesBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, backend->screenTilesCountBuffer);
glUniform1f(0, scale);
glUniform1i(1, backend->msaaCount);
glBindImageTexture(0, backend->outTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
for(int i = 0; i < OC_GL_MAX_IMAGES_PER_BATCH; i++)
{
if(images[i].h)
{
oc_gl_image* image = (oc_gl_image*)oc_image_data_from_handle(images[i]);
if(image)
{
glActiveTexture(GL_TEXTURE1 + i);
glBindTexture(GL_TEXTURE_2D, image->texture);
}
}
}
glUniform1i(2, backend->pathBatchStart);
glUniform1ui(3, maxWorkGroupCount);
glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, backend->rasterDispatchBuffer);
glDispatchComputeIndirect(0);
glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
if(!err)
{
err = glGetError();
if(err)
{
oc_log_error("gl error %i\n", err);
}
}
//NOTE: blit pass
glUseProgram(backend->blit);
glBindBuffer(GL_ARRAY_BUFFER, backend->dummyVertexBuffer);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, backend->outTexture);
glUniform1i(0, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);
if(!err)
{
err = glGetError();
if(err)
{
oc_log_error("gl error %i\n", err);
}
}
backend->pathBatchStart = backend->pathCount;
backend->eltBatchStart = backend->eltCount;
backend->maxSegmentCount = 0;
backend->maxTileQueueCount = 0;
}
void oc_gl_canvas_resize(oc_gl_canvas_backend* backend, oc_vec2 size)
{
int tileSize = OC_GL_TILE_SIZE;
int nTilesX = (int)(size.x + tileSize - 1) / tileSize;
int nTilesY = (int)(size.y + tileSize - 1) / tileSize;
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->screenTilesBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, nTilesX * nTilesY * OC_GL_SCREEN_TILE_SIZE, 0, GL_DYNAMIC_COPY);
if(backend->outTexture)
{
//NOTE: do we need to explicitly glDeleteTextures()?
glDeleteTextures(1, &backend->outTexture);
glGenTextures(1, &backend->outTexture);
glBindTexture(GL_TEXTURE_2D, backend->outTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, size.x, size.y);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
backend->frameSize = size;
}
void oc_gl_canvas_render(oc_canvas_backend* interface,
oc_color clearColor,
u32 primitiveCount,
oc_primitive* primitives,
u32 eltCount,
oc_path_elt* pathElements)
{
oc_gl_canvas_backend* backend = (oc_gl_canvas_backend*)interface;
//NOTE: roll input buffers
backend->bufferIndex = (backend->bufferIndex + 1) % OC_GL_INPUT_BUFFERS_COUNT;
if(backend->bufferSync[backend->bufferIndex] != 0)
{
glClientWaitSync(backend->bufferSync[backend->bufferIndex], GL_SYNC_FLUSH_COMMANDS_BIT, 0xffffffff);
glDeleteSync(backend->bufferSync[backend->bufferIndex]);
backend->bufferSync[backend->bufferIndex] = 0;
}
//NOTE update screen tiles buffer size
oc_wgl_surface* surface = backend->surface;
oc_vec2 surfaceSize = surface->interface.getSize((oc_surface_data*)surface);
oc_vec2 contentsScaling = surface->interface.contentsScaling((oc_surface_data*)surface);
//TODO support scaling in both axes?
f32 scale = contentsScaling.x;
oc_vec2 viewportSize = { surfaceSize.x * scale, surfaceSize.y * scale };
int tileSize = OC_GL_TILE_SIZE;
int nTilesX = (int)(viewportSize.x + tileSize - 1) / tileSize;
int nTilesY = (int)(viewportSize.y + tileSize - 1) / tileSize;
if(viewportSize.x != backend->frameSize.x || viewportSize.y != backend->frameSize.y)
{
oc_gl_canvas_resize(backend, viewportSize);
}
glViewport(0, 0, viewportSize.x, viewportSize.y);
//NOTE: clear screen and reset input buffer offsets
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
glClear(GL_COLOR_BUFFER_BIT);
backend->pathCount = 0;
backend->pathBatchStart = 0;
backend->eltCount = 0;
backend->eltBatchStart = 0;
backend->maxSegmentCount = 0;
backend->maxTileQueueCount = 0;
//NOTE: encode and render batches
oc_vec2 currentPos = { 0 };
oc_image images[OC_GL_MAX_IMAGES_PER_BATCH] = { 0 };
int imageCount = 0;
backend->eltCount = 0;
for(int primitiveIndex = 0; primitiveIndex < primitiveCount; primitiveIndex++)
{
oc_primitive* primitive = &primitives[primitiveIndex];
if(primitive->attributes.image.h != 0)
{
backend->currentImageIndex = -1;
for(int i = 0; i < imageCount; i++)
{
if(images[i].h == primitive->attributes.image.h)
{
backend->currentImageIndex = i;
}
}
if(backend->currentImageIndex <= 0)
{
if(imageCount < OC_GL_MAX_IMAGES_PER_BATCH)
{
images[imageCount] = primitive->attributes.image;
backend->currentImageIndex = imageCount;
imageCount++;
}
else
{
oc_gl_render_batch(backend,
surface,
images,
tileSize,
nTilesX,
nTilesY,
viewportSize,
scale);
images[0] = primitive->attributes.image;
backend->currentImageIndex = 0;
imageCount = 1;
}
}
}
else
{
backend->currentImageIndex = -1;
}
if(primitive->path.count)
{
backend->primitive = primitive;
backend->pathScreenExtents = (oc_vec4){ FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX };
backend->pathUserExtents = (oc_vec4){ FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX };
if(primitive->cmd == OC_CMD_STROKE)
{
oc_gl_encode_stroke(backend, pathElements + primitive->path.startIndex, &primitive->path);
}
else
{
int segCount = 0;
for(int eltIndex = 0;
(eltIndex < primitive->path.count) && (primitive->path.startIndex + eltIndex < eltCount);
eltIndex++)
{
oc_path_elt* elt = &pathElements[primitive->path.startIndex + eltIndex];
if(elt->type != OC_PATH_MOVE)
{
oc_vec2 p[4] = { currentPos, elt->p[0], elt->p[1], elt->p[2] };
oc_gl_canvas_encode_element(backend, elt->type, p);
segCount++;
}
switch(elt->type)
{
case OC_PATH_MOVE:
currentPos = elt->p[0];
break;
case OC_PATH_LINE:
currentPos = elt->p[0];
break;
case OC_PATH_QUADRATIC:
currentPos = elt->p[1];
break;
case OC_PATH_CUBIC:
currentPos = elt->p[2];
break;
}
}
}
//NOTE: push path
oc_gl_canvas_encode_path(backend, primitive, scale);
}
}
oc_gl_render_batch(backend,
surface,
images,
tileSize,
nTilesX,
nTilesY,
viewportSize,
scale);
//NOTE: add fence for rolling input buffers
backend->bufferSync[backend->bufferIndex] = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
}
//--------------------------------------------------------------------
// Image API
//--------------------------------------------------------------------
oc_image_data* oc_gl_canvas_image_create(oc_canvas_backend* interface, oc_vec2 size)
{
oc_gl_image* image = 0;
image = oc_malloc_type(oc_gl_image);
if(image)
{
glGenTextures(1, &image->texture);
glBindTexture(GL_TEXTURE_2D, image->texture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, size.x, size.y);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
image->interface.size = size;
}
return ((oc_image_data*)image);
}
void oc_gl_canvas_image_destroy(oc_canvas_backend* interface, oc_image_data* imageInterface)
{
//TODO: check that this image belongs to this backend
oc_gl_image* image = (oc_gl_image*)imageInterface;
glDeleteTextures(1, &image->texture);
free(image);
}
void oc_gl_canvas_image_upload_region(oc_canvas_backend* interface,
oc_image_data* imageInterface,
oc_rect region,
u8* pixels)
{
//TODO: check that this image belongs to this backend
oc_gl_image* image = (oc_gl_image*)imageInterface;
glBindTexture(GL_TEXTURE_2D, image->texture);
glTexSubImage2D(GL_TEXTURE_2D, 0, region.x, region.y, region.w, region.h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
}
//--------------------------------------------------------------------
// Canvas setup / destroy
//--------------------------------------------------------------------
void oc_gl_canvas_destroy(oc_canvas_backend* interface)
{
oc_gl_canvas_backend* backend = (oc_gl_canvas_backend*)interface;
////////////////////////////////////////////////////////////////////
//TODO
////////////////////////////////////////////////////////////////////
free(backend);
}
static int oc_gl_compile_shader(const char* name, GLuint shader, const char* source)
{
int res = 0;
const char* sources[3] = { "#version 430", glsl_common, source };
glShaderSource(shader, 3, sources, 0);
glCompileShader(shader);
int status = 0;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if(!status)
{
char buffer[256];
int size = 0;
glGetShaderInfoLog(shader, 256, &size, buffer);
printf("Shader compile error (%s): %.*s\n", name, size, buffer);
res = -1;
}
return (res);
}
static int oc_gl_canvas_compile_compute_program_named(const char* name, const char* source, GLuint* outProgram)
{
int res = 0;
*outProgram = 0;
GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
GLuint program = glCreateProgram();
res |= oc_gl_compile_shader(name, shader, source);
if(!res)
{
glAttachShader(program, shader);
glLinkProgram(program);
int status = 0;
glGetProgramiv(program, GL_LINK_STATUS, &status);
if(!status)
{
char buffer[256];
int size = 0;
glGetProgramInfoLog(program, 256, &size, buffer);
oc_log_error("Shader link error (%s): %.*s\n", name, size, buffer);
res = -1;
}
else
{
*outProgram = program;
}
}
return (res);
}
int oc_gl_canvas_compile_render_program_named(const char* progName,
const char* vertexName,
const char* fragmentName,
const char* vertexSrc,
const char* fragmentSrc,
GLuint* outProgram)
{
int res = 0;
*outProgram = 0;
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
GLuint program = glCreateProgram();
res |= oc_gl_compile_shader(vertexName, vertexShader, vertexSrc);
res |= oc_gl_compile_shader(fragmentName, fragmentShader, fragmentSrc);
if(!res)
{
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
int status = 0;
glGetProgramiv(program, GL_LINK_STATUS, &status);
if(!status)
{
char buffer[256];
int size = 0;
glGetProgramInfoLog(program, 256, &size, buffer);
oc_log_error("Shader link error (%s): %.*s\n", progName, size, buffer);
res = -1;
}
else
{
*outProgram = program;
}
}
return (res);
}
#define oc_gl_canvas_compile_compute_program(src, out) \
oc_gl_canvas_compile_compute_program_named(#src, src, out)
#define oc_gl_canvas_compile_render_program(progName, shaderSrc, vertexSrc, out) \
oc_gl_canvas_compile_render_program_named(progName, #shaderSrc, #vertexSrc, shaderSrc, vertexSrc, out)
const u32 OC_GL_PATH_BUFFER_SIZE = (4 << 10) * sizeof(oc_gl_path),
OC_GL_ELEMENT_BUFFER_SIZE = (4 << 12) * sizeof(oc_gl_path_elt),
OC_GL_SEGMENT_BUFFER_SIZE = (4 << 10) * OC_GL_SEGMENT_SIZE,
OC_GL_PATH_QUEUE_BUFFER_SIZE = (4 << 10) * OC_GL_PATH_QUEUE_SIZE,
OC_GL_TILE_QUEUE_BUFFER_SIZE = (4 << 10) * OC_GL_TILE_QUEUE_SIZE,
OC_GL_TILE_OP_BUFFER_SIZE = (4 << 20) * OC_GL_TILE_OP_SIZE;
oc_canvas_backend* oc_gl_canvas_backend_create(oc_wgl_surface* surface)
{
oc_gl_canvas_backend* backend = oc_malloc_type(oc_gl_canvas_backend);
if(backend)
{
memset(backend, 0, sizeof(oc_gl_canvas_backend));
backend->surface = surface;
backend->msaaCount = OC_GL_MSAA_COUNT;
//NOTE(martin): setup interface functions
backend->interface.destroy = oc_gl_canvas_destroy;
backend->interface.render = oc_gl_canvas_render;
backend->interface.imageCreate = oc_gl_canvas_image_create;
backend->interface.imageDestroy = oc_gl_canvas_image_destroy;
backend->interface.imageUploadRegion = oc_gl_canvas_image_upload_region;
surface->interface.prepare((oc_surface_data*)surface);
glGenVertexArrays(1, &backend->vao);
glBindVertexArray(backend->vao);
//NOTE: create programs
int err = 0;
err |= oc_gl_canvas_compile_compute_program(glsl_path_setup, &backend->pathSetup);
err |= oc_gl_canvas_compile_compute_program(glsl_segment_setup, &backend->segmentSetup);
err |= oc_gl_canvas_compile_compute_program(glsl_backprop, &backend->backprop);
err |= oc_gl_canvas_compile_compute_program(glsl_merge, &backend->merge);
err |= oc_gl_canvas_compile_compute_program(glsl_balance_workgroups, &backend->balanceWorkgroups);
err |= oc_gl_canvas_compile_compute_program(glsl_raster, &backend->raster);
err |= oc_gl_canvas_compile_render_program("blit", glsl_blit_vertex, glsl_blit_fragment, &backend->blit);
if(glGetError() != GL_NO_ERROR)
{
err |= -1;
}
//NOTE: create out texture
oc_vec2 size = surface->interface.getSize((oc_surface_data*)surface);
oc_vec2 scale = surface->interface.contentsScaling((oc_surface_data*)surface);
backend->frameSize = (oc_vec2){ size.x * scale.x, size.y * scale.y };
glGenTextures(1, &backend->outTexture);
glBindTexture(GL_TEXTURE_2D, backend->outTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, backend->frameSize.x, backend->frameSize.y);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//NOTE: generate buffers
glGenBuffers(1, &backend->dummyVertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, backend->dummyVertexBuffer);
for(int i = 0; i < OC_GL_INPUT_BUFFERS_COUNT; i++)
{
glGenBuffers(1, &backend->pathBuffer[i].buffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->pathBuffer[i].buffer);
glBufferStorage(GL_SHADER_STORAGE_BUFFER, OC_GL_PATH_BUFFER_SIZE, 0, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
backend->pathBuffer[i].size = OC_GL_PATH_BUFFER_SIZE;
backend->pathBuffer[i].contents = glMapBufferRange(GL_SHADER_STORAGE_BUFFER,
0,
OC_GL_PATH_BUFFER_SIZE,
GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_FLUSH_EXPLICIT_BIT);
glGenBuffers(1, &backend->elementBuffer[i].buffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->elementBuffer[i].buffer);
glBufferStorage(GL_SHADER_STORAGE_BUFFER, OC_GL_ELEMENT_BUFFER_SIZE, 0, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
backend->elementBuffer[i].size = OC_GL_ELEMENT_BUFFER_SIZE;
backend->elementBuffer[i].contents = glMapBufferRange(GL_SHADER_STORAGE_BUFFER,
0,
OC_GL_ELEMENT_BUFFER_SIZE,
GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT
| GL_MAP_FLUSH_EXPLICIT_BIT);
}
glGenBuffers(1, &backend->segmentBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->segmentBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, OC_GL_SEGMENT_BUFFER_SIZE, 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->segmentCountBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->segmentCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->pathQueueBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->pathQueueBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, OC_GL_PATH_QUEUE_BUFFER_SIZE, 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->tileQueueBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->tileQueueBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, OC_GL_TILE_QUEUE_BUFFER_SIZE, 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->tileQueueCountBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->tileQueueCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->tileOpBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->tileOpBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, OC_GL_TILE_OP_BUFFER_SIZE, 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->tileOpCountBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->tileOpCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), 0, GL_DYNAMIC_COPY);
int tileSize = OC_GL_TILE_SIZE;
int nTilesX = (int)(backend->frameSize.x + tileSize - 1) / tileSize;
int nTilesY = (int)(backend->frameSize.y + tileSize - 1) / tileSize;
glGenBuffers(1, &backend->screenTilesBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->screenTilesBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, nTilesX * nTilesY * OC_GL_SCREEN_TILE_SIZE, 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->screenTilesCountBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->screenTilesCountBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), 0, GL_DYNAMIC_COPY);
glGenBuffers(1, &backend->rasterDispatchBuffer);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, backend->rasterDispatchBuffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(oc_gl_dispatch_indirect_command), 0, GL_DYNAMIC_COPY);
if(err)
{
oc_gl_canvas_destroy((oc_canvas_backend*)backend);
backend = 0;
}
}
return ((oc_canvas_backend*)backend);
}
oc_surface_data* oc_gl_canvas_surface_create_for_window(oc_window window)
{
oc_wgl_surface* surface = (oc_wgl_surface*)oc_wgl_surface_create_for_window(window);
if(surface)
{
surface->interface.backend = oc_gl_canvas_backend_create(surface);
if(surface->interface.backend)
{
surface->interface.api = OC_CANVAS;
}
else
{
surface->interface.destroy((oc_surface_data*)surface);
surface = 0;
}
}
return ((oc_surface_data*)surface);
}
Reference in New Issue View Git Blame Copy Permalink