sleepy-day/Gears-C
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup of old code from pre-refactor

Browse Source
This commit is contained in:
Matthew 2025-05-11 21:25:38 +10:00
parent c4ce5328ef
commit f0e44b5c37
3 changed files with 0 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/platform/platform_linux_public.c
View File

@ -341,36 +341,4 @@ DefScalarImpl(AtomicLoad);
DefScalarImpl(AtomicFetchSub); DefScalarImpl(AtomicFetchSub);
DefScalarImpl(AtomicCompareExchange); DefScalarImpl(AtomicCompareExchange);
/*
static inline u32 AtomicFetchIncrU32(u32 *ptr)
{
return __atomic_fetch_add(ptr, 1, __ATOMIC_ACQUIRE);
}
static inline void AtomicIncrU32(u32 *ptr)
{
__atomic_fetch_add(ptr, 1, __ATOMIC_RELEASE);
}
static inline u32 AtomicLoadU32(u32 *ptr)
{
return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);
}
static inline u32 AtomicFetchSubU32(u32 *ptr, u32 count)
{
return __atomic_sub_fetch(ptr, count, __ATOMIC_ACQUIRE);
}
static inline b32 AtomicCompareExchangeU32(u32 *ptr, u32 *expected, u32 desired)
{
return __atomic_compare_exchange_n(ptr, expected, desired, true, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
}
static inline b32 AtomicCompareExchangeB32(b32 *ptr, b32 *expected, b32 desired)
{
return __atomic_compare_exchange_n(ptr, expected, desired, true, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
}
*/
// ::Platform::Atomics::Functions::End:: // ::Platform::Atomics::Functions::End::

264
src/renderer_vulkan.c
View File

@ -21,22 +21,6 @@ b32 v_rdoc_captured = false;
#endif #endif
/*
static vRenderer renderer = {
.vk = {
.queues = {
.graphics = -1,
.transfer = -1,
},
.sc = {
.format = INT_MAX,
.color_space = INT_MAX,
.present_mode = INT_MAX,
},
}
};
*/
// ::Vulkan::Globals::End:: // ::Vulkan::Globals::End::
@ -467,163 +451,6 @@ static vImageView *vImageSearch(TextureAsset asset_id)
return view; return view;
} }
static b32 vSamplerCreate(rTextureBuffer *buffer)
{
/*
b32 success = true;
vImage *image = &buffer->image;
rRenderBuffer staging_buffer = {
.type = rRBT_STAGING,
.size = buffer->width * buffer->height,
};
VmaAllocationCreateInfo alloc_create_info = {
.usage = VMA_MEMORY_USAGE_GPU_ONLY,
.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
};
VkImageCreateInfo image_info = {
.sType = STYPE(IMAGE_CREATE_INFO),
.imageType = VK_IMAGE_TYPE_2D,
.mipLevels = 1,
.arrayLayers = 1,
.format = VK_FORMAT_R8G8B8A8_SRGB,
.tiling = VK_IMAGE_TILING_OPTIMAL,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.samples = VK_SAMPLE_COUNT_1_BIT,
.extent = {
.width = buffer->width,
.height = buffer->height,
.depth = 1,
},
};
if (v_Renderer.state.vk.gfx_queue_idx != v_Renderer.state.vk.tfer_queue_idx)
{
image_info.sharingMode = VK_SHARING_MODE_CONCURRENT;
image_info.queueFamilyIndexCount = 2;
image_info.pQueueFamilyIndices = (u32[]){v_Renderer.state.vk.gfx_queue_idx, v_Renderer.state.vk.tfer_queue_idx};
}
VkResult result = vmaCreateImage(v_Renderer.handles.vma_alloc, &image_info,
&alloc_create_info, &image->img, &image->alloc, NULL);
if (result != VK_SUCCESS)
{
success = false;
Printfln("vmaCreateImage failure: %s", vVkResultStr(result));
}
if (success)
{
image->curr_layout = VK_IMAGE_LAYOUT_UNDEFINED;
VkImageViewCreateInfo view_info = {
.sType = STYPE(IMAGE_VIEW_CREATE_INFO),
.image = image->img,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = VK_FORMAT_R8G8B8A8_SRGB,
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.levelCount = 1,
.layerCount = 1,
}
};
result = vkCreateImageView(v_Renderer.handles.device, &view_info, NULL, &image->view);
if (result != VK_SUCCESS)
success = false;
}
if (success)
{
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(v_Renderer.handles.phys_device, &properties);
// TODO: handle no anisotropy
VkSamplerCreateInfo sampler_info = {
.sType = STYPE(SAMPLER_CREATE_INFO),
.magFilter = VK_FILTER_LINEAR,
.minFilter = VK_FILTER_LINEAR,
.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.anisotropyEnable = VK_TRUE,
.maxAnisotropy = properties.limits.maxSamplerAnisotropy,
.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
.compareOp = VK_COMPARE_OP_ALWAYS,
.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
};
result = vkCreateSampler(v_Renderer.handles.device, &sampler_info, NULL, &image->sampler);
if (result != VK_SUCCESS)
success = false;
}
return success;
*/
return false;
}
static void vImageUpload(rTextureBuffer *buffer, u8 *data, u32 thread_idx)
{
/*
b32 success = true;
VkDevice device = v_Renderer.handles.device;
VkCommandBuffer cmd = renderer.vk.imm.cmds[thread_idx];
VkFence fence = renderer.vk.imm.fences[thread_idx];
VkQueue queue = renderer.vk.queues.transfer_queue;
vImage *image = &buffer->image;
u32 width = buffer->width;
u32 height = buffer->height;
u32 channels = buffer->channels;
rRenderBuffer staging_buffer = {
.type = rRBT_STAGING,
.size = width * height * channels,
};
vImageTransition(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
success = vImmSubmitBegin(device, fence, cmd);
// TODO: FIX
//if (success)
//Assert(rBufferCreate(&staging_buffer), "vImageUpload failure: error creating buffer");
if (success)
{
rawptr mapped_buf = NULL;
vmaMapMemory(v_Renderer.handles.vma_alloc, staging_buffer.alloc, &mapped_buf);
MemCpy(mapped_buf, data, width * height * channels);
VkBufferImageCopy buffer_copy = {
.bufferRowLength = width,
.bufferImageHeight = height,
.imageSubresource = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.layerCount = 1,
},
.imageExtent = {
.width = width,
.height = height,
.depth = 1,
},
};
vkCmdCopyBufferToImage(cmd, staging_buffer.buffer, image->img, image->curr_layout, 1, &buffer_copy);
vmaUnmapMemory(v_Renderer.handles.vma_alloc, staging_buffer.alloc);
vmaDestroyBuffer(v_Renderer.handles.vma_alloc, staging_buffer.buffer, staging_buffer.alloc);
success = vImmSubmitFinish(device, fence, cmd, queue);
}
*/
}
// ::Vulkan::Images::Functions::End:: // ::Vulkan::Images::Functions::End::
@ -1865,97 +1692,6 @@ static void vLoaderStartThreads()
// ::Vulkan::Async::Functions::Start:: // ::Vulkan::Async::Functions::Start::
static u32 vLoaderProcessBuffers(u32 thread_index)
{
/*
JobQueue *job_queue = &renderer.upload_queues[vDT_MATERIAL].job_queue;
TicketMut *ticket_mut = &renderer.upload_queues[vDT_MATERIAL].ticket_mut;
rRenderBuffer **render_buffers = renderer.upload_queues[vDT_MATERIAL].queued_buffers;
rawptr *buffer_data = renderer.upload_queues[vDT_MATERIAL].data;
u32 buffer_count = JobQueueGetCount(job_queue);
u32 count = 0;
if (buffer_count > 0)
{
TicketMutLock(ticket_mut);
rRenderBuffer *buffers[16];
rawptr data[16];
for (i32 i = i32(buffer_count - 1); i >= 0 && count < 16; i--)
{
buffers[count] = render_buffers[i];
data[count] = buffer_data[i];
count += 1;
}
JobQueueMarkUnqueued(job_queue, count);
TicketMutUnlock(ticket_mut);
// TODO: FIX
//for (u32 i = 0; i < count; i++)
//Assert(rBufferCreate(buffers[i]), "vLoaderProcessBuffers failure: rBufferCreate failed");
Assert(rBufferUpload(buffers, data, count, thread_index), "vLoaderProcessBuffers failure: rBufferUpload failed");
JobQueueMarkCompleted(job_queue, count);
}
return count;
*/
return 0;
}
static u32 vLoaderProcessSamplers(u32 thread_index)
{
/*
JobQueue *job_queue = &renderer.upload_queues[vDT_SAMPLED_IMAGE].job_queue;
TicketMut *ticket_mut = &renderer.upload_queues[vDT_SAMPLED_IMAGE].ticket_mut;
rTextureBuffer **texture_buffers = renderer.upload_queues[vDT_SAMPLED_IMAGE].queued_textures;
rawptr *texture_data = renderer.upload_queues[vDT_SAMPLED_IMAGE].data;
u32 buffer_count = JobQueueGetCount(job_queue);
u32 count = 0;
if (buffer_count > 0)
{
TicketMutLock(ticket_mut);
rTextureBuffer *buffers[16];
rawptr data[16];
for (i32 i = i32(buffer_count - 1); i >= 0 && count < 16; i--)
{
buffers[count] = texture_buffers[i];
data[count] = texture_data[i];
count += 1;
}
JobQueueMarkUnqueued(job_queue, count);
TicketMutUnlock(ticket_mut);
for (u32 i = 0; i < count; i++)
{
Assert(vSamplerCreate(buffers[i]), "Unable to create VkSampler");
vImageUpload(buffers[i], data[i], thread_index);
}
JobQueueMarkCompleted(job_queue, count);
for (u32 i = 0; i < count; i++)
{
FLMemFree(buffers[i]);
}
}
return count;
*/
return 0;
}
static void vTransferUpload(vTransfer **transfers, u32 count, u32 idx) static void vTransferUpload(vTransfer **transfers, u32 count, u32 idx)
{ {
VkCommandPool pool = v_Renderer.imm_handles.data[idx].pool; VkCommandPool pool = v_Renderer.imm_handles.data[idx].pool;

4
src/renderer_vulkan.h
View File

@ -527,8 +527,6 @@ static inline void vImageCopyToImage(VkCommandBuffer cmd, VkImage src, VkImage d
static void vBufferQueueWait(); static void vBufferQueueWait();
static void vLoaderWake(); static void vLoaderWake();
static u32 vLoaderProcessBuffers(u32 thread_index);
static u32 vLoaderProcessSamplers(u32 thread_index);
#ifdef __linux__ #ifdef __linux__
void *vLoaderStart(void *thread_data); void *vLoaderStart(void *thread_data);
@ -553,8 +551,6 @@ static void vSwapchainResize();
static b32 vImageViewCreate(vImageView *view, u32 width, u32 height, u32 channels); static b32 vImageViewCreate(vImageView *view, u32 width, u32 height, u32 channels);
static void vTextureCleanUp(vImageView *view); static void vTextureCleanUp(vImageView *view);
static b32 vSamplerCreate(rTextureBuffer *buffer);
static void vImageUpload(rTextureBuffer *buffer, u8 *data, u32 thread_idx);
static void vImagePush(TextureAsset asset_id, vImageView *view); static void vImagePush(TextureAsset asset_id, vImageView *view);
static vImageView *vImageSearch(TextureAsset asset_id); static vImageView *vImageSearch(TextureAsset asset_id);