kbz_8/Pulse
1
0
Fork 0
mirror of https://github.com/Kbz-8/Pulse.git synced 2026-01-11 15:33:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

adding CI

Browse Source
This commit is contained in:
kbz_8
2025-01-12 20:25:13 +01:00
parent 4bd57a2a51
commit 8c00af0443
18 changed files with 710 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
.github/workflows/linux-build.yml vendored git.filemode.normal_file
View File

@@ -0,0 +1,97 @@
name: Linux build
on:
pull_request:
push:
paths-ignore:
- '.github/workflows/macos-build.yml'
- '.github/workflows/msys2-build.yml'
- '.github/workflows/windows-build.yml'
- '.gitignore'
- 'LICENSE'
- 'CHANGELOG.md'
- 'README.md'
jobs:
build:
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest]
arch: [x86_64]
kind: [shared, static]
confs:
- { mode: debug, archive: yes }
- { mode: debug, config: --asan=y, archive: false, cache_key: -asan }
- { mode: debug, config: --lsan=y, archive: false }
- { mode: debug, config: --tsan=y, archive: false }
- { mode: release, archive: yes }
runs-on: ${{ matrix.os }}
if: ${{ !contains(github.event.head_commit.message, 'ci skip') }}
steps:
- name: Get current date as package key
id: cache_key
run: echo "key=$(date +'%W')" >> $GITHUB_OUTPUT
- name: Checkout repository
uses: actions/checkout@v4
# Install system dependencies
- name: Install system dependencies
run: |
sudo apt-get update
sudo apt-get -y install mesa-common-dev
# Force xmake to a specific folder (for cache)
- name: Set xmake env
run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" >> $GITHUB_ENV
# Install xmake
- name: Setup xmake
uses: xmake-io/github-action-setup-xmake@v1
with:
xmake-version: branch@dev
actions-cache-folder: .xmake-cache-W${{ steps.cache_key.outputs.key }}
# Update xmake repository (in order to have the file that will be cached)
- name: Update xmake repository
run: xmake repo --update
# Fetch xmake dephash
- name: Retrieve dependencies hash
id: dep_hash
run: echo "hash=$(xmake l utils.ci.packageskey)" >> $GITHUB_OUTPUT
# Cache xmake dependencies
- name: Restore cached xmake dependencies
id: restore-depcache
uses: actions/cache/restore@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
key: Linux-${{ matrix.arch }}-${{ matrix.confs.mode }}${{ matrix.confs.cache_key }}-${{ steps.dep_hash.outputs.hash }}-W${{ steps.cache_key.outputs.key }}
# Setup compilation mode and install project dependencies
- name: Configure xmake and install dependencies
run: xmake config --arch=${{ matrix.arch }} --mode=${{ matrix.confs.mode }} --static=${{ matrix.kind == 'static' && 'yes' || 'no' }} ${{ matrix.confs.config }} --ccache=n --unitybuild=y --yes
# Save dependencies
- name: Save cached xmake dependencies
if: ${{ !steps.restore-depcache.outputs.cache-hit }}
uses: actions/cache/save@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
key: ${{ steps.restore-depcache.outputs.cache-primary-key }}
# Cache assets downloading
- name: Restore cached assets
id: restore-assets
uses: actions/cache/restore@v4
with:
path: assets
key: assets-${{ hashFiles('assets/examples_version.txt', 'assets/unittests_version.txt') }}
# Build the engine
- name: Build Pulse
run: xmake --yes

90
.github/workflows/macos-build.yml vendored git.filemode.normal_file
View File

@@ -0,0 +1,90 @@
name: macOS build
on:
pull_request:
push:
paths-ignore:
- '.github/workflows/linux-build.yml'
- '.github/workflows/msys2-build.yml'
- '.github/workflows/windows-build.yml'
- '.gitignore'
- 'LICENSE'
- 'README.md'
jobs:
build:
strategy:
fail-fast: false
matrix:
os: [macOS-latest]
arch: [x86_64]
kind: [shared, static]
confs:
- { mode: debug, archive: yes }
- { mode: debug, config: --asan=y, archive: false, cache_key: -asan }
- { mode: debug, config: --lsan=y, archive: false }
- { mode: debug, config: --tsan=y, archive: false }
- { mode: release, archive: yes }
runs-on: ${{ matrix.os }}
if: ${{ !contains(github.event.head_commit.message, 'ci skip') }}
steps:
- name: Get current date as package key
id: cache_key
run: echo "key=$(date +'%W')" >> $GITHUB_OUTPUT
- name: Checkout repository
uses: actions/checkout@v4
# Force xmake to a specific folder (for cache)
- name: Set xmake env
run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" >> $GITHUB_ENV
# Install xmake
- name: Setup xmake
uses: xmake-io/github-action-setup-xmake@v1
with:
xmake-version: branch@dev
actions-cache-folder: .xmake-cache-W${{ steps.cache_key.outputs.key }}
# Update xmake repository (in order to have the file that will be cached)
- name: Update xmake repository
run: xmake repo --update
# Fetch xmake dephash
- name: Retrieve dependencies hash
id: dep_hash
run: echo "hash=$(xmake l utils.ci.packageskey)" >> $GITHUB_OUTPUT
# Cache xmake dependencies
- name: Restore cached xmake dependencies
id: restore-depcache
uses: actions/cache/restore@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
key: macOS-${{ matrix.arch }}-${{ matrix.confs.mode }}${{ matrix.confs.cache_key }}-${{ steps.dep_hash.outputs.hash }}-W${{ steps.cache_key.outputs.key }}
# Setup compilation mode and install project dependencies
- name: Configure xmake and install dependencies
run: xmake config --arch=${{ matrix.arch }} --mode=${{ matrix.confs.mode }} --static=${{ matrix.kind == 'static' && 'yes' || 'no' }} ${{ matrix.confs.config }} --ccache=n --unitybuild=y --yes
# Save dependencies
- name: Save cached xmake dependencies
if: ${{ !steps.restore-depcache.outputs.cache-hit }}
uses: actions/cache/save@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
key: ${{ steps.restore-depcache.outputs.cache-primary-key }}
# Cache assets downloading
- name: Restore cached assets
id: restore-assets
uses: actions/cache/restore@v4
with:
path: assets
key: assets-${{ hashFiles('assets/examples_version.txt', 'assets/unittests_version.txt') }}
# Build the engine
- name: Build Pulse
run: xmake --yes

90
.github/workflows/msys2-build.yml vendored git.filemode.normal_file
View File

@@ -0,0 +1,90 @@
name: MSYS2 build (MinGW-w64)
on:
pull_request:
push:
paths-ignore:
- '.github/workflows/linux-build.yml'
- '.github/workflows/macos-build.yml'
- '.github/workflows/windows-build.yml'
- '.gitignore'
- 'LICENSE'
- 'README.md'
jobs:
build:
strategy:
matrix:
msystem: [mingw64]
os: [windows-latest]
arch: [x86_64]
mode: [debug, release]
kind: [shared, static]
runs-on: ${{ matrix.os }}
if: ${{ !contains(github.event.head_commit.message, 'ci skip') }}
defaults:
run:
shell: msys2 {0}
steps:
- name: Get current date as package key
id: cache_key
shell: bash
run: echo "key=$(date +'%W')" >> $GITHUB_OUTPUT
- name: Checkout repository
uses: actions/checkout@v4
# Setup MSYS2
- uses: msys2/setup-msys2@v2
with:
msystem: ${{ matrix.msystem }}
install: base-devel git unzip p7zip mingw-w64-${{ matrix.arch }}-toolchain mingw-w64-${{ matrix.arch }}-xmake
update: true
# Force xmake to a specific folder (for cache)
- name: Set xmake env
run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" >> $GITHUB_ENV
# Update xmake repository (in order to have the file that will be cached)
- name: Update xmake repository
run: xmake repo --update
# Fetch xmake dephash
- name: Retrieve dependencies hash
id: dep_hash
run: echo "hash=$(xmake l utils.ci.packageskey)" >> $GITHUB_OUTPUT
# Cache xmake dependencies
- name: Restore cached xmake dependencies
id: restore-depcache
uses: actions/cache/restore@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
key: MinGW-${{ matrix.arch }}-${{ matrix.mode }}-${{ steps.dep_hash.outputs.hash }}-W${{ steps.cache_key.outputs.key }}
# Setup compilation mode and install project dependencies
- name: Configure xmake and install dependencies
run: xmake config --arch=${{ matrix.arch }} --mode=${{ matrix.mode }} --static=${{ matrix.kind == 'static' && 'yes' || 'no' }} --ccache=n --unitybuild=y --yes
# Save dependencies
- name: Save cached xmake dependencies
if: ${{ !steps.restore-depcache.outputs.cache-hit }}
uses: actions/cache/save@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
key: ${{ steps.restore-depcache.outputs.cache-primary-key }}
# Cache assets downloading
- name: Restore cached assets
id: restore-assets
uses: actions/cache/restore@v4
with:
path: assets
key: assets-${{ hashFiles('assets/examples_version.txt', 'assets/unittests_version.txt') }}
# Build the engine
- name: Build Pulse
run: xmake --yes

85
.github/workflows/windows-build.yml vendored git.filemode.normal_file
View File

@@ -0,0 +1,85 @@
name: Windows build
on:
pull_request:
push:
paths-ignore:
- '.github/workflows/linux-build.yml'
- '.github/workflows/macos-build.yml'
- '.github/workflows/wasm-build.yml'
- '.gitignore'
- 'LICENSE'
- 'README.md'
jobs:
build:
strategy:
matrix:
os: [windows-latest]
arch: [x64]
mode: [debug, release]
kind: [shared, static]
runs-on: ${{ matrix.os }}
if: ${{ !contains(github.event.head_commit.message, 'ci skip') }}
steps:
- name: Get current date as package key
id: cache_key
run: echo "key=$(date +'%W')" >> $GITHUB_OUTPUT
shell: bash
- name: Checkout repository
uses: actions/checkout@v4
# Force xmake to a specific folder (for cache)
- name: Set xmake env
run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
# Install xmake
- name: Setup xmake
uses: xmake-io/github-action-setup-xmake@v1
with:
xmake-version: branch@dev
actions-cache-folder: .xmake-cache-W${{ steps.cache_key.outputs.key }}
# Update xmake repository (in order to have the file that will be cached)
- name: Update xmake repository
run: xmake repo --update
# Fetch xmake dephash
- name: Retrieve dependencies hash
id: dep_hash
run: echo "hash=$(xmake l utils.ci.packageskey)" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
# Cache xmake dependencies
- name: Restore cached xmake dependencies
id: restore-depcache
uses: actions/cache/restore@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}\.xmake\packages
key: MSVC-${{ matrix.arch }}-${{ matrix.mode }}-${{ steps.dep_hash.outputs.hash }}-W${{ steps.cache_key.outputs.key }}
# Setup compilation mode and install project dependencies
- name: Configure xmake and install dependencies
run: xmake config --arch=${{ matrix.arch }} --mode=${{ matrix.mode }} --static=${{ matrix.kind == 'static' && 'yes' || 'no' }} --ccache=n --unitybuild=y --yes
# Save dependencies
- name: Save cached xmake dependencies
if: ${{ !steps.restore-depcache.outputs.cache-hit }}
uses: actions/cache/save@v4
with:
path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages
key: ${{ steps.restore-depcache.outputs.cache-primary-key }}
# Cache assets downloading
- name: Restore cached assets
id: restore-assets
uses: actions/cache/restore@v4
with:
path: assets
key: assets-${{ hashFiles('assets/examples_version.txt', 'assets/unittests_version.txt') }}
# Build the engine
- name: Build Pulse
run: xmake --yes

9
Includes/Pulse.h
View File

@@ -109,6 +109,7 @@ typedef enum PulseErrorType
PULSE_ERROR_INVALID_INTERNAL_POINTER, PULSE_ERROR_INVALID_INTERNAL_POINTER,
PULSE_ERROR_MAP_FAILED, PULSE_ERROR_MAP_FAILED,
PULSE_ERROR_INVALID_DEVICE, PULSE_ERROR_INVALID_DEVICE,
PULSE_ERROR_INVALID_REGION,
} PulseErrorType; } PulseErrorType;
typedef enum PulseImageType typedef enum PulseImageType
@@ -262,14 +263,14 @@ PULSE_API void PulseDestroyDevice(PulseDevice device);
PULSE_API PulseBuffer PulseCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos); PULSE_API PulseBuffer PulseCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos);
PULSE_API bool PulseMapBuffer(PulseBuffer buffer, void** data); PULSE_API bool PulseMapBuffer(PulseBuffer buffer, void** data);
PULSE_API void PulseUnmapBuffer(PulseBuffer buffer); PULSE_API void PulseUnmapBuffer(PulseBuffer buffer);
PULSE_API bool PulseCopyBufferToBuffer(const PulseBufferRegion* src, const PulseBufferRegion* dst); PULSE_API bool PulseCopyBufferToBuffer(PulseCommandList cmd, const PulseBufferRegion* src, const PulseBufferRegion* dst);
PULSE_API bool PulseCopyBufferToImage(PulseBuffer src, const PulseBufferRegion* dst); PULSE_API bool PulseCopyBufferToImage(PulseCommandList cmd, const PulseBufferRegion* src, const PulseImageRegion* dst);
PULSE_API void PulseDestroyBuffer(PulseDevice device, PulseBuffer buffer); PULSE_API void PulseDestroyBuffer(PulseDevice device, PulseBuffer buffer);
PULSE_API PulseImage PulseCreateImage(PulseDevice device, const PulseImageCreateInfo* create_infos); PULSE_API PulseImage PulseCreateImage(PulseDevice device, const PulseImageCreateInfo* create_infos);
PULSE_API bool PulseIsImageFormatValid(PulseDevice device, PulseImageFormat format, PulseImageType type, PulseImageUsageFlags usage); PULSE_API bool PulseIsImageFormatValid(PulseDevice device, PulseImageFormat format, PulseImageType type, PulseImageUsageFlags usage);
PULSE_API bool PulseCopyImageToBuffer(const PulseImageRegion* src, const PulseBufferRegion* dst); PULSE_API bool PulseCopyImageToBuffer(PulseCommandList cmd, const PulseImageRegion* src, const PulseBufferRegion* dst);
PULSE_API bool PulseBlitImage(const PulseImageRegion* src, const PulseImageRegion* dst); PULSE_API bool PulseBlitImage(PulseCommandList cmd, const PulseImageRegion* src, const PulseImageRegion* dst);
PULSE_API void PulseDestroyImage(PulseDevice device, PulseImage image); PULSE_API void PulseDestroyImage(PulseDevice device, PulseImage image);
PULSE_API PulseCommandList PulseRequestCommandList(PulseDevice device, PulseCommandListUsage usage); PULSE_API PulseCommandList PulseRequestCommandList(PulseDevice device, PulseCommandListUsage usage);

5
README.md
View File

@@ -1,3 +1,8 @@
# PulseGPU # PulseGPU
<a href="https://github.com/ft-grmhd/Pulse/actions/workflows/linux_build.yml"><img src="https://github.com/ft-grmhd/Pulse/actions/workflows/linux_build.yml/badge.svg"></a>
<a href="https://github.com/ft-grmhd/Pulse/actions/workflows/macos_build.yml"><img src="https://github.com/ft-grmhd/Pulse/actions/workflows/macos_build.yml/badge.svg"></a>
<a href="https://github.com/ft-grmhd/Pulse/actions/workflows/msys2_build.yml"><img src="https://github.com/ft-grmhd/Pulse/actions/workflows/msys2_build.yml/badge.svg"></a>
<a href="https://github.com/ft-grmhd/Pulse/actions/workflows/windows_build.yml"><img src="https://github.com/ft-grmhd/Pulse/actions/workflows/windows_build.yml/badge.svg"></a>
Pulse is a low level GPGPU library designed for highly intensive general GPU computations with high control over the hardware. It is built on top of Vulkan and a Metal support is in discussion. Pulse is a low level GPGPU library designed for highly intensive general GPU computations with high control over the hardware. It is built on top of Vulkan and a Metal support is in discussion.

45
Sources/Backends/Vulkan/VulkanBuffer.c
View File

@@ -5,7 +5,9 @@
#include "Pulse.h" #include "Pulse.h"
#include "Vulkan.h" #include "Vulkan.h"
#include "VulkanBuffer.h" #include "VulkanBuffer.h"
#include "VulkanImage.h"
#include "VulkanDevice.h" #include "VulkanDevice.h"
#include "VulkanCommandList.h"
PulseBuffer VulkanCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos) PulseBuffer VulkanCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos)
{ {
@@ -70,6 +72,49 @@ void VulkanUnmapBuffer(PulseBuffer buffer)
vmaUnmapMemory(vulkan_device->allocator, vulkan_buffer->allocation); vmaUnmapMemory(vulkan_device->allocator, vulkan_buffer->allocation);
} }
bool VulkanCopyBufferToBuffer(PulseCommandList cmd, const PulseBufferRegion* src, const PulseBufferRegion* dst)
{
VulkanBuffer* vulkan_src_buffer = VULKAN_RETRIEVE_DRIVER_DATA_AS(src->buffer, VulkanBuffer*);
VulkanBuffer* vulkan_dst_buffer = VULKAN_RETRIEVE_DRIVER_DATA_AS(dst->buffer, VulkanBuffer*);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(src->buffer->device, VulkanDevice*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd, VulkanCommandList*);
VkBufferCopy copy_region = {};
copy_region.srcOffset = src->offset;
copy_region.dstOffset = dst->offset;
copy_region.size = (src->size < dst->size ? src->size : dst->size);
vulkan_device->vkCmdCopyBuffer(vulkan_cmd->cmd, vulkan_src_buffer->buffer, vulkan_dst_buffer->buffer, 1, &copy_region);
return true;
}
bool VulkanCopyBufferToImage(PulseCommandList cmd, const PulseBufferRegion* src, const PulseImageRegion* dst)
{
VulkanBuffer* vulkan_src_buffer = VULKAN_RETRIEVE_DRIVER_DATA_AS(src->buffer, VulkanBuffer*);
VulkanImage* vulkan_dst_image = VULKAN_RETRIEVE_DRIVER_DATA_AS(dst->image, VulkanImage*);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(src->buffer->device, VulkanDevice*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd, VulkanCommandList*);
VkBufferImageCopy region = { 0 };
region.bufferOffset = src->offset;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = dst->layer;
region.imageSubresource.layerCount = 1;
region.imageOffset.x = dst->x;
region.imageOffset.y = dst->y;
region.imageOffset.z = dst->z;
region.imageExtent.width = dst->width;
region.imageExtent.height = dst->height;
region.imageExtent.depth = dst->depth;
vulkan_device->vkCmdCopyBufferToImage(vulkan_cmd->cmd, vulkan_src_buffer->buffer, vulkan_dst_image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
return true;
}
void VulkanDestroyBuffer(PulseDevice device, PulseBuffer buffer) void VulkanDestroyBuffer(PulseDevice device, PulseBuffer buffer)
{ {
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*); VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);

4
Sources/Backends/Vulkan/VulkanBuffer.h
View File

@@ -25,8 +25,8 @@ typedef struct VulkanBuffer
PulseBuffer VulkanCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos); PulseBuffer VulkanCreateBuffer(PulseDevice device, const PulseBufferCreateInfo* create_infos);
bool VulkanMapBuffer(PulseBuffer buffer, void** data); bool VulkanMapBuffer(PulseBuffer buffer, void** data);
void VulkanUnmapBuffer(PulseBuffer buffer); void VulkanUnmapBuffer(PulseBuffer buffer);
bool VulkanCopyBufferToBuffer(const PulseBufferRegion* src, const PulseBufferRegion* dst); bool VulkanCopyBufferToBuffer(PulseCommandList cmd, const PulseBufferRegion* src, const PulseBufferRegion* dst);
bool VulkanCopyBufferToImage(const PulseBufferRegion* src, const PulseImageRegion* dst); bool VulkanCopyBufferToImage(PulseCommandList cmd, const PulseBufferRegion* src, const PulseImageRegion* dst);
void VulkanDestroyBuffer(PulseDevice device, PulseBuffer buffer); void VulkanDestroyBuffer(PulseDevice device, PulseBuffer buffer);
#endif // PULSE_VULKAN_BUFFER_H_ #endif // PULSE_VULKAN_BUFFER_H_

1
Sources/Backends/Vulkan/VulkanDevicePrototypes.h
View File

@@ -18,6 +18,7 @@
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdBindDescriptorSets) PULSE_VULKAN_DEVICE_FUNCTION(vkCmdBindDescriptorSets)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdBindPipeline) PULSE_VULKAN_DEVICE_FUNCTION(vkCmdBindPipeline)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdCopyBuffer) PULSE_VULKAN_DEVICE_FUNCTION(vkCmdCopyBuffer)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdCopyBufferToImage)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdDispatch) PULSE_VULKAN_DEVICE_FUNCTION(vkCmdDispatch)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdDispatchIndirect) PULSE_VULKAN_DEVICE_FUNCTION(vkCmdDispatchIndirect)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdExecuteCommands) PULSE_VULKAN_DEVICE_FUNCTION(vkCmdExecuteCommands)

9
Sources/Backends/Vulkan/VulkanImage.c
View File

@@ -115,7 +115,6 @@ PulseImage VulkanCreateImage(PulseDevice device, const PulseImageCreateInfo* cre
image->device = device; image->device = device;
image->driver_data = vulkan_image; image->driver_data = vulkan_image;
image->usage = create_infos->usage;
VmaAllocationCreateInfo allocation_create_info = { 0 }; VmaAllocationCreateInfo allocation_create_info = { 0 };
allocation_create_info.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE; allocation_create_info.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
@@ -188,6 +187,14 @@ bool VulkanIsImageFormatValid(PulseDevice device, PulseImageFormat format, Pulse
return vulkan_driver_data->instance.vkGetPhysicalDeviceImageFormatProperties(vulkan_device->physical, PulseImageFormatToVkFormat[format], (type == PULSE_IMAGE_TYPE_3D) ? VK_IMAGE_TYPE_3D : VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_STORAGE_BIT, vulkan_flags, &properties) == VK_SUCCESS; return vulkan_driver_data->instance.vkGetPhysicalDeviceImageFormatProperties(vulkan_device->physical, PulseImageFormatToVkFormat[format], (type == PULSE_IMAGE_TYPE_3D) ? VK_IMAGE_TYPE_3D : VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_STORAGE_BIT, vulkan_flags, &properties) == VK_SUCCESS;
} }
bool VulkanCopyImageToBuffer(PulseCommandList cmd, const PulseImageRegion* src, const PulseBufferRegion* dst)
{
}
bool VulkanBlitImage(PulseCommandList cmd, const PulseImageRegion* src, const PulseImageRegion* dst)
{
}
void VulkanDestroyImage(PulseDevice device, PulseImage image) void VulkanDestroyImage(PulseDevice device, PulseImage image)
{ {
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*); VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);

2
Sources/Backends/Vulkan/VulkanImage.h
View File

@@ -25,6 +25,8 @@ typedef struct VulkanImage
PulseImage VulkanCreateImage(PulseDevice device, const PulseImageCreateInfo* create_infos); PulseImage VulkanCreateImage(PulseDevice device, const PulseImageCreateInfo* create_infos);
bool VulkanIsImageFormatValid(PulseDevice device, PulseImageFormat format, PulseImageType type, PulseImageUsageFlags usage); bool VulkanIsImageFormatValid(PulseDevice device, PulseImageFormat format, PulseImageType type, PulseImageUsageFlags usage);
bool VulkanCopyImageToBuffer(PulseCommandList cmd, const PulseImageRegion* src, const PulseBufferRegion* dst);
bool VulkanBlitImage(PulseCommandList cmd, const PulseImageRegion* src, const PulseImageRegion* dst);
void VulkanDestroyImage(PulseDevice device, PulseImage image); void VulkanDestroyImage(PulseDevice device, PulseImage image);
#endif // PULSE_VULKAN_IMAGE_H_ #endif // PULSE_VULKAN_IMAGE_H_

1
Sources/PulseBackend.c
View File

@@ -165,6 +165,7 @@ PULSE_API const char* PulseVerbaliseErrorType(PulseErrorType error)
case PULSE_ERROR_INVALID_INTERNAL_POINTER: return "invalid internal pointer"; case PULSE_ERROR_INVALID_INTERNAL_POINTER: return "invalid internal pointer";
case PULSE_ERROR_MAP_FAILED: return "memory mapping failed"; case PULSE_ERROR_MAP_FAILED: return "memory mapping failed";
case PULSE_ERROR_INVALID_DEVICE: return "device is invalid"; case PULSE_ERROR_INVALID_DEVICE: return "device is invalid";
case PULSE_ERROR_INVALID_REGION: return "region is invalid";
default: return "invalid error type"; default: return "invalid error type";
}; };

82
Sources/PulseBuffer.c
View File

@@ -45,6 +45,88 @@ PULSE_API void PulseUnmapBuffer(PulseBuffer buffer)
buffer->is_mapped = false; buffer->is_mapped = false;
} }
PULSE_API bool PulseCopyBufferToBuffer(PulseCommandList cmd, const PulseBufferRegion* src, const PulseBufferRegion* dst)
{
PULSE_CHECK_PTR_RETVAL(src, false);
PULSE_CHECK_HANDLE_RETVAL(src->buffer, false);
PULSE_CHECK_PTR_RETVAL(dst, false);
PULSE_CHECK_HANDLE_RETVAL(dst->buffer, false);
PulseBackend backend = src->buffer->device->backend;
if(src->buffer->device != dst->buffer->device)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend))
PulseLogErrorFmt(backend, "source buffer has been created on a different device (%p) than the destination buffer (%p)", src->buffer->device, dst->buffer->device);
PulseSetInternalError(PULSE_ERROR_INVALID_DEVICE);
return false;
}
if(src->size + src->offset > src->buffer->size)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend))
PulseLogErrorFmt(backend, "source buffer region (%lld) is bigger than the buffer size (%lld)", src->size + src->offset, src->buffer->size);
PulseSetInternalError(PULSE_ERROR_INVALID_REGION);
return false;
}
if(dst->size + dst->offset > dst->buffer->size)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend))
PulseLogErrorFmt(backend, "destination buffer region (%lld) is bigger than the buffer size (%lld)", dst->size + dst->offset, dst->buffer->size);
PulseSetInternalError(PULSE_ERROR_INVALID_REGION);
return false;
}
if(src->buffer == dst->buffer)
return true;
return src->buffer->device->PFN_CopyBufferToBuffer(cmd, src, dst);
}
PULSE_API bool PulseCopyBufferToImage(PulseCommandList cmd, const PulseBufferRegion* src, const PulseImageRegion* dst)
{
PULSE_CHECK_HANDLE_RETVAL(src, false);
PULSE_CHECK_PTR_RETVAL(dst, false);
PULSE_CHECK_HANDLE_RETVAL(dst->image, false);
PulseBackend backend = src->buffer->device->backend;
if(src->buffer->device != dst->image->device)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend))
PulseLogErrorFmt(backend, "source buffer has been created on a different device (%p) than the destination buffer (%p)", src->buffer->device, dst->image->device);
PulseSetInternalError(PULSE_ERROR_INVALID_DEVICE);
return false;
}
if(src->size + src->offset > src->buffer->size)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend))
PulseLogErrorFmt(backend, "source buffer region (%lld) is bigger than the buffer size (%lld)", src->size + src->offset, src->buffer->size);
PulseSetInternalError(PULSE_ERROR_INVALID_REGION);
return false;
}
if(dst->width > dst->image->width)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend))
PulseLogErrorFmt(backend, "destination image region width (%lld) is bigger than image width (%lld)", dst->width, dst->image->width);
PulseSetInternalError(PULSE_ERROR_INVALID_REGION);
return false;
}
if(dst->height > dst->image->height)
{
if(PULSE_IS_BACKEND_LOW_LEVEL_DEBUG(backend))
PulseLogErrorFmt(backend, "destination image region height (%lld) is bigger than image height (%lld)", dst->height, dst->image->height);
PulseSetInternalError(PULSE_ERROR_INVALID_REGION);
return false;
}
return src->buffer->device->PFN_CopyBufferToImage(cmd, src, dst);
}
PULSE_API void PulseDestroyBuffer(PulseDevice device, PulseBuffer buffer) PULSE_API void PulseDestroyBuffer(PulseDevice device, PulseBuffer buffer)
{ {
PULSE_CHECK_HANDLE(device); PULSE_CHECK_HANDLE(device);

16
Sources/PulseImage.c
View File

@@ -102,6 +102,14 @@ PULSE_API PulseImage PulseCreateImage(PulseDevice device, const PulseImageCreate
PulseImage image = device->PFN_CreateImage(device, create_infos); PulseImage image = device->PFN_CreateImage(device, create_infos);
if(image == PULSE_NULL_HANDLE) if(image == PULSE_NULL_HANDLE)
return PULSE_NULL_HANDLE; return PULSE_NULL_HANDLE;
image->type = create_infos->type;
image->format = create_infos->format;
image->usage = create_infos->usage;
image->width = create_infos->width;
image->height = create_infos->height;
image->layer_count_or_depth = create_infos->layer_count_or_depth;
PULSE_EXPAND_ARRAY_IF_NEEDED(device->allocated_images, PulseImage, device->allocated_images_size, device->allocated_images_capacity, 64); PULSE_EXPAND_ARRAY_IF_NEEDED(device->allocated_images, PulseImage, device->allocated_images_size, device->allocated_images_capacity, 64);
device->allocated_images[device->allocated_images_size] = image; device->allocated_images[device->allocated_images_size] = image;
device->allocated_images_size++; device->allocated_images_size++;
@@ -114,6 +122,14 @@ PULSE_API bool PulseIsImageFormatValid(PulseDevice device, PulseImageFormat form
return device->PFN_IsImageFormatValid(device, format, type, usage); return device->PFN_IsImageFormatValid(device, format, type, usage);
} }
PULSE_API bool PulseCopyImageToBuffer(PulseCommandList cmd, const PulseImageRegion* src, const PulseBufferRegion* dst)
{
}
PULSE_API bool PulseBlitImage(PulseCommandList cmd, const PulseImageRegion* src, const PulseImageRegion* dst)
{
}
PULSE_API void PulseDestroyImage(PulseDevice device, PulseImage image) PULSE_API void PulseDestroyImage(PulseDevice device, PulseImage image)
{ {
PULSE_CHECK_HANDLE(device); PULSE_CHECK_HANDLE(device);

5
Sources/PulseInternal.h
View File

@@ -105,7 +105,12 @@ typedef struct PulseImageHandler
{ {
PulseDevice device; PulseDevice device;
void* driver_data; void* driver_data;
PulseImageType type;
PulseImageFormat format;
PulseImageUsageFlags usage; PulseImageUsageFlags usage;
uint32_t width;
uint32_t height;
uint32_t layer_count_or_depth;
} PulseImageHandler; } PulseImageHandler;
PulseThreadID PulseGetThreadID(); PulseThreadID PulseGetThreadID();

6
Sources/PulsePFNs.h
View File

@@ -31,9 +31,9 @@ typedef void (*PulseDestroyBufferPFN)(PulseDevice, PulseBuffer);
typedef PulseImage (*PulseCreateImagePFN)(PulseDevice, const PulseImageCreateInfo*); typedef PulseImage (*PulseCreateImagePFN)(PulseDevice, const PulseImageCreateInfo*);
typedef bool (*PulseIsImageFormatValidPFN)(PulseDevice, PulseImageFormat, PulseImageType, PulseImageUsageFlags); typedef bool (*PulseIsImageFormatValidPFN)(PulseDevice, PulseImageFormat, PulseImageType, PulseImageUsageFlags);
typedef void (*PulseDestroyImagePFN)(PulseDevice, PulseImage); typedef void (*PulseDestroyImagePFN)(PulseDevice, PulseImage);
typedef bool (*PulseCopyBufferToBufferPFN)(const PulseBufferRegion*, const PulseBufferRegion*); typedef bool (*PulseCopyBufferToBufferPFN)(PulseCommandList, const PulseBufferRegion*, const PulseBufferRegion*);
typedef bool (*PulseCopyBufferToImageFN)(const PulseBufferRegion*, const PulseImageRegion*); typedef bool (*PulseCopyBufferToImageFN)(PulseCommandList, const PulseBufferRegion*, const PulseImageRegion*);
typedef bool (*PulseCopyImageToBufferPFN)(const PulseImageRegion*, const PulseBufferRegion*); typedef bool (*PulseCopyImageToBufferPFN)(PulseCommandList, const PulseImageRegion*, const PulseBufferRegion*);
typedef bool (*PulseBlitImagePFN)(const PulseImageRegion*, const PulseImageRegion*); typedef bool (*PulseBlitImagePFN)(const PulseImageRegion*, const PulseImageRegion*);
#endif // PULSE_PFNS_H_ #endif // PULSE_PFNS_H_

167
Tests/Vulkan/Buffer.c
View File

@@ -65,6 +65,7 @@ void TestBufferCreation()
buffer_create_info.usage = PULSE_BUFFER_USAGE_STORAGE_READ; buffer_create_info.usage = PULSE_BUFFER_USAGE_STORAGE_READ;
buffer = PulseCreateBuffer(device, &buffer_create_info); buffer = PulseCreateBuffer(device, &buffer_create_info);
TEST_ASSERT_EQUAL(buffer, PULSE_NULL_HANDLE); TEST_ASSERT_EQUAL(buffer, PULSE_NULL_HANDLE);
PulseGetLastErrorType(); // Just to clear the error code
PulseDestroyBuffer(device, buffer); PulseDestroyBuffer(device, buffer);
ENABLE_ERRORS; ENABLE_ERRORS;
@@ -112,6 +113,170 @@ void TestBufferMapping()
CleanupPulse(backend); CleanupPulse(backend);
} }
void TestBufferCopy()
{
PulseBackend backend;
SetupPulse(&backend);
PulseDevice device;
SetupDevice(backend, &device);
const unsigned char data[8] = { 0xA1, 0xFF, 0xDF, 0x17, 0x5B, 0xCC, 0x00, 0x36 };
PulseBufferCreateInfo buffer_create_info = { 0 };
buffer_create_info.size = 8;
buffer_create_info.usage = PULSE_BUFFER_USAGE_TRANSFER_UPLOAD | PULSE_BUFFER_USAGE_TRANSFER_DOWNLOAD;
PulseBuffer src_buffer = PulseCreateBuffer(device, &buffer_create_info);
TEST_ASSERT_NOT_EQUAL_MESSAGE(src_buffer, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
{
void* ptr;
TEST_ASSERT_NOT_EQUAL_MESSAGE(PulseMapBuffer(src_buffer, &ptr), false, PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_NOT_NULL(ptr);
memcpy(ptr, data, 8);
PulseUnmapBuffer(src_buffer);
}
PulseBuffer dst_buffer = PulseCreateBuffer(device, &buffer_create_info);
TEST_ASSERT_NOT_EQUAL_MESSAGE(dst_buffer, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
{
PulseCommandList cmd = PulseRequestCommandList(device, PULSE_COMMAND_LIST_TRANSFER_ONLY);
TEST_ASSERT_NOT_EQUAL_MESSAGE(cmd, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseFence fence = PulseCreateFence(device);
TEST_ASSERT_NOT_EQUAL_MESSAGE(fence, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseBufferRegion src_region = { 0 };
src_region.buffer = src_buffer;
src_region.size = 8;
PulseBufferRegion dst_region = { 0 };
dst_region.buffer = dst_buffer;
dst_region.size = 8;
TEST_ASSERT_TRUE_MESSAGE(PulseCopyBufferToBuffer(cmd, &src_region, &dst_region), PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_TRUE_MESSAGE(PulseSubmitCommandList(device, cmd, fence), PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_TRUE_MESSAGE(PulseWaitForFences(device, &fence, 1, true), PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseReleaseCommandList(device, cmd);
PulseDestroyFence(device, fence);
}
{
void* ptr;
TEST_ASSERT_NOT_EQUAL_MESSAGE(PulseMapBuffer(dst_buffer, &ptr), false, PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_NOT_NULL(ptr);
TEST_ASSERT_EQUAL(memcmp(ptr, data, 8), 0);
PulseUnmapBuffer(dst_buffer);
}
{
PulseCommandList cmd = PulseRequestCommandList(device, PULSE_COMMAND_LIST_TRANSFER_ONLY);
TEST_ASSERT_NOT_EQUAL_MESSAGE(cmd, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseFence fence = PulseCreateFence(device);
TEST_ASSERT_NOT_EQUAL_MESSAGE(fence, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseBufferRegion src_region = { 0 };
src_region.buffer = src_buffer;
src_region.size = 8;
src_region.offset = 2;
PulseBufferRegion dst_region = { 0 };
dst_region.buffer = dst_buffer;
dst_region.size = 12;
DISABLE_ERRORS;
TEST_ASSERT_FALSE_MESSAGE(PulseCopyBufferToBuffer(cmd, &src_region, &dst_region), PulseVerbaliseErrorType(PulseGetLastErrorType()));
ENABLE_ERRORS;
TEST_ASSERT_TRUE_MESSAGE(PulseSubmitCommandList(device, cmd, fence), PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_TRUE_MESSAGE(PulseWaitForFences(device, &fence, 1, true), PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseReleaseCommandList(device, cmd);
PulseDestroyFence(device, fence);
}
DISABLE_ERRORS;
void* ptr;
TEST_ASSERT_NOT_EQUAL_MESSAGE(PulseMapBuffer(src_buffer, &ptr), false, PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseDestroyBuffer(device, src_buffer);
ENABLE_ERRORS;
PulseDestroyBuffer(device, dst_buffer);
CleanupDevice(device);
CleanupPulse(backend);
}
void TestBufferCopyImage()
{
PulseBackend backend;
SetupPulse(&backend);
PulseDevice device;
SetupDevice(backend, &device);
const unsigned char data[8] = { 0xA1, 0xFF, 0xDF, 0x17, 0x5B, 0xCC, 0x00, 0x36 };
PulseBufferCreateInfo buffer_create_info = { 0 };
buffer_create_info.size = 8;
buffer_create_info.usage = PULSE_BUFFER_USAGE_TRANSFER_UPLOAD;
PulseBuffer buffer = PulseCreateBuffer(device, &buffer_create_info);
TEST_ASSERT_NOT_EQUAL_MESSAGE(buffer, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
{
void* ptr;
TEST_ASSERT_NOT_EQUAL_MESSAGE(PulseMapBuffer(buffer, &ptr), false, PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_NOT_NULL(ptr);
memcpy(ptr, data, 8);
PulseUnmapBuffer(buffer);
}
PulseImageCreateInfo image_create_info = { 0 };
image_create_info.type = PULSE_IMAGE_TYPE_2D;
image_create_info.format = PULSE_IMAGE_FORMAT_R8G8B8A8_UNORM;
image_create_info.usage = PULSE_IMAGE_USAGE_STORAGE_WRITE;
image_create_info.width = 8;
image_create_info.height = 1;
image_create_info.layer_count_or_depth = 1;
PulseImage image = PulseCreateImage(device, &image_create_info);
TEST_ASSERT_NOT_EQUAL_MESSAGE(image, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
{
PulseCommandList cmd = PulseRequestCommandList(device, PULSE_COMMAND_LIST_TRANSFER_ONLY);
TEST_ASSERT_NOT_EQUAL_MESSAGE(cmd, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseFence fence = PulseCreateFence(device);
TEST_ASSERT_NOT_EQUAL_MESSAGE(fence, PULSE_NULL_HANDLE, PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseBufferRegion src_region = { 0 };
src_region.buffer = buffer;
src_region.size = 8;
PulseImageRegion dst_region = { 0 };
dst_region.image = image;
dst_region.width = 8;
dst_region.height = 1;
dst_region.depth = 1;
dst_region.x = 1;
dst_region.y = 1;
dst_region.z = 1;
dst_region.layer = 1;
TEST_ASSERT_TRUE_MESSAGE(PulseCopyBufferToImage(cmd, &src_region, &dst_region), PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_TRUE_MESSAGE(PulseSubmitCommandList(device, cmd, fence), PulseVerbaliseErrorType(PulseGetLastErrorType()));
TEST_ASSERT_TRUE_MESSAGE(PulseWaitForFences(device, &fence, 1, true), PulseVerbaliseErrorType(PulseGetLastErrorType()));
PulseReleaseCommandList(device, cmd);
PulseDestroyFence(device, fence);
}
PulseDestroyImage(device, image);
PulseDestroyBuffer(device, buffer);
CleanupDevice(device);
CleanupPulse(backend);
}
void TestBufferDestruction() void TestBufferDestruction()
{ {
PulseBackend backend; PulseBackend backend;
@@ -149,5 +314,7 @@ void TestBuffer()
{ {
RUN_TEST(TestBufferCreation); RUN_TEST(TestBufferCreation);
RUN_TEST(TestBufferMapping); RUN_TEST(TestBufferMapping);
RUN_TEST(TestBufferCopy);
RUN_TEST(TestBufferCopyImage);
RUN_TEST(TestBufferDestruction); RUN_TEST(TestBufferDestruction);
} }

6
xmake.lua
View File

@@ -54,6 +54,8 @@ set_dependir("build/.deps")
set_optimize("fastest") set_optimize("fastest")
option("unitybuild", { description = "Build the library using unity build", default = false })
for name, module in pairs(backends) do for name, module in pairs(backends) do
if has_config(module.option) then if has_config(module.option) then
if module.packages then if module.packages then
@@ -70,6 +72,10 @@ target("pulse_gpu")
add_files("Sources/*.c") add_files("Sources/*.c")
if has_config("unitybuild") then
add_rules("c.unity_build", { batchsize = 6 })
end
for name, module in pairs(backends) do for name, module in pairs(backends) do
if has_config(module.option) then if has_config(module.option) then
if module.packages then if module.packages then