eden-emu/SDL
15
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2025-05-29 16:09:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

GPU: Rename struct members and parameters for SDL3 naming conventions (#10730)

Browse source 
---------

Co-authored-by: Evan Hemsley <2342303+thatcosmonaut@users.noreply.github.com>
This commit is contained in:
Caleb Cornett 2024-09-06 18:38:23 -05:00 • committed by GitHub
parent e21f70c593
commit 9730f62e8c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 2963 additions and 2972 deletions
Download patch file Download diff file Expand all files Collapse all files

833
include/SDL3/SDL_gpu.h
View file

File diff suppressed because it is too large Load diff

2
src/dynapi/SDL_dynapi_procs.h
View file

@ -70,7 +70,7 @@ SDL_DYNAPI_PROC(SDL_JoystickID,SDL_AttachVirtualJoystick,(const SDL_VirtualJoyst
SDL_DYNAPI_PROC(SDL_bool,SDL_AudioDevicePaused,(SDL_AudioDeviceID a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_AudioDevicePaused,(SDL_AudioDeviceID a),(a),return)
SDL_DYNAPI_PROC(SDL_GPUComputePass*,SDL_BeginGPUComputePass,(SDL_GPUCommandBuffer *a, const SDL_GPUStorageTextureWriteOnlyBinding *b, Uint32 c, const SDL_GPUStorageBufferWriteOnlyBinding *d, Uint32 e),(a,b,c,d,e),return) SDL_DYNAPI_PROC(SDL_GPUComputePass*,SDL_BeginGPUComputePass,(SDL_GPUCommandBuffer *a, const SDL_GPUStorageTextureWriteOnlyBinding *b, Uint32 c, const SDL_GPUStorageBufferWriteOnlyBinding *d, Uint32 e),(a,b,c,d,e),return)
SDL_DYNAPI_PROC(SDL_GPUCopyPass*,SDL_BeginGPUCopyPass,(SDL_GPUCommandBuffer *a),(a),return) SDL_DYNAPI_PROC(SDL_GPUCopyPass*,SDL_BeginGPUCopyPass,(SDL_GPUCommandBuffer *a),(a),return)
SDL_DYNAPI_PROC(SDL_GPURenderPass*,SDL_BeginGPURenderPass,(SDL_GPUCommandBuffer *a, const SDL_GPUColorAttachmentInfo *b, Uint32 c, const SDL_GPUDepthStencilAttachmentInfo *d),(a,b,c,d),return) SDL_DYNAPI_PROC(SDL_GPURenderPass*,SDL_BeginGPURenderPass,(SDL_GPUCommandBuffer *a, const SDL_GPUColorTargetInfo *b, Uint32 c, const SDL_GPUDepthStencilTargetInfo *d),(a,b,c,d),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_BindAudioStream,(SDL_AudioDeviceID a, SDL_AudioStream *b),(a,b),return) SDL_DYNAPI_PROC(SDL_bool,SDL_BindAudioStream,(SDL_AudioDeviceID a, SDL_AudioStream *b),(a,b),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_BindAudioStreams,(SDL_AudioDeviceID a, SDL_AudioStream **b, int c),(a,b,c),return) SDL_DYNAPI_PROC(SDL_bool,SDL_BindAudioStreams,(SDL_AudioDeviceID a, SDL_AudioStream **b, int c),(a,b,c),return)
SDL_DYNAPI_PROC(void,SDL_BindGPUComputePipeline,(SDL_GPUComputePass *a, SDL_GPUComputePipeline *b),(a,b),) SDL_DYNAPI_PROC(void,SDL_BindGPUComputePipeline,(SDL_GPUComputePass *a, SDL_GPUComputePipeline *b),(a,b),)

1404
src/gpu/SDL_gpu.c
View file

File diff suppressed because it is too large Load diff

116
src/gpu/SDL_sysgpu.h
View file

@ -28,18 +28,18 @@
typedef struct Pass typedef struct Pass
{ {
SDL_GPUCommandBuffer *commandBuffer; SDL_GPUCommandBuffer *command_buffer;
bool inProgress; bool in_progress;
} Pass; } Pass;
typedef struct CommandBufferCommonHeader typedef struct CommandBufferCommonHeader
{ {
SDL_GPUDevice *device; SDL_GPUDevice *device;
Pass renderPass; Pass render_pass;
bool graphicsPipelineBound; bool graphics_pipeline_bound;
Pass computePass; Pass compute_pass;
bool computePipelineBound; bool compute_pipeline_bound;
Pass copyPass; Pass copy_pass;
bool submitted; bool submitted;
} CommandBufferCommonHeader; } CommandBufferCommonHeader;
@ -56,8 +56,8 @@ typedef struct BlitFragmentUniforms
float width; float width;
float height; float height;
Uint32 mipLevel; Uint32 mip_level;
float layerOrDepth; float layer_or_depth;
} BlitFragmentUniforms; } BlitFragmentUniforms;
typedef struct BlitPipelineCacheEntry typedef struct BlitPipelineCacheEntry
@ -266,7 +266,7 @@ void SDL_GPU_BlitCommon(
const SDL_GPUBlitRegion *source, const SDL_GPUBlitRegion *source,
const SDL_GPUBlitRegion *destination, const SDL_GPUBlitRegion *destination,
SDL_FlipMode flipMode, SDL_FlipMode flipMode,
SDL_GPUFilter filterMode, SDL_GPUFilter filter,
bool cycle, bool cycle,
SDL_GPUSampler *blitLinearSampler, SDL_GPUSampler *blitLinearSampler,
SDL_GPUSampler *blitNearestSampler, SDL_GPUSampler *blitNearestSampler,
@ -297,33 +297,33 @@ struct SDL_GPUDevice
SDL_GPUComputePipeline *(*CreateComputePipeline)( SDL_GPUComputePipeline *(*CreateComputePipeline)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
const SDL_GPUComputePipelineCreateInfo *pipelineCreateInfo); const SDL_GPUComputePipelineCreateInfo *createinfo);
SDL_GPUGraphicsPipeline *(*CreateGraphicsPipeline)( SDL_GPUGraphicsPipeline *(*CreateGraphicsPipeline)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
const SDL_GPUGraphicsPipelineCreateInfo *pipelineCreateInfo); const SDL_GPUGraphicsPipelineCreateInfo *createinfo);
SDL_GPUSampler *(*CreateSampler)( SDL_GPUSampler *(*CreateSampler)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
const SDL_GPUSamplerCreateInfo *samplerCreateInfo); const SDL_GPUSamplerCreateInfo *createinfo);
SDL_GPUShader *(*CreateShader)( SDL_GPUShader *(*CreateShader)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
const SDL_GPUShaderCreateInfo *shaderCreateInfo); const SDL_GPUShaderCreateInfo *createinfo);
SDL_GPUTexture *(*CreateTexture)( SDL_GPUTexture *(*CreateTexture)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
const SDL_GPUTextureCreateInfo *textureCreateInfo); const SDL_GPUTextureCreateInfo *createinfo);
SDL_GPUBuffer *(*CreateBuffer)( SDL_GPUBuffer *(*CreateBuffer)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
SDL_GPUBufferUsageFlags usageFlags, SDL_GPUBufferUsageFlags usageFlags,
Uint32 sizeInBytes); Uint32 size);
SDL_GPUTransferBuffer *(*CreateTransferBuffer)( SDL_GPUTransferBuffer *(*CreateTransferBuffer)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
SDL_GPUTransferBufferUsage usage, SDL_GPUTransferBufferUsage usage,
Uint32 sizeInBytes); Uint32 size);
// Debug Naming // Debug Naming
@ -382,9 +382,9 @@ struct SDL_GPUDevice
void (*BeginRenderPass)( void (*BeginRenderPass)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
const SDL_GPUColorAttachmentInfo *colorAttachmentInfos, const SDL_GPUColorTargetInfo *colorTargetInfos,
Uint32 colorAttachmentCount, Uint32 numColorTargets,
const SDL_GPUDepthStencilAttachmentInfo *depthStencilAttachmentInfo); const SDL_GPUDepthStencilTargetInfo *depthStencilTargetInfo);
void (*BindGraphicsPipeline)( void (*BindGraphicsPipeline)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
@ -409,90 +409,90 @@ struct SDL_GPUDevice
void (*BindVertexBuffers)( void (*BindVertexBuffers)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstBinding, Uint32 firstBinding,
const SDL_GPUBufferBinding *pBindings, const SDL_GPUBufferBinding *bindings,
Uint32 bindingCount); Uint32 numBindings);
void (*BindIndexBuffer)( void (*BindIndexBuffer)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
const SDL_GPUBufferBinding *pBinding, const SDL_GPUBufferBinding *binding,
SDL_GPUIndexElementSize indexElementSize); SDL_GPUIndexElementSize indexElementSize);
void (*BindVertexSamplers)( void (*BindVertexSamplers)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
const SDL_GPUTextureSamplerBinding *textureSamplerBindings, const SDL_GPUTextureSamplerBinding *textureSamplerBindings,
Uint32 bindingCount); Uint32 numBindings);
void (*BindVertexStorageTextures)( void (*BindVertexStorageTextures)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
SDL_GPUTexture *const *storageTextures, SDL_GPUTexture *const *storageTextures,
Uint32 bindingCount); Uint32 numBindings);
void (*BindVertexStorageBuffers)( void (*BindVertexStorageBuffers)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
SDL_GPUBuffer *const *storageBuffers, SDL_GPUBuffer *const *storageBuffers,
Uint32 bindingCount); Uint32 numBindings);
void (*BindFragmentSamplers)( void (*BindFragmentSamplers)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
const SDL_GPUTextureSamplerBinding *textureSamplerBindings, const SDL_GPUTextureSamplerBinding *textureSamplerBindings,
Uint32 bindingCount); Uint32 numBindings);
void (*BindFragmentStorageTextures)( void (*BindFragmentStorageTextures)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
SDL_GPUTexture *const *storageTextures, SDL_GPUTexture *const *storageTextures,
Uint32 bindingCount); Uint32 numBindings);
void (*BindFragmentStorageBuffers)( void (*BindFragmentStorageBuffers)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
SDL_GPUBuffer *const *storageBuffers, SDL_GPUBuffer *const *storageBuffers,
Uint32 bindingCount); Uint32 numBindings);
void (*PushVertexUniformData)( void (*PushVertexUniformData)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 slotIndex, Uint32 slotIndex,
const void *data, const void *data,
Uint32 dataLengthInBytes); Uint32 length);
void (*PushFragmentUniformData)( void (*PushFragmentUniformData)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 slotIndex, Uint32 slotIndex,
const void *data, const void *data,
Uint32 dataLengthInBytes); Uint32 length);
void (*DrawIndexedPrimitives)( void (*DrawIndexedPrimitives)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 indexCount, Uint32 numIndices,
Uint32 instanceCount, Uint32 numInstances,
Uint32 firstIndex, Uint32 firstIndex,
Sint32 vertexOffset, Sint32 vertexOffset,
Uint32 firstInstance); Uint32 firstInstance);
void (*DrawPrimitives)( void (*DrawPrimitives)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 vertexCount, Uint32 numVertices,
Uint32 instanceCount, Uint32 numInstances,
Uint32 firstVertex, Uint32 firstVertex,
Uint32 firstInstance); Uint32 firstInstance);
void (*DrawPrimitivesIndirect)( void (*DrawPrimitivesIndirect)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
SDL_GPUBuffer *buffer, SDL_GPUBuffer *buffer,
Uint32 offsetInBytes, Uint32 offset,
Uint32 drawCount, Uint32 drawCount,
Uint32 stride); Uint32 pitch);
void (*DrawIndexedPrimitivesIndirect)( void (*DrawIndexedPrimitivesIndirect)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
SDL_GPUBuffer *buffer, SDL_GPUBuffer *buffer,
Uint32 offsetInBytes, Uint32 offset,
Uint32 drawCount, Uint32 drawCount,
Uint32 stride); Uint32 pitch);
void (*EndRenderPass)( void (*EndRenderPass)(
SDL_GPUCommandBuffer *commandBuffer); SDL_GPUCommandBuffer *commandBuffer);
@ -502,9 +502,9 @@ struct SDL_GPUDevice
void (*BeginComputePass)( void (*BeginComputePass)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
const SDL_GPUStorageTextureWriteOnlyBinding *storageTextureBindings, const SDL_GPUStorageTextureWriteOnlyBinding *storageTextureBindings,
Uint32 storageTextureBindingCount, Uint32 numStorageTextureBindings,
const SDL_GPUStorageBufferWriteOnlyBinding *storageBufferBindings, const SDL_GPUStorageBufferWriteOnlyBinding *storageBufferBindings,
Uint32 storageBufferBindingCount); Uint32 numStorageBufferBindings);
void (*BindComputePipeline)( void (*BindComputePipeline)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
@ -514,30 +514,30 @@ struct SDL_GPUDevice
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
SDL_GPUTexture *const *storageTextures, SDL_GPUTexture *const *storageTextures,
Uint32 bindingCount); Uint32 numBindings);
void (*BindComputeStorageBuffers)( void (*BindComputeStorageBuffers)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 firstSlot, Uint32 firstSlot,
SDL_GPUBuffer *const *storageBuffers, SDL_GPUBuffer *const *storageBuffers,
Uint32 bindingCount); Uint32 numBindings);
void (*PushComputeUniformData)( void (*PushComputeUniformData)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 slotIndex, Uint32 slotIndex,
const void *data, const void *data,
Uint32 dataLengthInBytes); Uint32 length);
void (*DispatchCompute)( void (*DispatchCompute)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
Uint32 groupCountX, Uint32 groupcountX,
Uint32 groupCountY, Uint32 groupcountY,
Uint32 groupCountZ); Uint32 groupcountZ);
void (*DispatchComputeIndirect)( void (*DispatchComputeIndirect)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
SDL_GPUBuffer *buffer, SDL_GPUBuffer *buffer,
Uint32 offsetInBytes); Uint32 offset);
void (*EndComputePass)( void (*EndComputePass)(
SDL_GPUCommandBuffer *commandBuffer); SDL_GPUCommandBuffer *commandBuffer);
@ -608,7 +608,7 @@ struct SDL_GPUDevice
const SDL_GPUBlitRegion *source, const SDL_GPUBlitRegion *source,
const SDL_GPUBlitRegion *destination, const SDL_GPUBlitRegion *destination,
SDL_FlipMode flipMode, SDL_FlipMode flipMode,
SDL_GPUFilter filterMode, SDL_GPUFilter filter,
bool cycle); bool cycle);
// Submission/Presentation // Submission/Presentation
@ -647,8 +647,8 @@ struct SDL_GPUDevice
SDL_GPUTexture *(*AcquireSwapchainTexture)( SDL_GPUTexture *(*AcquireSwapchainTexture)(
SDL_GPUCommandBuffer *commandBuffer, SDL_GPUCommandBuffer *commandBuffer,
SDL_Window *window, SDL_Window *window,
Uint32 *pWidth, Uint32 *w,
Uint32 *pHeight); Uint32 *h);
void (*Submit)( void (*Submit)(
SDL_GPUCommandBuffer *commandBuffer); SDL_GPUCommandBuffer *commandBuffer);
@ -662,8 +662,8 @@ struct SDL_GPUDevice
void (*WaitForFences)( void (*WaitForFences)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
bool waitAll, bool waitAll,
SDL_GPUFence *const *pFences, SDL_GPUFence *const *fences,
Uint32 fenceCount); Uint32 numFences);
bool (*QueryFence)( bool (*QueryFence)(
SDL_GPURenderer *driverData, SDL_GPURenderer *driverData,
@ -693,8 +693,8 @@ struct SDL_GPUDevice
SDL_GPUDriver backend; SDL_GPUDriver backend;
// Store this for SDL_gpu.c's debug layer // Store this for SDL_gpu.c's debug layer
bool debugMode; bool debug_mode;
SDL_GPUShaderFormat shaderFormats; SDL_GPUShaderFormat shader_formats;
}; };
#define ASSIGN_DRIVER_FUNC(func, name) \ #define ASSIGN_DRIVER_FUNC(func, name) \
@ -780,11 +780,11 @@ struct SDL_GPUDevice
typedef struct SDL_GPUBootstrap typedef struct SDL_GPUBootstrap
{ {
const char *Name; const char *name;
const SDL_GPUDriver backendflag; const SDL_GPUDriver backendflag;
const SDL_GPUShaderFormat shaderFormats; const SDL_GPUShaderFormat shader_formats;
bool (*PrepareDriver)(SDL_VideoDevice *_this); bool (*PrepareDriver)(SDL_VideoDevice *_this);
SDL_GPUDevice *(*CreateDevice)(bool debugMode, bool preferLowPower, SDL_PropertiesID props); SDL_GPUDevice *(*CreateDevice)(bool debug_mode, bool prefer_low_power, SDL_PropertiesID props);
} SDL_GPUBootstrap; } SDL_GPUBootstrap;
#ifdef __cplusplus #ifdef __cplusplus

723
src/gpu/d3d11/SDL_gpu_d3d11.c
View file

File diff suppressed because it is too large Load diff

930
src/gpu/d3d12/SDL_gpu_d3d12.c
View file

File diff suppressed because it is too large Load diff

686
src/gpu/metal/SDL_gpu_metal.m
View file

File diff suppressed because it is too large Load diff

948
src/gpu/vulkan/SDL_gpu_vulkan.c
View file

File diff suppressed because it is too large Load diff

60
src/render/sdlgpu/SDL_pipeline_gpu.c
View file

@ -97,34 +97,34 @@ void GPU_DestroyPipelineCache(GPU_PipelineCache *cache)
static SDL_GPUGraphicsPipeline *MakePipeline(SDL_GPUDevice *device, GPU_Shaders *shaders, const GPU_PipelineParameters *params) static SDL_GPUGraphicsPipeline *MakePipeline(SDL_GPUDevice *device, GPU_Shaders *shaders, const GPU_PipelineParameters *params)
{ {
SDL_GPUColorAttachmentDescription ad; SDL_GPUColorTargetDescription ad;
SDL_zero(ad); SDL_zero(ad);
ad.format = params->attachment_format; ad.format = params->attachment_format;
SDL_BlendMode blend = params->blend_mode; SDL_BlendMode blend = params->blend_mode;
ad.blendState.blendEnable = blend != 0; ad.blend_state.enable_blend = blend != 0;
ad.blendState.colorWriteMask = 0xF; ad.blend_state.color_write_mask = 0xF;
ad.blendState.alphaBlendOp = GPU_ConvertBlendOperation(SDL_GetBlendModeAlphaOperation(blend)); ad.blend_state.alpha_blend_op = GPU_ConvertBlendOperation(SDL_GetBlendModeAlphaOperation(blend));
ad.blendState.dstAlphaBlendFactor = GPU_ConvertBlendFactor(SDL_GetBlendModeDstAlphaFactor(blend)); ad.blend_state.dst_alpha_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeDstAlphaFactor(blend));
ad.blendState.srcAlphaBlendFactor = GPU_ConvertBlendFactor(SDL_GetBlendModeSrcAlphaFactor(blend)); ad.blend_state.src_alpha_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeSrcAlphaFactor(blend));
ad.blendState.colorBlendOp = GPU_ConvertBlendOperation(SDL_GetBlendModeColorOperation(blend)); ad.blend_state.color_blend_op = GPU_ConvertBlendOperation(SDL_GetBlendModeColorOperation(blend));
ad.blendState.dstColorBlendFactor = GPU_ConvertBlendFactor(SDL_GetBlendModeDstColorFactor(blend)); ad.blend_state.dst_color_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeDstColorFactor(blend));
ad.blendState.srcColorBlendFactor = GPU_ConvertBlendFactor(SDL_GetBlendModeSrcColorFactor(blend)); ad.blend_state.src_color_blendfactor = GPU_ConvertBlendFactor(SDL_GetBlendModeSrcColorFactor(blend));
SDL_GPUGraphicsPipelineCreateInfo pci; SDL_GPUGraphicsPipelineCreateInfo pci;
SDL_zero(pci); SDL_zero(pci);
pci.attachmentInfo.hasDepthStencilAttachment = false; pci.target_info.has_depth_stencil_target = false;
pci.attachmentInfo.colorAttachmentCount = 1; pci.target_info.num_color_targets = 1;
pci.attachmentInfo.colorAttachmentDescriptions = &ad; pci.target_info.color_target_descriptions = &ad;
pci.vertexShader = GPU_GetVertexShader(shaders, params->vert_shader); pci.vertex_shader = GPU_GetVertexShader(shaders, params->vert_shader);
pci.fragmentShader = GPU_GetFragmentShader(shaders, params->frag_shader); pci.fragment_shader = GPU_GetFragmentShader(shaders, params->frag_shader);
pci.multisampleState.sampleCount = SDL_GPU_SAMPLECOUNT_1; pci.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1;
pci.multisampleState.sampleMask = 0xFFFF; pci.multisample_state.sample_mask = 0xFFFF;
pci.primitiveType = params->primitive_type; pci.primitive_type = params->primitive_type;
pci.rasterizerState.cullMode = SDL_GPU_CULLMODE_NONE; pci.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE;
pci.rasterizerState.fillMode = SDL_GPU_FILLMODE_FILL; pci.rasterizer_state.fill_mode = SDL_GPU_FILLMODE_FILL;
pci.rasterizerState.frontFace = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE; pci.rasterizer_state.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;
SDL_GPUVertexBinding bind; SDL_GPUVertexBinding bind;
SDL_zero(bind); SDL_zero(bind);
@ -150,16 +150,16 @@ static SDL_GPUGraphicsPipeline *MakePipeline(SDL_GPUDevice *device, GPU_Shaders
// Position // Position
attribs[num_attribs].location = num_attribs; attribs[num_attribs].location = num_attribs;
attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2; attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
attribs[num_attribs].offset = bind.stride; attribs[num_attribs].offset = bind.pitch;
bind.stride += 2 * sizeof(float); bind.pitch += 2 * sizeof(float);
num_attribs++; num_attribs++;
if (have_attr_color) { if (have_attr_color) {
// Color // Color
attribs[num_attribs].location = num_attribs; attribs[num_attribs].location = num_attribs;
attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4; attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4;
attribs[num_attribs].offset = bind.stride; attribs[num_attribs].offset = bind.pitch;
bind.stride += 4 * sizeof(float); bind.pitch += 4 * sizeof(float);
num_attribs++; num_attribs++;
} }
@ -167,15 +167,15 @@ static SDL_GPUGraphicsPipeline *MakePipeline(SDL_GPUDevice *device, GPU_Shaders
// UVs // UVs
attribs[num_attribs].location = num_attribs; attribs[num_attribs].location = num_attribs;
attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2; attribs[num_attribs].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
attribs[num_attribs].offset = bind.stride; attribs[num_attribs].offset = bind.pitch;
bind.stride += 2 * sizeof(float); bind.pitch += 2 * sizeof(float);
num_attribs++; num_attribs++;
} }
pci.vertexInputState.vertexAttributeCount = num_attribs; pci.vertex_input_state.num_vertex_attributes = num_attribs;
pci.vertexInputState.vertexAttributes = attribs; pci.vertex_input_state.vertex_attributes = attribs;
pci.vertexInputState.vertexBindingCount = 1; pci.vertex_input_state.num_vertex_bindings = 1;
pci.vertexInputState.vertexBindings = &bind; pci.vertex_input_state.vertex_bindings = &bind;
return SDL_CreateGPUGraphicsPipeline(device, &pci); return SDL_CreateGPUGraphicsPipeline(device, &pci);
} }

70
src/render/sdlgpu/SDL_render_gpu.c
View file

@ -69,7 +69,7 @@ typedef struct GPU_RenderData
SDL_GPURenderPass *render_pass; SDL_GPURenderPass *render_pass;
SDL_Texture *render_target; SDL_Texture *render_target;
SDL_GPUCommandBuffer *command_buffer; SDL_GPUCommandBuffer *command_buffer;
SDL_GPUColorAttachmentInfo color_attachment; SDL_GPUColorTargetInfo color_attachment;
SDL_GPUViewport viewport; SDL_GPUViewport viewport;
SDL_Rect scissor; SDL_Rect scissor;
SDL_FColor draw_color; SDL_FColor draw_color;
@ -219,12 +219,12 @@ static bool GPU_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_
SDL_GPUTextureCreateInfo tci; SDL_GPUTextureCreateInfo tci;
SDL_zero(tci); SDL_zero(tci);
tci.format = format; tci.format = format;
tci.layerCountOrDepth = 1; tci.layer_count_or_depth = 1;
tci.levelCount = 1; tci.num_levels = 1;
tci.usageFlags = usage; tci.usage = usage;
tci.width = texture->w; tci.width = texture->w;
tci.height = texture->h; tci.height = texture->h;
tci.sampleCount = SDL_GPU_SAMPLECOUNT_1; tci.sample_count = SDL_GPU_SAMPLECOUNT_1;
data->format = format; data->format = format;
data->texture = SDL_CreateGPUTexture(renderdata->device, &tci); data->texture = SDL_CreateGPUTexture(renderdata->device, &tci);
@ -258,7 +258,7 @@ static bool GPU_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
SDL_GPUTransferBufferCreateInfo tbci; SDL_GPUTransferBufferCreateInfo tbci;
SDL_zero(tbci); SDL_zero(tbci);
tbci.sizeInBytes = (Uint32)data_size; tbci.size = (Uint32)data_size;
tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD; tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
SDL_GPUTransferBuffer *tbuf = SDL_CreateGPUTransferBuffer(renderdata->device, &tbci); SDL_GPUTransferBuffer *tbuf = SDL_CreateGPUTransferBuffer(renderdata->device, &tbci);
@ -273,7 +273,7 @@ static bool GPU_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
memcpy(output, pixels, data_size); memcpy(output, pixels, data_size);
} else { } else {
// FIXME is negative pitch supposed to work? // FIXME is negative pitch supposed to work?
// If not, maybe use SDL_GPUTextureTransferInfo::imagePitch instead of this // If not, maybe use SDL_GPUTextureTransferInfo::pixels_per_row instead of this
const Uint8 *input = pixels; const Uint8 *input = pixels;
for (int i = 0; i < rect->h; ++i) { for (int i = 0; i < rect->h; ++i) {
@ -290,9 +290,9 @@ static bool GPU_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
SDL_GPUTextureTransferInfo tex_src; SDL_GPUTextureTransferInfo tex_src;
SDL_zero(tex_src); SDL_zero(tex_src);
tex_src.transferBuffer = tbuf; tex_src.transfer_buffer = tbuf;
tex_src.imageHeight = rect->h; tex_src.rows_per_layer = rect->h;
tex_src.imagePitch = rect->w; tex_src.pixels_per_row = rect->w;
SDL_GPUTextureRegion tex_dst; SDL_GPUTextureRegion tex_dst;
SDL_zero(tex_dst); SDL_zero(tex_dst);
@ -467,7 +467,7 @@ static SDL_GPURenderPass *RestartRenderPass(GPU_RenderData *data)
// This is busted. We should be able to know which load op to use. // This is busted. We should be able to know which load op to use.
// LOAD is incorrect behavior most of the time, unless we had to break a render pass. // LOAD is incorrect behavior most of the time, unless we had to break a render pass.
// -cosmonaut // -cosmonaut
data->state.color_attachment.loadOp = SDL_GPU_LOADOP_LOAD; data->state.color_attachment.load_op = SDL_GPU_LOADOP_LOAD;
data->state.scissor_was_enabled = false; data->state.scissor_was_enabled = false;
return data->state.render_pass; return data->state.render_pass;
@ -524,7 +524,7 @@ static void Draw(
Uint32 offset, Uint32 offset,
SDL_GPUPrimitiveType prim) SDL_GPUPrimitiveType prim)
{ {
if (!data->state.render_pass || data->state.color_attachment.loadOp == SDL_GPU_LOADOP_CLEAR) { if (!data->state.render_pass || data->state.color_attachment.load_op == SDL_GPU_LOADOP_CLEAR) {
RestartRenderPass(data); RestartRenderPass(data);
} }
@ -607,8 +607,8 @@ static bool InitVertexBuffer(GPU_RenderData *data, Uint32 size)
{ {
SDL_GPUBufferCreateInfo bci; SDL_GPUBufferCreateInfo bci;
SDL_zero(bci); SDL_zero(bci);
bci.sizeInBytes = size; bci.size = size;
bci.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX; bci.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
data->vertices.buffer = SDL_CreateGPUBuffer(data->device, &bci); data->vertices.buffer = SDL_CreateGPUBuffer(data->device, &bci);
@ -618,7 +618,7 @@ static bool InitVertexBuffer(GPU_RenderData *data, Uint32 size)
SDL_GPUTransferBufferCreateInfo tbci; SDL_GPUTransferBufferCreateInfo tbci;
SDL_zero(tbci); SDL_zero(tbci);
tbci.sizeInBytes = size; tbci.size = size;
tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD; tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
data->vertices.transfer_buf = SDL_CreateGPUTransferBuffer(data->device, &tbci); data->vertices.transfer_buf = SDL_CreateGPUTransferBuffer(data->device, &tbci);
@ -655,7 +655,7 @@ static bool UploadVertices(GPU_RenderData *data, void *vertices, size_t vertsize
SDL_GPUTransferBufferLocation src; SDL_GPUTransferBufferLocation src;
SDL_zero(src); SDL_zero(src);
src.transferBuffer = data->vertices.transfer_buf; src.transfer_buffer = data->vertices.transfer_buf;
SDL_GPUBufferRegion dst; SDL_GPUBufferRegion dst;
SDL_zero(dst); SDL_zero(dst);
@ -685,7 +685,7 @@ static bool GPU_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
return false; return false;
} }
data->state.color_attachment.loadOp = SDL_GPU_LOADOP_LOAD; data->state.color_attachment.load_op = SDL_GPU_LOADOP_LOAD;
if (renderer->target) { if (renderer->target) {
GPU_TextureData *tdata = renderer->target->internal; GPU_TextureData *tdata = renderer->target->internal;
@ -729,8 +729,8 @@ static bool GPU_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
case SDL_RENDERCMD_CLEAR: case SDL_RENDERCMD_CLEAR:
{ {
data->state.color_attachment.clearColor = GetDrawCmdColor(renderer, cmd); data->state.color_attachment.clear_color = GetDrawCmdColor(renderer, cmd);
data->state.color_attachment.loadOp = SDL_GPU_LOADOP_CLEAR; data->state.color_attachment.load_op = SDL_GPU_LOADOP_CLEAR;
break; break;
} }
@ -823,7 +823,7 @@ static bool GPU_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd,
cmd = cmd->next; cmd = cmd->next;
} }
if (data->state.color_attachment.loadOp == SDL_GPU_LOADOP_CLEAR) { if (data->state.color_attachment.load_op == SDL_GPU_LOADOP_CLEAR) {
RestartRenderPass(data); RestartRenderPass(data);
} }
@ -873,7 +873,7 @@ static SDL_Surface *GPU_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect
SDL_GPUTransferBufferCreateInfo tbci; SDL_GPUTransferBufferCreateInfo tbci;
SDL_zero(tbci); SDL_zero(tbci);
tbci.sizeInBytes = (Uint32)image_size; tbci.size = (Uint32)image_size;
tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD; tbci.usage = SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD;
SDL_GPUTransferBuffer *tbuf = SDL_CreateGPUTransferBuffer(data->device, &tbci); SDL_GPUTransferBuffer *tbuf = SDL_CreateGPUTransferBuffer(data->device, &tbci);
@ -895,9 +895,9 @@ static SDL_Surface *GPU_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect
SDL_GPUTextureTransferInfo dst; SDL_GPUTextureTransferInfo dst;
SDL_zero(dst); SDL_zero(dst);
dst.transferBuffer = tbuf; dst.transfer_buffer = tbuf;
dst.imageHeight = rect->h; dst.rows_per_layer = rect->h;
dst.imagePitch = rect->w; dst.pixels_per_row = rect->w;
SDL_DownloadFromGPUTexture(pass, &src, &dst); SDL_DownloadFromGPUTexture(pass, &src, &dst);
SDL_EndGPUCopyPass(pass); SDL_EndGPUCopyPass(pass);
@ -935,10 +935,10 @@ static bool CreateBackbuffer(GPU_RenderData *data, Uint32 w, Uint32 h, SDL_GPUTe
tci.width = w; tci.width = w;
tci.height = h; tci.height = h;
tci.format = fmt; tci.format = fmt;
tci.layerCountOrDepth = 1; tci.layer_count_or_depth = 1;
tci.levelCount = 1; tci.num_levels = 1;
tci.sampleCount = SDL_GPU_SAMPLECOUNT_1; tci.sample_count = SDL_GPU_SAMPLECOUNT_1;
tci.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; tci.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER;
data->backbuffer.texture = SDL_CreateGPUTexture(data->device, &tci); data->backbuffer.texture = SDL_CreateGPUTexture(data->device, &tci);
data->backbuffer.width = w; data->backbuffer.width = w;
@ -1167,11 +1167,11 @@ static bool InitSamplers(GPU_RenderData *data)
for (Uint32 i = 0; i < SDL_arraysize(configs); ++i) { for (Uint32 i = 0; i < SDL_arraysize(configs); ++i) {
SDL_GPUSamplerCreateInfo sci; SDL_GPUSamplerCreateInfo sci;
SDL_zero(sci); SDL_zero(sci);
sci.maxAnisotropy = configs[i].gpu.anisotropy; sci.max_anisotropy = configs[i].gpu.anisotropy;
sci.anisotropyEnable = configs[i].gpu.anisotropy > 0; sci.enable_anisotropy = configs[i].gpu.anisotropy > 0;
sci.addressModeU = sci.addressModeV = sci.addressModeW = configs[i].gpu.address_mode; sci.address_mode_u = sci.address_mode_v = sci.address_mode_w = configs[i].gpu.address_mode;
sci.minFilter = sci.magFilter = configs[i].gpu.filter; sci.min_filter = sci.mag_filter = configs[i].gpu.filter;
sci.mipmapMode = configs[i].gpu.mipmap_mode; sci.mipmap_mode = configs[i].gpu.mipmap_mode;
SDL_GPUSampler *sampler = SDL_CreateGPUSampler(data->device, &sci); SDL_GPUSampler *sampler = SDL_CreateGPUSampler(data->device, &sci);
@ -1286,8 +1286,8 @@ static bool GPU_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_P
data->state.draw_color.g = 1.0f; data->state.draw_color.g = 1.0f;
data->state.draw_color.b = 1.0f; data->state.draw_color.b = 1.0f;
data->state.draw_color.a = 1.0f; data->state.draw_color.a = 1.0f;
data->state.viewport.minDepth = 0; data->state.viewport.min_depth = 0;
data->state.viewport.maxDepth = 1; data->state.viewport.max_depth = 1;
data->state.command_buffer = SDL_AcquireGPUCommandBuffer(data->device); data->state.command_buffer = SDL_AcquireGPUCommandBuffer(data->device);
int w, h; int w, h;

8
src/render/sdlgpu/SDL_shaders_gpu.c
View file

@ -167,12 +167,12 @@ static SDL_GPUShader *CompileShader(const GPU_ShaderSources *sources, SDL_GPUDev
SDL_GPUShaderCreateInfo sci = { 0 }; SDL_GPUShaderCreateInfo sci = { 0 };
sci.code = sms->code; sci.code = sms->code;
sci.codeSize = sms->code_len; sci.code_size = sms->code_len;
sci.format = sms->format; sci.format = sms->format;
// FIXME not sure if this is correct // FIXME not sure if this is correct
sci.entryPointName = driver == SDL_GPU_DRIVER_METAL ? "main0" : "main"; sci.entrypoint = driver == SDL_GPU_DRIVER_METAL ? "main0" : "main";
sci.samplerCount = sources->num_samplers; sci.num_samplers = sources->num_samplers;
sci.uniformBufferCount = sources->num_uniform_buffers; sci.num_uniform_buffers = sources->num_uniform_buffers;
sci.stage = stage; sci.stage = stage;
return SDL_CreateGPUShader(device, &sci); return SDL_CreateGPUShader(device, &sci);

21
test/testgpu_simple_clear.c
View file

@ -89,17 +89,17 @@ SDL_AppResult SDL_AppIterate(void *appstate)
if (swapchainTexture != NULL) { if (swapchainTexture != NULL) {
const double currentTime = (double)SDL_GetPerformanceCounter() / SDL_GetPerformanceFrequency(); const double currentTime = (double)SDL_GetPerformanceCounter() / SDL_GetPerformanceFrequency();
SDL_GPURenderPass *renderPass; SDL_GPURenderPass *renderPass;
SDL_GPUColorAttachmentInfo colorAttachmentInfo; SDL_GPUColorTargetInfo color_target_info;
SDL_zero(colorAttachmentInfo); SDL_zero(color_target_info);
colorAttachmentInfo.texture = swapchainTexture; color_target_info.texture = swapchainTexture;
colorAttachmentInfo.clearColor.r = (float)(0.5 + 0.5 * SDL_sin(currentTime)); color_target_info.clear_color.r = (float)(0.5 + 0.5 * SDL_sin(currentTime));
colorAttachmentInfo.clearColor.g = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 2 / 3)); color_target_info.clear_color.g = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 2 / 3));
colorAttachmentInfo.clearColor.b = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 4 / 3));; color_target_info.clear_color.b = (float)(0.5 + 0.5 * SDL_sin(currentTime + SDL_PI_D * 4 / 3));;
colorAttachmentInfo.clearColor.a = 1.0f; color_target_info.clear_color.a = 1.0f;
colorAttachmentInfo.loadOp = SDL_GPU_LOADOP_CLEAR; color_target_info.load_op = SDL_GPU_LOADOP_CLEAR;
colorAttachmentInfo.storeOp = SDL_GPU_STOREOP_STORE; color_target_info.store_op = SDL_GPU_STOREOP_STORE;
renderPass = SDL_BeginGPURenderPass(cmdbuf, &colorAttachmentInfo, 1, NULL); renderPass = SDL_BeginGPURenderPass(cmdbuf, &color_target_info, 1, NULL);
SDL_EndGPURenderPass(renderPass); SDL_EndGPURenderPass(renderPass);
} }
@ -122,4 +122,3 @@ void SDL_AppQuit(void *appstate)
SDL_DestroyGPUDevice(gpu_device); SDL_DestroyGPUDevice(gpu_device);
SDLTest_CommonQuit(state); SDLTest_CommonQuit(state);
} }

134
test/testgpu_spinning_cube.c
View file

@ -256,10 +256,10 @@ CreateDepthTexture(Uint32 drawablew, Uint32 drawableh)
depthtex_createinfo.format = SDL_GPU_TEXTUREFORMAT_D16_UNORM; depthtex_createinfo.format = SDL_GPU_TEXTUREFORMAT_D16_UNORM;
depthtex_createinfo.width = drawablew; depthtex_createinfo.width = drawablew;
depthtex_createinfo.height = drawableh; depthtex_createinfo.height = drawableh;
depthtex_createinfo.layerCountOrDepth = 1; depthtex_createinfo.layer_count_or_depth = 1;
depthtex_createinfo.levelCount = 1; depthtex_createinfo.num_levels = 1;
depthtex_createinfo.sampleCount = render_state.sample_count; depthtex_createinfo.sample_count = render_state.sample_count;
depthtex_createinfo.usageFlags = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET; depthtex_createinfo.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET;
depthtex_createinfo.props = 0; depthtex_createinfo.props = 0;
result = SDL_CreateGPUTexture(gpu_device, &depthtex_createinfo); result = SDL_CreateGPUTexture(gpu_device, &depthtex_createinfo);
@ -282,10 +282,10 @@ CreateMSAATexture(Uint32 drawablew, Uint32 drawableh)
msaatex_createinfo.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]); msaatex_createinfo.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]);
msaatex_createinfo.width = drawablew; msaatex_createinfo.width = drawablew;
msaatex_createinfo.height = drawableh; msaatex_createinfo.height = drawableh;
msaatex_createinfo.layerCountOrDepth = 1; msaatex_createinfo.layer_count_or_depth = 1;
msaatex_createinfo.levelCount = 1; msaatex_createinfo.num_levels = 1;
msaatex_createinfo.sampleCount = render_state.sample_count; msaatex_createinfo.sample_count = render_state.sample_count;
msaatex_createinfo.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; msaatex_createinfo.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER;
msaatex_createinfo.props = 0; msaatex_createinfo.props = 0;
result = SDL_CreateGPUTexture(gpu_device, &msaatex_createinfo); result = SDL_CreateGPUTexture(gpu_device, &msaatex_createinfo);
@ -299,8 +299,8 @@ Render(SDL_Window *window, const int windownum)
{ {
WindowState *winstate = &window_states[windownum]; WindowState *winstate = &window_states[windownum];
SDL_GPUTexture *swapchain; SDL_GPUTexture *swapchain;
SDL_GPUColorAttachmentInfo color_attachment; SDL_GPUColorTargetInfo color_target;
SDL_GPUDepthStencilAttachmentInfo depth_attachment; SDL_GPUDepthStencilTargetInfo depth_target;
float matrix_rotate[16], matrix_modelview[16], matrix_perspective[16], matrix_final[16]; float matrix_rotate[16], matrix_modelview[16], matrix_perspective[16], matrix_final[16];
Uint32 drawablew, drawableh; Uint32 drawablew, drawableh;
SDL_GPUCommandBuffer *cmd; SDL_GPUCommandBuffer *cmd;
@ -363,18 +363,18 @@ Render(SDL_Window *window, const int windownum)
/* Set up the pass */ /* Set up the pass */
SDL_zero(color_attachment); SDL_zero(color_target);
color_attachment.clearColor.a = 1.0f; color_target.clear_color.a = 1.0f;
color_attachment.loadOp = SDL_GPU_LOADOP_CLEAR; color_target.load_op = SDL_GPU_LOADOP_CLEAR;
color_attachment.storeOp = SDL_GPU_STOREOP_STORE; color_target.store_op = SDL_GPU_STOREOP_STORE;
color_attachment.texture = winstate->tex_msaa ? winstate->tex_msaa : swapchain; color_target.texture = winstate->tex_msaa ? winstate->tex_msaa : swapchain;
SDL_zero(depth_attachment); SDL_zero(depth_target);
depth_attachment.depthStencilClearValue.depth = 1.0f; depth_target.clear_value.depth = 1.0f;
depth_attachment.loadOp = SDL_GPU_LOADOP_CLEAR; depth_target.load_op = SDL_GPU_LOADOP_CLEAR;
depth_attachment.storeOp = SDL_GPU_STOREOP_DONT_CARE; depth_target.store_op = SDL_GPU_STOREOP_DONT_CARE;
depth_attachment.texture = winstate->tex_depth; depth_target.texture = winstate->tex_depth;
depth_attachment.cycle = SDL_TRUE; depth_target.cycle = SDL_TRUE;
/* Set up the bindings */ /* Set up the bindings */
@ -385,7 +385,7 @@ Render(SDL_Window *window, const int windownum)
SDL_PushGPUVertexUniformData(cmd, 0, matrix_final, sizeof(matrix_final)); SDL_PushGPUVertexUniformData(cmd, 0, matrix_final, sizeof(matrix_final));
pass = SDL_BeginGPURenderPass(cmd, &color_attachment, 1, &depth_attachment); pass = SDL_BeginGPURenderPass(cmd, &color_target, 1, &depth_target);
SDL_BindGPUGraphicsPipeline(pass, render_state.pipeline); SDL_BindGPUGraphicsPipeline(pass, render_state.pipeline);
SDL_BindGPUVertexBuffers(pass, 0, &vertex_binding, 1); SDL_BindGPUVertexBuffers(pass, 0, &vertex_binding, 1);
SDL_DrawGPUPrimitives(pass, 36, 1, 0, 0); SDL_DrawGPUPrimitives(pass, 36, 1, 0, 0);
@ -414,33 +414,33 @@ static SDL_GPUShader*
load_shader(SDL_bool is_vertex) load_shader(SDL_bool is_vertex)
{ {
SDL_GPUShaderCreateInfo createinfo; SDL_GPUShaderCreateInfo createinfo;
createinfo.samplerCount = 0; createinfo.num_samplers = 0;
createinfo.storageBufferCount = 0; createinfo.num_storage_buffers = 0;
createinfo.storageTextureCount = 0; createinfo.num_storage_textures = 0;
createinfo.uniformBufferCount = is_vertex ? 1 : 0; createinfo.num_uniform_buffers = is_vertex ? 1 : 0;
createinfo.props = 0; createinfo.props = 0;
SDL_GPUDriver backend = SDL_GetGPUDriver(gpu_device); SDL_GPUDriver backend = SDL_GetGPUDriver(gpu_device);
if (backend == SDL_GPU_DRIVER_D3D11) { if (backend == SDL_GPU_DRIVER_D3D11) {
createinfo.format = SDL_GPU_SHADERFORMAT_DXBC; createinfo.format = SDL_GPU_SHADERFORMAT_DXBC;
createinfo.code = is_vertex ? D3D11_CubeVert : D3D11_CubeFrag; createinfo.code = is_vertex ? D3D11_CubeVert : D3D11_CubeFrag;
createinfo.codeSize = is_vertex ? SDL_arraysize(D3D11_CubeVert) : SDL_arraysize(D3D11_CubeFrag); createinfo.code_size = is_vertex ? SDL_arraysize(D3D11_CubeVert) : SDL_arraysize(D3D11_CubeFrag);
createinfo.entryPointName = is_vertex ? "VSMain" : "PSMain"; createinfo.entrypoint = is_vertex ? "VSMain" : "PSMain";
} else if (backend == SDL_GPU_DRIVER_D3D12) { } else if (backend == SDL_GPU_DRIVER_D3D12) {
createinfo.format = SDL_GPU_SHADERFORMAT_DXIL; createinfo.format = SDL_GPU_SHADERFORMAT_DXIL;
createinfo.code = is_vertex ? D3D12_CubeVert : D3D12_CubeFrag; createinfo.code = is_vertex ? D3D12_CubeVert : D3D12_CubeFrag;
createinfo.codeSize = is_vertex ? SDL_arraysize(D3D12_CubeVert) : SDL_arraysize(D3D12_CubeFrag); createinfo.code_size = is_vertex ? SDL_arraysize(D3D12_CubeVert) : SDL_arraysize(D3D12_CubeFrag);
createinfo.entryPointName = is_vertex ? "VSMain" : "PSMain"; createinfo.entrypoint = is_vertex ? "VSMain" : "PSMain";
} else if (backend == SDL_GPU_DRIVER_METAL) { } else if (backend == SDL_GPU_DRIVER_METAL) {
createinfo.format = SDL_GPU_SHADERFORMAT_METALLIB; createinfo.format = SDL_GPU_SHADERFORMAT_METALLIB;
createinfo.code = is_vertex ? cube_vert_metallib : cube_frag_metallib; createinfo.code = is_vertex ? cube_vert_metallib : cube_frag_metallib;
createinfo.codeSize = is_vertex ? cube_vert_metallib_len : cube_frag_metallib_len; createinfo.code_size = is_vertex ? cube_vert_metallib_len : cube_frag_metallib_len;
createinfo.entryPointName = is_vertex ? "vs_main" : "fs_main"; createinfo.entrypoint = is_vertex ? "vs_main" : "fs_main";
} else { } else {
createinfo.format = SDL_GPU_SHADERFORMAT_SPIRV; createinfo.format = SDL_GPU_SHADERFORMAT_SPIRV;
createinfo.code = is_vertex ? cube_vert_spv : cube_frag_spv; createinfo.code = is_vertex ? cube_vert_spv : cube_frag_spv;
createinfo.codeSize = is_vertex ? cube_vert_spv_len : cube_frag_spv_len; createinfo.code_size = is_vertex ? cube_vert_spv_len : cube_frag_spv_len;
createinfo.entryPointName = "main"; createinfo.entrypoint = "main";
} }
createinfo.stage = is_vertex ? SDL_GPU_SHADERSTAGE_VERTEX : SDL_GPU_SHADERSTAGE_FRAGMENT; createinfo.stage = is_vertex ? SDL_GPU_SHADERSTAGE_VERTEX : SDL_GPU_SHADERSTAGE_FRAGMENT;
@ -459,7 +459,7 @@ init_render_state(int msaa)
SDL_GPUBufferCreateInfo buffer_desc; SDL_GPUBufferCreateInfo buffer_desc;
SDL_GPUTransferBufferCreateInfo transfer_buffer_desc; SDL_GPUTransferBufferCreateInfo transfer_buffer_desc;
SDL_GPUGraphicsPipelineCreateInfo pipelinedesc; SDL_GPUGraphicsPipelineCreateInfo pipelinedesc;
SDL_GPUColorAttachmentDescription color_attachment_desc; SDL_GPUColorTargetDescription color_target_desc;
Uint32 drawablew, drawableh; Uint32 drawablew, drawableh;
SDL_GPUVertexAttribute vertex_attributes[2]; SDL_GPUVertexAttribute vertex_attributes[2];
SDL_GPUVertexBinding vertex_binding; SDL_GPUVertexBinding vertex_binding;
@ -492,8 +492,8 @@ init_render_state(int msaa)
/* Create buffers */ /* Create buffers */
buffer_desc.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX; buffer_desc.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
buffer_desc.sizeInBytes = sizeof(vertex_data); buffer_desc.size = sizeof(vertex_data);
buffer_desc.props = 0; buffer_desc.props = 0;
render_state.buf_vertex = SDL_CreateGPUBuffer( render_state.buf_vertex = SDL_CreateGPUBuffer(
gpu_device, gpu_device,
@ -504,7 +504,7 @@ init_render_state(int msaa)
SDL_SetGPUBufferName(gpu_device, render_state.buf_vertex, "космонавт"); SDL_SetGPUBufferName(gpu_device, render_state.buf_vertex, "космонавт");
transfer_buffer_desc.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD; transfer_buffer_desc.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
transfer_buffer_desc.sizeInBytes = sizeof(vertex_data); transfer_buffer_desc.size = sizeof(vertex_data);
transfer_buffer_desc.props = 0; transfer_buffer_desc.props = 0;
buf_transfer = SDL_CreateGPUTransferBuffer( buf_transfer = SDL_CreateGPUTransferBuffer(
gpu_device, gpu_device,
@ -519,7 +519,7 @@ init_render_state(int msaa)
cmd = SDL_AcquireGPUCommandBuffer(gpu_device); cmd = SDL_AcquireGPUCommandBuffer(gpu_device);
copy_pass = SDL_BeginGPUCopyPass(cmd); copy_pass = SDL_BeginGPUCopyPass(cmd);
buf_location.transferBuffer = buf_transfer; buf_location.transfer_buffer = buf_transfer;
buf_location.offset = 0; buf_location.offset = 0;
dst_region.buffer = render_state.buf_vertex; dst_region.buffer = render_state.buf_vertex;
dst_region.offset = 0; dst_region.offset = 0;
@ -543,38 +543,38 @@ init_render_state(int msaa)
SDL_zero(pipelinedesc); SDL_zero(pipelinedesc);
color_attachment_desc.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]); color_target_desc.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]);
color_attachment_desc.blendState.blendEnable = 0; color_target_desc.blend_state.enable_blend = 0;
color_attachment_desc.blendState.alphaBlendOp = SDL_GPU_BLENDOP_ADD; color_target_desc.blend_state.alpha_blend_op = SDL_GPU_BLENDOP_ADD;
color_attachment_desc.blendState.colorBlendOp = SDL_GPU_BLENDOP_ADD; color_target_desc.blend_state.color_blend_op = SDL_GPU_BLENDOP_ADD;
color_attachment_desc.blendState.colorWriteMask = 0xF; color_target_desc.blend_state.color_write_mask = 0xF;
color_attachment_desc.blendState.srcAlphaBlendFactor = SDL_GPU_BLENDFACTOR_ONE; color_target_desc.blend_state.src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE;
color_attachment_desc.blendState.dstAlphaBlendFactor = SDL_GPU_BLENDFACTOR_ZERO; color_target_desc.blend_state.dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ZERO;
color_attachment_desc.blendState.srcColorBlendFactor = SDL_GPU_BLENDFACTOR_ONE; color_target_desc.blend_state.src_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE;
color_attachment_desc.blendState.dstColorBlendFactor = SDL_GPU_BLENDFACTOR_ZERO; color_target_desc.blend_state.dst_color_blendfactor = SDL_GPU_BLENDFACTOR_ZERO;
pipelinedesc.attachmentInfo.colorAttachmentCount = 1; pipelinedesc.target_info.num_color_targets = 1;
pipelinedesc.attachmentInfo.colorAttachmentDescriptions = &color_attachment_desc; pipelinedesc.target_info.color_target_descriptions = &color_target_desc;
pipelinedesc.attachmentInfo.depthStencilFormat = SDL_GPU_TEXTUREFORMAT_D16_UNORM; pipelinedesc.target_info.depth_stencil_format = SDL_GPU_TEXTUREFORMAT_D16_UNORM;
pipelinedesc.attachmentInfo.hasDepthStencilAttachment = SDL_TRUE; pipelinedesc.target_info.has_depth_stencil_target = SDL_TRUE;
pipelinedesc.depthStencilState.depthTestEnable = 1; pipelinedesc.depth_stencil_state.enable_depth_test = 1;
pipelinedesc.depthStencilState.depthWriteEnable = 1; pipelinedesc.depth_stencil_state.enable_depth_write = 1;
pipelinedesc.depthStencilState.compareOp = SDL_GPU_COMPAREOP_LESS_OR_EQUAL; pipelinedesc.depth_stencil_state.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL;
pipelinedesc.multisampleState.sampleCount = render_state.sample_count; pipelinedesc.multisample_state.sample_count = render_state.sample_count;
pipelinedesc.multisampleState.sampleMask = 0xF; pipelinedesc.multisample_state.sample_mask = 0xF;
pipelinedesc.primitiveType = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; pipelinedesc.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
pipelinedesc.vertexShader = vertex_shader; pipelinedesc.vertex_shader = vertex_shader;
pipelinedesc.fragmentShader = fragment_shader; pipelinedesc.fragment_shader = fragment_shader;
vertex_binding.binding = 0; vertex_binding.binding = 0;
vertex_binding.inputRate = SDL_GPU_VERTEXINPUTRATE_VERTEX; vertex_binding.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
vertex_binding.instanceStepRate = 0; vertex_binding.instance_step_rate = 0;
vertex_binding.stride = sizeof(VertexData); vertex_binding.pitch = sizeof(VertexData);
vertex_attributes[0].binding = 0; vertex_attributes[0].binding = 0;
vertex_attributes[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3; vertex_attributes[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3;
@ -586,10 +586,10 @@ init_render_state(int msaa)
vertex_attributes[1].location = 1; vertex_attributes[1].location = 1;
vertex_attributes[1].offset = sizeof(float) * 3; vertex_attributes[1].offset = sizeof(float) * 3;
pipelinedesc.vertexInputState.vertexBindingCount = 1; pipelinedesc.vertex_input_state.num_vertex_bindings = 1;
pipelinedesc.vertexInputState.vertexBindings = &vertex_binding; pipelinedesc.vertex_input_state.vertex_bindings = &vertex_binding;
pipelinedesc.vertexInputState.vertexAttributeCount = 2; pipelinedesc.vertex_input_state.num_vertex_attributes = 2;
pipelinedesc.vertexInputState.vertexAttributes = (SDL_GPUVertexAttribute*) &vertex_attributes; pipelinedesc.vertex_input_state.vertex_attributes = (SDL_GPUVertexAttribute*) &vertex_attributes;
pipelinedesc.props = 0; pipelinedesc.props = 0;