First pass at nodes
This commit is contained in:
@@ -0,0 +1,212 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "pr_graph.h"
|
||||
#include "../../vendor/wapp/wapp.h"
|
||||
#include <string.h>
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Internal: unlink edge helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
static void _unlinkForward(PrGraph *graph, u64 from_idx, PrGraphEdge *edge) {
|
||||
PrGraphVertex *vtx = &graph->vertices[from_idx];
|
||||
PrGraphEdge *curr = vtx->next_forward;
|
||||
PrGraphEdge *prev = NULL;
|
||||
while (curr) {
|
||||
if (curr == edge) {
|
||||
if (prev) {
|
||||
prev->next_forward = curr->next_forward;
|
||||
} else {
|
||||
vtx->next_forward = curr->next_forward;
|
||||
}
|
||||
return;
|
||||
}
|
||||
prev = curr;
|
||||
curr = curr->next_forward;
|
||||
}
|
||||
}
|
||||
|
||||
static void _unlinkBackward(PrGraph *graph, u64 to_idx, PrGraphEdge *edge) {
|
||||
PrGraphVertex *vtx = &graph->vertices[to_idx];
|
||||
PrGraphEdge *curr = vtx->next_backward;
|
||||
PrGraphEdge *prev = NULL;
|
||||
while (curr) {
|
||||
if (curr == edge) {
|
||||
if (prev) {
|
||||
prev->next_backward = curr->next_backward;
|
||||
} else {
|
||||
vtx->next_backward = curr->next_backward;
|
||||
}
|
||||
return;
|
||||
}
|
||||
prev = curr;
|
||||
curr = curr->next_backward;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Graph lifecycle
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern void prGraphInit(PrGraph *graph, WpAllocator *allocator, u64 capacity) {
|
||||
memset(graph, 0, sizeof(*graph));
|
||||
graph->capacity = capacity;
|
||||
|
||||
graph->vertices = wpArrayAllocCapacity(PrGraphVertex, allocator, capacity, WP_ARRAY_INIT_FILLED);
|
||||
if (!graph->vertices) {
|
||||
graph->capacity = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
prPoolInit(&graph->edge_pool, sizeof(PrGraphEdge), 64);
|
||||
}
|
||||
|
||||
wp_extern void prGraphDestroy(PrGraph *graph) {
|
||||
prPoolDestroy(&graph->edge_pool);
|
||||
// vertices are owned by the wapp allocator passed to prGraphInit
|
||||
memset(graph, 0, sizeof(*graph));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Vertex lifecycle
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern void prGraphAddVertex(PrGraph *graph, u64 idx) {
|
||||
graph->vertices[idx].active = true;
|
||||
graph->vertex_count++;
|
||||
if (idx >= graph->max_vertex_ever) {
|
||||
graph->max_vertex_ever = idx + 1;
|
||||
}
|
||||
}
|
||||
|
||||
wp_extern void prGraphRemoveVertex(PrGraph *graph, u64 idx) {
|
||||
PrGraphVertex *vtx = &graph->vertices[idx];
|
||||
if (!vtx->active) { return; }
|
||||
|
||||
// Free outgoing edges: unlink from each target's backward list
|
||||
PrGraphEdge *curr = vtx->next_forward;
|
||||
while (curr) {
|
||||
PrGraphEdge *next = curr->next_forward;
|
||||
_unlinkBackward(graph, curr->target_idx, curr);
|
||||
prPoolFree(&graph->edge_pool, curr);
|
||||
curr = next;
|
||||
}
|
||||
|
||||
// Free incoming edges: unlink from each source's forward list
|
||||
curr = vtx->next_backward;
|
||||
while (curr) {
|
||||
PrGraphEdge *next = curr->next_backward;
|
||||
_unlinkForward(graph, curr->source_idx, curr);
|
||||
prPoolFree(&graph->edge_pool, curr);
|
||||
curr = next;
|
||||
}
|
||||
|
||||
vtx->next_forward = NULL;
|
||||
vtx->next_backward = NULL;
|
||||
vtx->active = false;
|
||||
graph->vertex_count--;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Edge management
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern b8 prGraphEdgeExists(const PrGraph *graph, u64 from_idx, u64 to_idx) {
|
||||
PrGraphVertex *vtx = &graph->vertices[from_idx];
|
||||
PrGraphEdge *curr = vtx->next_forward;
|
||||
while (curr) {
|
||||
if (curr->target_idx == to_idx) { return true; }
|
||||
curr = curr->next_forward;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
wp_extern b8 prGraphAddEdge(PrGraph *graph, u64 from_idx, u64 to_idx) {
|
||||
PrGraphEdge *edge = (PrGraphEdge *)prPoolAlloc(&graph->edge_pool);
|
||||
if (!edge) { return false; }
|
||||
|
||||
edge->source_idx = from_idx;
|
||||
edge->target_idx = to_idx;
|
||||
|
||||
// Link into adjacency chains
|
||||
PrGraphVertex *src = &graph->vertices[from_idx];
|
||||
PrGraphVertex *dst = &graph->vertices[to_idx];
|
||||
edge->next_forward = src->next_forward;
|
||||
edge->next_backward = dst->next_backward;
|
||||
src->next_forward = edge;
|
||||
dst->next_backward = edge;
|
||||
|
||||
// Check whether the new edge created a cycle
|
||||
WpAllocator scratch = wpMemArenaAllocatorInitZero(KiB(16));
|
||||
WpU64Array sorted = prGraphTopologicalSort(graph, &scratch);
|
||||
u64 sorted_n = sorted ? wpArrayCount(sorted) : 0;
|
||||
if (sorted_n < graph->vertex_count) {
|
||||
_unlinkForward(graph, from_idx, edge);
|
||||
_unlinkBackward(graph, to_idx, edge);
|
||||
prPoolFree(&graph->edge_pool, edge);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
wp_extern u64 prGraphVertexCount(const PrGraph *graph) {
|
||||
return graph->vertex_count;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kahn's algorithm — topological sort / cycle detection
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern WpU64Array prGraphTopologicalSort(const PrGraph *graph, const WpAllocator *allocator) {
|
||||
if (graph->vertex_count == 0) { return NULL; }
|
||||
if (!graph->vertices || graph->capacity == 0) { return NULL; }
|
||||
|
||||
WpU64Array result = wpArrayAllocCapacity(u64, allocator, graph->vertex_count, WP_ARRAY_INIT_NONE);
|
||||
if (!result) { return NULL; }
|
||||
|
||||
WpAllocator local_arena = wpMemArenaAllocatorInitZero(KiB(16));
|
||||
|
||||
WpU64Array in_degree = wpArrayAllocCapacity(u64, &local_arena, graph->capacity, WP_ARRAY_INIT_FILLED);
|
||||
if (!in_degree) { return result; }
|
||||
memset(in_degree, 0, wpArrayCapacity(in_degree) * sizeof(u64));
|
||||
|
||||
for (u64 i = 0; i < graph->max_vertex_ever; i++) {
|
||||
if (!graph->vertices[i].active) { continue; }
|
||||
|
||||
PrGraphEdge *curr = graph->vertices[i].next_forward;
|
||||
while (curr) {
|
||||
in_degree[curr->target_idx]++;
|
||||
curr = curr->next_forward;
|
||||
}
|
||||
}
|
||||
|
||||
WpQueue queue = wpQueueAlloc(u64, &local_arena, graph->vertex_count);
|
||||
|
||||
for (u64 i = 0; i < graph->max_vertex_ever; i++) {
|
||||
if (!graph->vertices[i].active) { continue; }
|
||||
if (in_degree[i] == 0) {
|
||||
wpQueuePush(u64, &queue, &i);
|
||||
}
|
||||
}
|
||||
|
||||
while (queue.count > 0) {
|
||||
u64 *node_idx = wpQueuePop(u64, &queue);
|
||||
if (!node_idx) { break; }
|
||||
|
||||
wpArrayAppendCapped(u64, result, node_idx);
|
||||
|
||||
PrGraphEdge *curr = graph->vertices[*node_idx].next_forward;
|
||||
while (curr) {
|
||||
u64 target_idx = curr->target_idx;
|
||||
if (in_degree[target_idx] > 0) {
|
||||
in_degree[target_idx]--;
|
||||
if (in_degree[target_idx] == 0) {
|
||||
wpQueuePush(u64, &queue, &target_idx);
|
||||
}
|
||||
}
|
||||
curr = curr->next_forward;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef PR_GRAPH_H
|
||||
#define PR_GRAPH_H
|
||||
|
||||
#include "../../vendor/wapp/common/aliases/aliases.h"
|
||||
#include "../../vendor/wapp/base/mem/allocator/mem_allocator.h"
|
||||
#include "../../vendor/wapp/base/wapp_base.h"
|
||||
#include "../allocators/pr_pool_allocator.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PrGraphEdge — separately allocated adjacency list node
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct PrGraphEdge PrGraphEdge;
|
||||
struct PrGraphEdge {
|
||||
PrGraphEdge *next_forward;
|
||||
PrGraphEdge *next_backward;
|
||||
u64 source_idx;
|
||||
u64 target_idx;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PrGraphVertex — compact adjacency head
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct PrGraphVertex PrGraphVertex;
|
||||
struct PrGraphVertex {
|
||||
PrGraphEdge *next_forward;
|
||||
PrGraphEdge *next_backward;
|
||||
b8 active;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PrGraph — owns topology (edges + adjacency heads)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct {
|
||||
PrPool edge_pool;
|
||||
PrGraphVertex *vertices;
|
||||
u64 capacity;
|
||||
u64 max_vertex_ever;
|
||||
u64 vertex_count;
|
||||
} PrGraph;
|
||||
|
||||
void prGraphInit(PrGraph *graph, WpAllocator *allocator, u64 capacity);
|
||||
void prGraphDestroy(PrGraph *graph);
|
||||
void prGraphAddVertex(PrGraph *graph, u64 idx);
|
||||
void prGraphRemoveVertex(PrGraph *graph, u64 idx);
|
||||
b8 prGraphAddEdge(PrGraph *graph, u64 from_idx, u64 to_idx);
|
||||
b8 prGraphEdgeExists(const PrGraph *graph, u64 from_idx, u64 to_idx);
|
||||
u64 prGraphVertexCount(const PrGraph *graph);
|
||||
WpU64Array prGraphTopologicalSort(const PrGraph *graph, const WpAllocator *allocator);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // !PR_GRAPH_H
|
||||
@@ -0,0 +1,99 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "pr_node.h"
|
||||
#include "../../vendor/wapp/wapp.h"
|
||||
#include <string.h>
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Node manager lifecycle
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern void prNodeManagerInit(PrNodeManager *mgr, WpAllocator *allocator, u64 capacity) {
|
||||
memset(mgr, 0, sizeof(*mgr));
|
||||
mgr->capacity = capacity;
|
||||
|
||||
mgr->nodes = wpArrayAllocCapacity(PrNode, allocator, capacity, WP_ARRAY_INIT_FILLED);
|
||||
if (!mgr->nodes) {
|
||||
mgr->capacity = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
mgr->free_head = 0;
|
||||
for (u64 i = 0; i < capacity; ++i) {
|
||||
mgr->nodes[i].next_free = i < capacity - 1 ? i + 1 : INVALID_NODE_INDEX;
|
||||
}
|
||||
|
||||
prGraphInit(&mgr->graph, allocator, capacity);
|
||||
}
|
||||
|
||||
wp_extern void prNodeManagerDestroy(PrNodeManager *mgr) {
|
||||
prGraphDestroy(&mgr->graph);
|
||||
// nodes are owned by the wapp allocator passed to prNodeManagerInit
|
||||
memset(mgr, 0, sizeof(*mgr));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Handle queries
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern b8 prNodeManagerIsStaleNode(const PrNodeManager *mgr, PrNodeId id) {
|
||||
u64 generation = mgr->nodes[id.index].generation;
|
||||
return id.generation != generation;
|
||||
}
|
||||
|
||||
wp_extern b8 prNodeManagerIsActiveNode(const PrNodeManager *mgr, PrNodeId id) {
|
||||
u64 next_free = mgr->nodes[id.index].next_free;
|
||||
return !prNodeManagerIsStaleNode(mgr, id) && next_free == INVALID_NODE_INDEX;
|
||||
}
|
||||
|
||||
wp_extern PrNodeId prNodeManagerGetNode(const PrNodeManager *mgr, u64 index) {
|
||||
return (PrNodeId){ .index = index, .generation = mgr->nodes[index].generation };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Node lifecycle
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern PrNodeId prNodeManagerAddNode(PrNodeManager *mgr, PrNodeType type) {
|
||||
u64 idx = mgr->free_head;
|
||||
if (idx == INVALID_NODE_INDEX) { return INVALID_NODE_ID; }
|
||||
|
||||
PrNode *node = &mgr->nodes[idx];
|
||||
|
||||
mgr->free_head = node->next_free;
|
||||
node->next_free = INVALID_NODE_INDEX;
|
||||
node->type = type;
|
||||
memset(&node->params, 0, sizeof(node->params));
|
||||
|
||||
mgr->count++;
|
||||
if (idx + 1 > mgr->max_count_ever) { mgr->max_count_ever = idx + 1; }
|
||||
|
||||
prGraphAddVertex(&mgr->graph, idx);
|
||||
|
||||
return (PrNodeId){ .index = idx, .generation = node->generation };
|
||||
}
|
||||
|
||||
wp_extern void prNodeManagerRemoveNode(PrNodeManager *mgr, PrNodeId id) {
|
||||
if (!prNodeManagerIsActiveNode(mgr, id)) { return; }
|
||||
|
||||
// Tear down all edges incident to this node and mark vertex inactive
|
||||
prGraphRemoveVertex(&mgr->graph, id.index);
|
||||
|
||||
// Return node slot to free list with bumped generation
|
||||
PrNode *node = &mgr->nodes[id.index];
|
||||
node->generation++;
|
||||
node->next_free = mgr->free_head;
|
||||
mgr->free_head = id.index;
|
||||
mgr->count--;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Edge management
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern void prNodeManagerAddEdge(PrNodeManager *mgr, PrNodeId from, PrNodeId to) {
|
||||
if (!prNodeManagerIsActiveNode(mgr, from) || !prNodeManagerIsActiveNode(mgr, to)) { return; }
|
||||
if (from.index == to.index) { return; }
|
||||
if (prGraphEdgeExists(&mgr->graph, from.index, to.index)) { return; }
|
||||
prGraphAddEdge(&mgr->graph, from.index, to.index);
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef PR_NODE_H
|
||||
#define PR_NODE_H
|
||||
|
||||
#include "../../vendor/wapp/common/aliases/aliases.h"
|
||||
#include "pr_graph.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Forward declarations
|
||||
typedef struct PrRhiTexture PrRhiTexture;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Constants
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#define INVALID_NODE_INDEX (u64)-1
|
||||
#define INVALID_NODE_ID ((PrNodeId){ .index = INVALID_NODE_INDEX, .generation = INVALID_NODE_INDEX })
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PrNodeType
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef enum {
|
||||
PR_NODE_TYPE_NONE,
|
||||
PR_NODE_TYPE_READ,
|
||||
PR_NODE_TYPE_BLUR,
|
||||
PR_NODE_TYPE_GRADE,
|
||||
PR_NODE_TYPE_BLEND,
|
||||
|
||||
COUNT_NODE_TYPES
|
||||
} PrNodeType;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PrNodeId — generational handle
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct {
|
||||
u64 index;
|
||||
u64 generation;
|
||||
} PrNodeId;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PrNode — compositor node data
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct {
|
||||
union {
|
||||
//WpStr8 path; // READ: texture path
|
||||
f32 radius; // BLUR: radius
|
||||
struct { // GRADE: colour grading
|
||||
f32 gain;
|
||||
f32 offset;
|
||||
f32 power;
|
||||
} grade;
|
||||
u32 mode; // BLEND: 0=over, 1=under, 2=add
|
||||
} params;
|
||||
PrRhiTexture *texture; // READ: persistent KTX texture
|
||||
PrNodeType type;
|
||||
u64 generation;
|
||||
u64 next_free;
|
||||
} PrNode;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// PrNodeManager — owns node data + handle lifecycle + topology
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct {
|
||||
PrNode *nodes;
|
||||
PrGraph graph;
|
||||
u64 capacity;
|
||||
u64 max_count_ever;
|
||||
u64 count;
|
||||
u64 free_head;
|
||||
} PrNodeManager;
|
||||
|
||||
void prNodeManagerInit(PrNodeManager *mgr, WpAllocator *allocator, u64 capacity);
|
||||
void prNodeManagerDestroy(PrNodeManager *mgr);
|
||||
b8 prNodeManagerIsStaleNode(const PrNodeManager *mgr, PrNodeId id);
|
||||
b8 prNodeManagerIsActiveNode(const PrNodeManager *mgr, PrNodeId id);
|
||||
PrNodeId prNodeManagerGetNode(const PrNodeManager *mgr, u64 index);
|
||||
PrNodeId prNodeManagerAddNode(PrNodeManager *mgr, PrNodeType type);
|
||||
void prNodeManagerRemoveNode(PrNodeManager *mgr, PrNodeId id);
|
||||
void prNodeManagerAddEdge(PrNodeManager *mgr, PrNodeId from, PrNodeId to);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // !PR_NODE_H
|
||||
@@ -0,0 +1,358 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "pr_node_eval.h"
|
||||
#include "../rhi/pr_rhi.h"
|
||||
#include "../../vendor/wapp/wapp.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
wp_intern PrNodeTypeEntry _node_type_table_data[COUNT_NODE_TYPES] = {
|
||||
[PR_NODE_TYPE_READ] = {
|
||||
.type = PR_NODE_TYPE_READ,
|
||||
.shader_type = PR_SHADER_TYPE_FRAGMENT,
|
||||
.vertex_shader_path = "assets/shaders/blit.vert.spv",
|
||||
.fragment_shader_path= "assets/shaders/read.frag.spv",
|
||||
.input_count = 1,
|
||||
.output_count = 1,
|
||||
.push_constant_size = 0,
|
||||
},
|
||||
[PR_NODE_TYPE_BLUR] = {
|
||||
.type = PR_NODE_TYPE_BLUR,
|
||||
.shader_type = PR_SHADER_TYPE_FRAGMENT,
|
||||
.vertex_shader_path = "assets/shaders/blit.vert.spv",
|
||||
.fragment_shader_path= "assets/shaders/blur.frag.spv",
|
||||
.input_count = 1,
|
||||
.output_count = 1,
|
||||
.push_constant_size = sizeof(PrBlurPushConstants),
|
||||
},
|
||||
[PR_NODE_TYPE_GRADE] = {
|
||||
.type = PR_NODE_TYPE_GRADE,
|
||||
.shader_type = PR_SHADER_TYPE_FRAGMENT,
|
||||
.vertex_shader_path = "assets/shaders/blit.vert.spv",
|
||||
.fragment_shader_path= "assets/shaders/grade.frag.spv",
|
||||
.input_count = 1,
|
||||
.output_count = 1,
|
||||
.push_constant_size = sizeof(PrGradePushConstants),
|
||||
},
|
||||
[PR_NODE_TYPE_BLEND] = {
|
||||
.type = PR_NODE_TYPE_BLEND,
|
||||
.shader_type = PR_SHADER_TYPE_FRAGMENT,
|
||||
.vertex_shader_path = "assets/shaders/blit.vert.spv",
|
||||
.fragment_shader_path= "assets/shaders/blend.frag.spv",
|
||||
.input_count = 2,
|
||||
.output_count = 1,
|
||||
.push_constant_size = sizeof(PrBlendPushConstants),
|
||||
},
|
||||
};
|
||||
|
||||
PrNodeTypeEntry pr_node_type_table[COUNT_NODE_TYPES];
|
||||
|
||||
wp_persist PrRhiDescriptorPool *_eval_desc_pool;
|
||||
|
||||
wp_intern void *_loadSpirv(const WpAllocator *alloc, const char *path, u64 *out_size) {
|
||||
u64 path_len = strlen(path);
|
||||
WpStr8RO filepath = { path_len, path_len, (c8 *)path };
|
||||
WpFile *f = wpFileOpen(alloc, &filepath, WP_ACCESS_READ);
|
||||
if (!f) {
|
||||
fprintf(stderr, "failed to open SPIR-V: %s\n", path);
|
||||
abort();
|
||||
}
|
||||
i64 file_size = wpFileGetLength(f);
|
||||
if (file_size <= 0) {
|
||||
wpFileClose(f);
|
||||
fprintf(stderr, "empty SPIR-V file: %s\n", path);
|
||||
abort();
|
||||
}
|
||||
void *code = wpMemAllocatorAlloc(alloc, (u64)file_size);
|
||||
if (!code) { wpFileClose(f); abort(); }
|
||||
u64 bytes_read = wpFileRead(code, f, (u64)file_size);
|
||||
wpFileClose(f);
|
||||
if (bytes_read != (u64)file_size) {
|
||||
fprintf(stderr, "short read on SPIR-V: %s\n", path);
|
||||
abort();
|
||||
}
|
||||
*out_size = (u64)file_size;
|
||||
return code;
|
||||
}
|
||||
|
||||
wp_extern void prNodeEvalInit(PrRhiDevice *device, PrRhiFormat output_format) {
|
||||
(void)output_format;
|
||||
memcpy(pr_node_type_table, _node_type_table_data, sizeof(_node_type_table_data));
|
||||
|
||||
for (u32 i = 0; i < COUNT_NODE_TYPES; ++i) {
|
||||
PrNodeTypeEntry *entry = &pr_node_type_table[i];
|
||||
if (entry->shader_type != PR_SHADER_TYPE_FRAGMENT) { continue; }
|
||||
if (!entry->vertex_shader_path || !entry->fragment_shader_path) { continue; }
|
||||
|
||||
// load SPIR-V
|
||||
u64 vert_size = 0, frag_size = 0;
|
||||
void *vert_code = _loadSpirv(&_G_RHI_CONTEXT.allocator, entry->vertex_shader_path, &vert_size);
|
||||
void *frag_code = _loadSpirv(&_G_RHI_CONTEXT.allocator, entry->fragment_shader_path, &frag_size);
|
||||
|
||||
// create shaders
|
||||
entry->vertex_shader = prRhiCreateShader(device, (PrRhiShaderDesc){
|
||||
.spirv_code = vert_code,
|
||||
.spirv_size = vert_size,
|
||||
});
|
||||
entry->fragment_shader = prRhiCreateShader(device, (PrRhiShaderDesc){
|
||||
.spirv_code = frag_code,
|
||||
.spirv_size = frag_size,
|
||||
});
|
||||
|
||||
// free SPIR-V (now owned by Vulkan)
|
||||
wpMemAllocatorFree(&_G_RHI_CONTEXT.allocator, &vert_code, vert_size);
|
||||
wpMemAllocatorFree(&_G_RHI_CONTEXT.allocator, &frag_code, frag_size);
|
||||
|
||||
// create descriptor set layout
|
||||
PrRhiDescriptorSetLayoutBindingArray bindings = NULL;
|
||||
if (entry->input_count > 0) {
|
||||
bindings = wpArrayWithCapacity(PrRhiDescriptorSetLayoutBinding, 4, WP_ARRAY_INIT_NONE);
|
||||
for (u32 b = 0; b < entry->input_count; ++b) {
|
||||
PrRhiDescriptorSetLayoutBinding binding = {
|
||||
.type = PR_RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
||||
.descriptor_count = 1,
|
||||
.stage_flags = PR_RHI_SHADER_STAGE_FRAGMENT,
|
||||
.binding_flags = (PrRhiDescriptorBindingFlag)0,
|
||||
};
|
||||
wpArrayAppendCapped(PrRhiDescriptorSetLayoutBinding, bindings, &binding);
|
||||
}
|
||||
}
|
||||
entry->set_layout = prRhiCreateDescriptorSetLayout(device, (PrRhiDescriptorSetLayoutDesc){
|
||||
.bindings = bindings,
|
||||
});
|
||||
|
||||
// create pipeline layout
|
||||
PrRhiPushConstantRange pc_range = {
|
||||
.stage_flags = PR_RHI_SHADER_STAGE_FRAGMENT,
|
||||
.offset = 0,
|
||||
.size = entry->push_constant_size,
|
||||
};
|
||||
PrRhiDescriptorSetLayoutArray set_layouts = entry->set_layout
|
||||
? wpArray(PrRhiDescriptorSetLayout *, entry->set_layout)
|
||||
: NULL;
|
||||
PrRhiPushConstantRangeArray pc_ranges = entry->push_constant_size > 0
|
||||
? wpArray(PrRhiPushConstantRange, pc_range)
|
||||
: NULL;
|
||||
entry->pipeline_layout = prRhiCreatePipelineLayout(device, (PrRhiPipelineLayoutDesc){
|
||||
.set_layouts = set_layouts,
|
||||
.push_constant_ranges = pc_ranges,
|
||||
});
|
||||
|
||||
// create graphics pipeline
|
||||
// pool textures are always RGBA16F
|
||||
PrRhiFormatArray color_formats = wpArray(PrRhiFormat, PR_RHI_FORMAT_R16G16B16A16_SFLOAT);
|
||||
PrRhiColorBlendAttachmentArray blend_attachments = wpArray(PrRhiColorBlendAttachment,
|
||||
((PrRhiColorBlendAttachment){ .color_write_mask = 0xF }));
|
||||
entry->pipeline = prRhiCreateGraphicsPipeline(device, (PrRhiGraphicsPipelineDesc){
|
||||
.vertex_shader = entry->vertex_shader,
|
||||
.vertex_shader_entry_point = "main",
|
||||
.fragment_shader = entry->fragment_shader,
|
||||
.fragment_shader_entry_point = "main",
|
||||
.vertex_bindings = NULL,
|
||||
.vertex_attributes = NULL,
|
||||
.topology = PR_RHI_TOPOLOGY_TRIANGLE_LIST,
|
||||
.color_attachment_formats = color_formats,
|
||||
.depth_attachment_format = PR_RHI_FORMAT_UNDEFINED,
|
||||
.depth_test_enable = false,
|
||||
.depth_write_enable = false,
|
||||
.depth_compare_op = PR_RHI_COMPARE_OP_ALWAYS,
|
||||
.blend_attachments = blend_attachments,
|
||||
.dynamic_viewport = true,
|
||||
.dynamic_scissor = true,
|
||||
.polygon_mode = PR_RHI_POLYGON_MODE_FILL,
|
||||
.cull_mode = PR_RHI_CULL_MODE_NONE,
|
||||
.front_face = PR_RHI_FRONT_FACE_COUNTER_CLOCKWISE,
|
||||
.line_width = 1.0,
|
||||
.multisample_count = PR_RHI_SAMPLE_COUNT_1,
|
||||
.layout = entry->pipeline_layout,
|
||||
});
|
||||
}
|
||||
|
||||
// create per-frame descriptor pool (reset each frame)
|
||||
PrRhiDescriptorPoolSizeArray pool_sizes = wpArray(PrRhiDescriptorPoolSize,
|
||||
((PrRhiDescriptorPoolSize){ .type = PR_RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptor_count = 64 }));
|
||||
_eval_desc_pool = prRhiCreateDescriptorPool(device, (PrRhiDescriptorPoolDesc){
|
||||
.max_sets = 64,
|
||||
.pool_sizes = pool_sizes,
|
||||
});
|
||||
}
|
||||
|
||||
wp_extern void prNodeEvalDestroy(PrRhiDevice *device) {
|
||||
if (_eval_desc_pool) {
|
||||
prRhiDestroyDescriptorPool(device, _eval_desc_pool);
|
||||
_eval_desc_pool = NULL;
|
||||
}
|
||||
for (u32 i = 0; i < COUNT_NODE_TYPES; ++i) {
|
||||
PrNodeTypeEntry *entry = &pr_node_type_table[i];
|
||||
if (entry->pipeline) {
|
||||
prRhiDestroyPipeline(device, entry->pipeline);
|
||||
entry->pipeline = NULL;
|
||||
}
|
||||
if (entry->pipeline_layout) {
|
||||
prRhiDestroyPipelineLayout(device, entry->pipeline_layout);
|
||||
entry->pipeline_layout = NULL;
|
||||
}
|
||||
if (entry->set_layout) {
|
||||
prRhiDestroyDescriptorSetLayout(device, entry->set_layout);
|
||||
entry->set_layout = NULL;
|
||||
}
|
||||
if (entry->fragment_shader) {
|
||||
prRhiDestroyShader(device, entry->fragment_shader);
|
||||
entry->fragment_shader = NULL;
|
||||
}
|
||||
if (entry->vertex_shader) {
|
||||
prRhiDestroyShader(device, entry->vertex_shader);
|
||||
entry->vertex_shader = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Per-frame evaluation
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern void prGraphEvaluate(PrNodeManager *mgr, PrRhiDevice *device,
|
||||
PrTexturePool *pool, PrRhiCommandBuffer *cb,
|
||||
PrRhiSampler *shared_sampler,
|
||||
PrTextureSlot **out_output) {
|
||||
PrGraph *graph = &mgr->graph;
|
||||
u64 vertex_count = prGraphVertexCount(graph);
|
||||
|
||||
if (out_output) { *out_output = NULL; }
|
||||
|
||||
// 1. topological sort
|
||||
WpAllocator scratch = wpMemArenaAllocatorInitZero(KiB(64));
|
||||
WpU64Array topo = prGraphTopologicalSort(graph, &scratch);
|
||||
u64 topo_count = topo ? wpArrayCount(topo) : 0;
|
||||
|
||||
// 2. compute initial refcounts (out-degree per node)
|
||||
u32 *refcounts = wpMemAllocatorAlloc(&scratch, vertex_count * sizeof(u32));
|
||||
memset(refcounts, 0, vertex_count * sizeof(u32));
|
||||
for (u64 i = 0; i < graph->max_vertex_ever; ++i) {
|
||||
if (!graph->vertices[i].active) { continue; }
|
||||
PrGraphEdge *edge = graph->vertices[i].next_forward;
|
||||
while (edge) {
|
||||
refcounts[i]++;
|
||||
edge = edge->next_forward;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. reset texture pool and descriptor pool
|
||||
prTexturePoolReset(pool);
|
||||
if (_eval_desc_pool) {
|
||||
prRhiResetDescriptorPool(device, _eval_desc_pool);
|
||||
}
|
||||
|
||||
// output slot per node (transient, lives in scratch arena)
|
||||
PrTextureSlot **output_slots = wpMemAllocatorAlloc(&scratch, vertex_count * sizeof(PrTextureSlot *));
|
||||
memset(output_slots, 0, vertex_count * sizeof(PrTextureSlot *));
|
||||
|
||||
// 4. for each node in topological order
|
||||
for (u64 t = 0; t < topo_count; ++t) {
|
||||
u64 node_idx = topo[t];
|
||||
PrNode *node = &mgr->nodes[node_idx];
|
||||
if (node->generation == 0) { continue; } // inactive node
|
||||
|
||||
PrNodeTypeEntry *entry = &pr_node_type_table[node->type];
|
||||
|
||||
// acquire output texture
|
||||
PrTextureSlot *output_slot = prTexturePoolAcquire(pool, device);
|
||||
if (!output_slot) { abort(); }
|
||||
|
||||
// gather input textures (predecessors via backward edges)
|
||||
PrTextureSlot *input_slots[4];
|
||||
u32 input_count = 0;
|
||||
PrGraphEdge *edge = graph->vertices[node_idx].next_backward;
|
||||
while (edge && input_count < 4) {
|
||||
u64 src_idx = edge->source_idx;
|
||||
if (output_slots[src_idx]) {
|
||||
input_slots[input_count++] = output_slots[src_idx];
|
||||
}
|
||||
edge = edge->next_backward;
|
||||
}
|
||||
// READ nodes: use the node's own persistent texture if no edges
|
||||
if (input_count == 0 && node->texture) {
|
||||
input_slots[0] = NULL;
|
||||
input_count = 1;
|
||||
}
|
||||
|
||||
// allocate descriptor set (skip for nodes with no inputs)
|
||||
PrRhiDescriptorSet *desc_set = NULL;
|
||||
if (entry->input_count > 0 && input_count > 0) {
|
||||
desc_set = prRhiAllocateDescriptorSet(device, _eval_desc_pool, entry->set_layout, NULL);
|
||||
|
||||
// build write descriptors
|
||||
PrRhiDescriptorImageInfo image_infos[4];
|
||||
PrRhiWriteDescriptorSet writes[4];
|
||||
for (u32 i = 0; i < input_count; ++i) {
|
||||
PrRhiTexture *tex = input_slots[i] ? input_slots[i]->texture : node->texture;
|
||||
image_infos[i] = (PrRhiDescriptorImageInfo){
|
||||
.texture = tex,
|
||||
.sampler = shared_sampler,
|
||||
.layout = PR_RHI_LAYOUT_READ_ONLY_OPTIMAL,
|
||||
};
|
||||
writes[i] = (PrRhiWriteDescriptorSet){
|
||||
.dst_set = desc_set,
|
||||
.dst_binding = i,
|
||||
.dst_array_element= 0,
|
||||
.type = PR_RHI_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
||||
.image_info = &image_infos[i],
|
||||
.buffer_info = NULL,
|
||||
};
|
||||
}
|
||||
prRhiUpdateDescriptorSet(device, writes);
|
||||
}
|
||||
|
||||
// record commands
|
||||
PrRhiColorAttachment color_att = {
|
||||
.texture = output_slot->texture,
|
||||
.layout = PR_RHI_LAYOUT_ATTACHMENT_OPTIMAL,
|
||||
.clear = true,
|
||||
.clear_color = {0.0f, 0.0f, 0.0f, 0.0f},
|
||||
};
|
||||
prRhiCmdBeginRendering(cb, &color_att, NULL);
|
||||
prRhiCmdBindPipeline(cb, PR_RHI_PIPELINE_BIND_POINT_GRAPHICS, entry->pipeline);
|
||||
prRhiCmdSetViewport(cb, 0.0f, 0.0f, (f32)pool->width, (f32)pool->height);
|
||||
prRhiCmdSetScissor(cb, 0, 0, pool->width, pool->height);
|
||||
|
||||
if (desc_set) {
|
||||
PrRhiDescriptorSet *sets_arr[1] = { desc_set };
|
||||
prRhiCmdBindDescriptorSets(cb, PR_RHI_PIPELINE_BIND_POINT_GRAPHICS,
|
||||
entry->pipeline_layout, 0, sets_arr);
|
||||
}
|
||||
|
||||
// push constants
|
||||
if (entry->push_constant_size > 0) {
|
||||
prRhiCmdPushConstants(cb, entry->pipeline_layout,
|
||||
PR_RHI_SHADER_STAGE_FRAGMENT, 0,
|
||||
entry->push_constant_size, &node->params);
|
||||
}
|
||||
|
||||
prRhiCmdDraw(cb, 3, 1, 0, 0);
|
||||
prRhiCmdEndRendering(cb);
|
||||
|
||||
// release input textures whose refcount hit 0
|
||||
edge = graph->vertices[node_idx].next_backward;
|
||||
u32 input_idx = 0;
|
||||
while (edge && input_idx < input_count) {
|
||||
u64 src_idx = edge->source_idx;
|
||||
if (refcounts[src_idx] > 0) {
|
||||
refcounts[src_idx]--;
|
||||
if (refcounts[src_idx] == 0) {
|
||||
prTexturePoolRelease(pool, output_slots[src_idx]);
|
||||
}
|
||||
}
|
||||
edge = edge->next_backward;
|
||||
input_idx++;
|
||||
}
|
||||
|
||||
output_slots[node_idx] = output_slot;
|
||||
}
|
||||
|
||||
// Return the last node's output as the compositor output
|
||||
if (out_output && topo_count > 0) {
|
||||
u64 last_idx = topo[topo_count - 1];
|
||||
*out_output = output_slots[last_idx];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef PR_NODE_EVAL_H
|
||||
#define PR_NODE_EVAL_H
|
||||
|
||||
#include "../../vendor/wapp/common/aliases/aliases.h"
|
||||
#include "../rhi/pr_rhi_types.h"
|
||||
#include "pr_node.h"
|
||||
#include "pr_texture_pool.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Shader type
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef enum PrShaderType {
|
||||
PR_SHADER_TYPE_FRAGMENT, // fullscreen triangle, per-pixel
|
||||
PR_SHADER_TYPE_COMPUTE, // dispatch, shared memory
|
||||
} PrShaderType;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Push constant structs (one per node type)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct {
|
||||
f32 radius;
|
||||
} PrBlurPushConstants;
|
||||
|
||||
typedef struct {
|
||||
f32 gain;
|
||||
f32 offset;
|
||||
f32 power;
|
||||
} PrGradePushConstants;
|
||||
|
||||
typedef struct {
|
||||
u32 mode; // 0=over, 1=under, 2=add
|
||||
} PrBlendPushConstants;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Node type entry — maps a node type to its resource signature
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
typedef struct PrNodeTypeEntry {
|
||||
PrNodeType type;
|
||||
PrShaderType shader_type;
|
||||
|
||||
// shader paths (pre-compiled SPIR-V, built from .slang via slangc)
|
||||
const char *vertex_shader_path; // NULL for compute
|
||||
const char *fragment_shader_path; // NULL for compute
|
||||
const char *compute_shader_path; // NULL for fragment
|
||||
|
||||
// resource signature
|
||||
u32 input_count; // number of texture inputs
|
||||
u32 output_count; // always 1 for V1
|
||||
|
||||
// push constant size (bytes)
|
||||
u32 push_constant_size;
|
||||
|
||||
// created at init, cached here
|
||||
PrRhiShader *vertex_shader;
|
||||
PrRhiShader *fragment_shader;
|
||||
PrRhiDescriptorSetLayout *set_layout;
|
||||
PrRhiPipelineLayout *pipeline_layout;
|
||||
PrRhiPipeline *pipeline;
|
||||
} PrNodeTypeEntry;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Global registry
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
extern PrNodeTypeEntry pr_node_type_table[COUNT_NODE_TYPES];
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Evaluation
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
wp_extern void prNodeEvalInit(PrRhiDevice *device, PrRhiFormat output_format);
|
||||
wp_extern void prNodeEvalDestroy(PrRhiDevice *device);
|
||||
|
||||
// Per-frame graph evaluation. Records commands into cb.
|
||||
// pool is reset each frame. desc_pool is reset each frame.
|
||||
// out_output receives the final compositor output slot (last node in topo order).
|
||||
wp_extern void prGraphEvaluate(PrNodeManager *mgr, PrRhiDevice *device,
|
||||
PrTexturePool *pool, PrRhiCommandBuffer *cb,
|
||||
PrRhiSampler *shared_sampler,
|
||||
PrTextureSlot **out_output);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // !PR_NODE_EVAL_H
|
||||
@@ -0,0 +1,101 @@
|
||||
#include "pr_texture_pool.h"
|
||||
#include "../rhi/pr_rhi.h"
|
||||
#include "../../vendor/wapp/wapp.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
wp_intern b8 _growPool(PrTexturePool *pool, PrRhiDevice *device) {
|
||||
u32 old_count = pool->count;
|
||||
u32 new_count = old_count + PR_TEXTURE_POOL_GROWTH_BATCH;
|
||||
if (new_count > pool->max) { new_count = pool->max; }
|
||||
if (old_count >= pool->max) {
|
||||
fprintf(stderr, "texture pool exhausted: %u in use, max %u\n", pool->in_use, pool->max);
|
||||
abort();
|
||||
}
|
||||
|
||||
PrTextureSlot *new_slots = wpArrayAllocCapacity(PrTextureSlot, pool->alloc, new_count, WP_ARRAY_INIT_FILLED);
|
||||
if (!new_slots) { return false; }
|
||||
if (pool->slots) {
|
||||
memcpy(new_slots, pool->slots, old_count * sizeof(PrTextureSlot));
|
||||
wpArrayDealloc(PrTextureSlot, pool->alloc, &pool->slots);
|
||||
}
|
||||
pool->slots = new_slots;
|
||||
|
||||
for (u32 i = old_count; i < new_count; ++i) {
|
||||
PrRhiTextureDesc desc = {
|
||||
.format = PR_RHI_FORMAT_R16G16B16A16_SFLOAT,
|
||||
.width = pool->width,
|
||||
.height = pool->height,
|
||||
.mip_levels = 1,
|
||||
.usage = PR_RHI_TEXTURE_USAGE_SAMPLED | PR_RHI_TEXTURE_USAGE_COLOR_ATTACHMENT,
|
||||
};
|
||||
PrRhiTexture *tex = prRhiCreateTexture(device, desc);
|
||||
if (!tex) { return false; }
|
||||
pool->slots[i].texture = tex;
|
||||
pool->slots[i].refcount = 0;
|
||||
pool->slots[i].in_use = false;
|
||||
}
|
||||
pool->count = new_count;
|
||||
return true;
|
||||
}
|
||||
|
||||
wp_extern void prTexturePoolInit(PrTexturePool *pool, u32 initial_capacity, u32 max, u32 width, u32 height, const WpAllocator *alloc) {
|
||||
pool->alloc = alloc;
|
||||
pool->slots = NULL;
|
||||
pool->count = 0;
|
||||
pool->in_use = 0;
|
||||
pool->max = max;
|
||||
pool->width = width;
|
||||
pool->height = height;
|
||||
if (initial_capacity > 0) {
|
||||
pool->slots = wpArrayAllocCapacity(PrTextureSlot, alloc, initial_capacity, WP_ARRAY_INIT_FILLED);
|
||||
if (!pool->slots) {
|
||||
fprintf(stderr, "texture pool initial allocation failed\n");
|
||||
abort();
|
||||
}
|
||||
pool->count = initial_capacity;
|
||||
}
|
||||
}
|
||||
|
||||
wp_extern void prTexturePoolReset(PrTexturePool *pool) {
|
||||
for (u32 i = 0; i < pool->count; ++i) {
|
||||
pool->slots[i].refcount = 0;
|
||||
pool->slots[i].in_use = false;
|
||||
}
|
||||
pool->in_use = 0;
|
||||
}
|
||||
|
||||
wp_extern PrTextureSlot *prTexturePoolAcquire(PrTexturePool *pool, PrRhiDevice *device) {
|
||||
for (u32 i = 0; i < pool->count; ++i) {
|
||||
if (!pool->slots[i].in_use) {
|
||||
pool->slots[i].in_use = true;
|
||||
pool->in_use += 1;
|
||||
return &pool->slots[i];
|
||||
}
|
||||
}
|
||||
if (!_growPool(pool, device)) { return NULL; }
|
||||
PrTextureSlot *slot = &pool->slots[pool->count - 1];
|
||||
slot->in_use = true;
|
||||
pool->in_use += 1;
|
||||
return slot;
|
||||
}
|
||||
|
||||
wp_extern void prTexturePoolRelease(PrTexturePool *pool, PrTextureSlot *slot) {
|
||||
(void)pool;
|
||||
slot->refcount = 0;
|
||||
slot->in_use = false;
|
||||
pool->in_use -= 1;
|
||||
}
|
||||
|
||||
wp_extern void prTexturePoolDestroy(PrTexturePool *pool, PrRhiDevice *device) {
|
||||
for (u32 i = 0; i < pool->count; ++i) {
|
||||
if (pool->slots[i].texture) {
|
||||
prRhiDestroyTexture(device, pool->slots[i].texture);
|
||||
}
|
||||
}
|
||||
if (pool->slots) { wpArrayDealloc(PrTextureSlot, pool->alloc, &pool->slots); }
|
||||
pool->slots = NULL;
|
||||
pool->count = 0;
|
||||
pool->in_use = 0;
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
#ifndef PR_TEXTURE_POOL_H
|
||||
#define PR_TEXTURE_POOL_H
|
||||
|
||||
#include "../rhi/pr_rhi_types.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define PR_TEXTURE_POOL_GROWTH_BATCH 8
|
||||
|
||||
typedef struct PrTextureSlot {
|
||||
PrRhiTexture *texture;
|
||||
u32 refcount;
|
||||
b8 in_use;
|
||||
} PrTextureSlot;
|
||||
|
||||
typedef struct PrTexturePool {
|
||||
PrTextureSlot *slots;
|
||||
const WpAllocator *alloc;
|
||||
u32 count;
|
||||
u32 in_use;
|
||||
u32 max;
|
||||
u32 width;
|
||||
u32 height;
|
||||
} PrTexturePool;
|
||||
|
||||
wp_extern void prTexturePoolInit(PrTexturePool *pool, u32 initial_capacity, u32 max, u32 width, u32 height, const WpAllocator *alloc);
|
||||
wp_extern void prTexturePoolReset(PrTexturePool *pool);
|
||||
wp_extern PrTextureSlot *prTexturePoolAcquire(PrTexturePool *pool, PrRhiDevice *device);
|
||||
wp_extern void prTexturePoolRelease(PrTexturePool *pool, PrTextureSlot *slot);
|
||||
wp_extern void prTexturePoolDestroy(PrTexturePool *pool, PrRhiDevice *device);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -162,6 +162,8 @@ PrRhiDescriptorPool *prRhiCreateDescriptorPool(PrRhiDevice *device,
|
||||
PrRhiDescriptorPoolDesc desc);
|
||||
void prRhiDestroyDescriptorPool(PrRhiDevice *device,
|
||||
PrRhiDescriptorPool *pool);
|
||||
void prRhiResetDescriptorPool(PrRhiDevice *device,
|
||||
PrRhiDescriptorPool *pool);
|
||||
|
||||
// ======================================================================
|
||||
// Descriptor sets
|
||||
|
||||
@@ -1399,27 +1399,33 @@ PrRhiPipelineLayout *prRhiCreatePipelineLayoutVk(PrRhiDevice *device,
|
||||
u32 layout_count = (desc.set_layouts && wpArrayCount(desc.set_layouts) > 0)
|
||||
? (u32)wpArrayCount(desc.set_layouts) : 0;
|
||||
|
||||
VkDescriptorSetLayoutArray vk_layouts =
|
||||
wpArrayAllocCapacity(VkDescriptorSetLayout, &_G_RHI_CONTEXT.allocator, layout_count,
|
||||
WP_ARRAY_INIT_FILLED);
|
||||
if (!vk_layouts) { _abort("alloc failed for VkDescriptorSetLayout array"); }
|
||||
VkDescriptorSetLayoutArray vk_layouts = NULL;
|
||||
if (layout_count > 0) {
|
||||
vk_layouts =
|
||||
wpArrayAllocCapacity(VkDescriptorSetLayout, &_G_RHI_CONTEXT.allocator, layout_count,
|
||||
WP_ARRAY_INIT_FILLED);
|
||||
if (!vk_layouts) { _abort("alloc failed for VkDescriptorSetLayout array"); }
|
||||
|
||||
for (u32 i = 0; i < layout_count; ++i) {
|
||||
vk_layouts[i] = desc.set_layouts[i]->handle;
|
||||
for (u32 i = 0; i < layout_count; ++i) {
|
||||
vk_layouts[i] = desc.set_layouts[i]->handle;
|
||||
}
|
||||
}
|
||||
|
||||
// Gather push constant ranges
|
||||
u32 pc_count = (desc.push_constant_ranges && wpArrayCount(desc.push_constant_ranges) > 0)
|
||||
? (u32)wpArrayCount(desc.push_constant_ranges) : 0;
|
||||
|
||||
VkPushConstantRangeArray pc_ranges =
|
||||
wpArrayAllocCapacity(VkPushConstantRange, &_G_RHI_CONTEXT.allocator, pc_count, WP_ARRAY_INIT_NONE);
|
||||
if (!pc_ranges) { _abort("alloc failed for VkPushConstantRange array"); }
|
||||
VkPushConstantRangeArray pc_ranges = NULL;
|
||||
if (pc_count > 0) {
|
||||
pc_ranges =
|
||||
wpArrayAllocCapacity(VkPushConstantRange, &_G_RHI_CONTEXT.allocator, pc_count, WP_ARRAY_INIT_NONE);
|
||||
if (!pc_ranges) { _abort("alloc failed for VkPushConstantRange array"); }
|
||||
|
||||
for (u32 i = 0; i < pc_count; ++i) {
|
||||
pc_ranges[i].stageFlags = _toVkShaderStage(desc.push_constant_ranges[i].stage_flags);
|
||||
pc_ranges[i].offset = desc.push_constant_ranges[i].offset;
|
||||
pc_ranges[i].size = desc.push_constant_ranges[i].size;
|
||||
for (u32 i = 0; i < pc_count; ++i) {
|
||||
pc_ranges[i].stageFlags = _toVkShaderStage(desc.push_constant_ranges[i].stage_flags);
|
||||
pc_ranges[i].offset = desc.push_constant_ranges[i].offset;
|
||||
pc_ranges[i].size = desc.push_constant_ranges[i].size;
|
||||
}
|
||||
}
|
||||
|
||||
VkPipelineLayoutCreateInfo pl_info = {
|
||||
@@ -1433,8 +1439,8 @@ PrRhiPipelineLayout *prRhiCreatePipelineLayoutVk(PrRhiDevice *device,
|
||||
VkPipelineLayout vk_layout = VK_NULL_HANDLE;
|
||||
_checkVk(vkCreatePipelineLayout(vk_device, &pl_info, NULL, &vk_layout), "vkCreatePipelineLayout");
|
||||
|
||||
wpArrayDealloc(VkDescriptorSetLayout, &_G_RHI_CONTEXT.allocator, &vk_layouts);
|
||||
wpArrayDealloc(VkPushConstantRange, &_G_RHI_CONTEXT.allocator, &pc_ranges);
|
||||
if (vk_layouts) { wpArrayDealloc(VkDescriptorSetLayout, &_G_RHI_CONTEXT.allocator, &vk_layouts); }
|
||||
if (pc_ranges) { wpArrayDealloc(VkPushConstantRange, &_G_RHI_CONTEXT.allocator, &pc_ranges); }
|
||||
|
||||
PrRhiPipelineLayout *layout = wpMemAllocatorAlloc(&_G_RHI_CONTEXT.allocator, sizeof(PrRhiPipelineLayout));
|
||||
if (!layout) { _abort("alloc failed for PrRhiPipelineLayout"); }
|
||||
@@ -1758,6 +1764,10 @@ void prRhiDestroyDescriptorPoolVk(PrRhiDevice *device, PrRhiDescriptorPool *pool
|
||||
wpMemAllocatorFree(&_G_RHI_CONTEXT.allocator, (void**)&pool, sizeof(PrRhiDescriptorPool));
|
||||
}
|
||||
|
||||
void prRhiResetDescriptorPoolVk(PrRhiDevice *device, PrRhiDescriptorPool *pool) {
|
||||
vkResetDescriptorPool(device->handle, pool->handle, 0);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Descriptor sets
|
||||
// ============================================================================
|
||||
|
||||
@@ -193,6 +193,8 @@ PrRhiDescriptorPool *prRhiCreateDescriptorPoolVk(PrRhiDevice *device,
|
||||
PrRhiDescriptorPoolDesc desc);
|
||||
void prRhiDestroyDescriptorPoolVk(PrRhiDevice *device,
|
||||
PrRhiDescriptorPool *pool);
|
||||
void prRhiResetDescriptorPoolVk(PrRhiDevice *device,
|
||||
PrRhiDescriptorPool *pool);
|
||||
|
||||
PrRhiDescriptorSet *prRhiAllocateDescriptorSetVk(PrRhiDevice *device,
|
||||
PrRhiDescriptorPool *pool,
|
||||
|
||||
@@ -48,6 +48,7 @@
|
||||
#define prRhiDestroyDescriptorSetLayout prRhiDestroyDescriptorSetLayoutVk
|
||||
#define prRhiCreateDescriptorPool prRhiCreateDescriptorPoolVk
|
||||
#define prRhiDestroyDescriptorPool prRhiDestroyDescriptorPoolVk
|
||||
#define prRhiResetDescriptorPool prRhiResetDescriptorPoolVk
|
||||
#define prRhiAllocateDescriptorSet prRhiAllocateDescriptorSetVk
|
||||
#define prRhiFreeDescriptorSet prRhiFreeDescriptorSetVk
|
||||
#define prRhiUpdateDescriptorSet prRhiUpdateDescriptorSetVk
|
||||
|
||||
Reference in New Issue
Block a user