From 6aaedb813fa11ba0679c3051bc2eb28646b9506c Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 30 Aug 2025 16:53:58 -0700 Subject: Update to SDL3 --- .../SDL-3.2.20/test/testgpu_spinning_cube.c | 761 +++++++++++++++++++++ 1 file changed, 761 insertions(+) create mode 100644 src/contrib/SDL-3.2.20/test/testgpu_spinning_cube.c (limited to 'src/contrib/SDL-3.2.20/test/testgpu_spinning_cube.c') diff --git a/src/contrib/SDL-3.2.20/test/testgpu_spinning_cube.c b/src/contrib/SDL-3.2.20/test/testgpu_spinning_cube.c new file mode 100644 index 0000000..0eeb034 --- /dev/null +++ b/src/contrib/SDL-3.2.20/test/testgpu_spinning_cube.c @@ -0,0 +1,761 @@ +/* + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely. +*/ + +#include + +#ifdef __EMSCRIPTEN__ +#include +#endif + +#include +#include +#include + +/* Regenerate the shaders with testgpu/build-shaders.sh */ +#include "testgpu/testgpu_spirv.h" +#include "testgpu/testgpu_dxil.h" +#include "testgpu/testgpu_metallib.h" + +#define TESTGPU_SUPPORTED_FORMATS (SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_DXBC | SDL_GPU_SHADERFORMAT_DXIL | SDL_GPU_SHADERFORMAT_METALLIB) + +#define CHECK_CREATE(var, thing) { if (!(var)) { SDL_Log("Failed to create %s: %s", thing, SDL_GetError()); quit(2); } } + +static Uint32 frames = 0; + +typedef struct RenderState +{ + SDL_GPUBuffer *buf_vertex; + SDL_GPUGraphicsPipeline *pipeline; + SDL_GPUSampleCount sample_count; +} RenderState; + +typedef struct WindowState +{ + int angle_x, angle_y, angle_z; + SDL_GPUTexture *tex_depth, *tex_msaa, *tex_resolve; + Uint32 prev_drawablew, prev_drawableh; +} WindowState; + +static SDL_GPUDevice *gpu_device = NULL; +static RenderState render_state; +static SDLTest_CommonState *state = NULL; +static WindowState *window_states = NULL; + +static void shutdownGPU(void) +{ + if (window_states) { + int i; + for (i = 0; i < state->num_windows; i++) { + WindowState *winstate = &window_states[i]; + SDL_ReleaseGPUTexture(gpu_device, winstate->tex_depth); + SDL_ReleaseGPUTexture(gpu_device, winstate->tex_msaa); + SDL_ReleaseGPUTexture(gpu_device, winstate->tex_resolve); + SDL_ReleaseWindowFromGPUDevice(gpu_device, state->windows[i]); + } + SDL_free(window_states); + window_states = NULL; + } + + SDL_ReleaseGPUBuffer(gpu_device, render_state.buf_vertex); + SDL_ReleaseGPUGraphicsPipeline(gpu_device, render_state.pipeline); + SDL_DestroyGPUDevice(gpu_device); + + SDL_zero(render_state); + gpu_device = NULL; +} + + +/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ +static void +quit(int rc) +{ + shutdownGPU(); + SDLTest_CommonQuit(state); + exit(rc); +} + +/* + * Simulates desktop's glRotatef. The matrix is returned in column-major + * order. + */ +static void +rotate_matrix(float angle, float x, float y, float z, float *r) +{ + float radians, c, s, c1, u[3], length; + int i, j; + + radians = angle * SDL_PI_F / 180.0f; + + c = SDL_cosf(radians); + s = SDL_sinf(radians); + + c1 = 1.0f - SDL_cosf(radians); + + length = (float)SDL_sqrt(x * x + y * y + z * z); + + u[0] = x / length; + u[1] = y / length; + u[2] = z / length; + + for (i = 0; i < 16; i++) { + r[i] = 0.0; + } + + r[15] = 1.0; + + for (i = 0; i < 3; i++) { + r[i * 4 + (i + 1) % 3] = u[(i + 2) % 3] * s; + r[i * 4 + (i + 2) % 3] = -u[(i + 1) % 3] * s; + } + + for (i = 0; i < 3; i++) { + for (j = 0; j < 3; j++) { + r[i * 4 + j] += c1 * u[i] * u[j] + (i == j ? c : 0.0f); + } + } +} + +/* + * Simulates gluPerspectiveMatrix + */ +static void +perspective_matrix(float fovy, float aspect, float znear, float zfar, float *r) +{ + int i; + float f; + + f = 1.0f/SDL_tanf(fovy * 0.5f); + + for (i = 0; i < 16; i++) { + r[i] = 0.0; + } + + r[0] = f / aspect; + r[5] = f; + r[10] = (znear + zfar) / (znear - zfar); + r[11] = -1.0f; + r[14] = (2.0f * znear * zfar) / (znear - zfar); + r[15] = 0.0f; +} + +/* + * Multiplies lhs by rhs and writes out to r. All matrices are 4x4 and column + * major. In-place multiplication is supported. + */ +static void +multiply_matrix(const float *lhs, const float *rhs, float *r) +{ + int i, j, k; + float tmp[16]; + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + tmp[j * 4 + i] = 0.0; + + for (k = 0; k < 4; k++) { + tmp[j * 4 + i] += lhs[k * 4 + i] * rhs[j * 4 + k]; + } + } + } + + for (i = 0; i < 16; i++) { + r[i] = tmp[i]; + } +} + +typedef struct VertexData +{ + float x, y, z; /* 3D data. Vertex range -0.5..0.5 in all axes. Z -0.5 is near, 0.5 is far. */ + float red, green, blue; /* intensity 0 to 1 (alpha is always 1). */ +} VertexData; + +static const VertexData vertex_data[] = { + /* Front face. */ + /* Bottom left */ + { -0.5, 0.5, -0.5, 1.0, 0.0, 0.0 }, /* red */ + { 0.5, -0.5, -0.5, 0.0, 0.0, 1.0 }, /* blue */ + { -0.5, -0.5, -0.5, 0.0, 1.0, 0.0 }, /* green */ + + /* Top right */ + { -0.5, 0.5, -0.5, 1.0, 0.0, 0.0 }, /* red */ + { 0.5, 0.5, -0.5, 1.0, 1.0, 0.0 }, /* yellow */ + { 0.5, -0.5, -0.5, 0.0, 0.0, 1.0 }, /* blue */ + + /* Left face */ + /* Bottom left */ + { -0.5, 0.5, 0.5, 1.0, 1.0, 1.0 }, /* white */ + { -0.5, -0.5, -0.5, 0.0, 1.0, 0.0 }, /* green */ + { -0.5, -0.5, 0.5, 0.0, 1.0, 1.0 }, /* cyan */ + + /* Top right */ + { -0.5, 0.5, 0.5, 1.0, 1.0, 1.0 }, /* white */ + { -0.5, 0.5, -0.5, 1.0, 0.0, 0.0 }, /* red */ + { -0.5, -0.5, -0.5, 0.0, 1.0, 0.0 }, /* green */ + + /* Top face */ + /* Bottom left */ + { -0.5, 0.5, 0.5, 1.0, 1.0, 1.0 }, /* white */ + { 0.5, 0.5, -0.5, 1.0, 1.0, 0.0 }, /* yellow */ + { -0.5, 0.5, -0.5, 1.0, 0.0, 0.0 }, /* red */ + + /* Top right */ + { -0.5, 0.5, 0.5, 1.0, 1.0, 1.0 }, /* white */ + { 0.5, 0.5, 0.5, 0.0, 0.0, 0.0 }, /* black */ + { 0.5, 0.5, -0.5, 1.0, 1.0, 0.0 }, /* yellow */ + + /* Right face */ + /* Bottom left */ + { 0.5, 0.5, -0.5, 1.0, 1.0, 0.0 }, /* yellow */ + { 0.5, -0.5, 0.5, 1.0, 0.0, 1.0 }, /* magenta */ + { 0.5, -0.5, -0.5, 0.0, 0.0, 1.0 }, /* blue */ + + /* Top right */ + { 0.5, 0.5, -0.5, 1.0, 1.0, 0.0 }, /* yellow */ + { 0.5, 0.5, 0.5, 0.0, 0.0, 0.0 }, /* black */ + { 0.5, -0.5, 0.5, 1.0, 0.0, 1.0 }, /* magenta */ + + /* Back face */ + /* Bottom left */ + { 0.5, 0.5, 0.5, 0.0, 0.0, 0.0 }, /* black */ + { -0.5, -0.5, 0.5, 0.0, 1.0, 1.0 }, /* cyan */ + { 0.5, -0.5, 0.5, 1.0, 0.0, 1.0 }, /* magenta */ + + /* Top right */ + { 0.5, 0.5, 0.5, 0.0, 0.0, 0.0 }, /* black */ + { -0.5, 0.5, 0.5, 1.0, 1.0, 1.0 }, /* white */ + { -0.5, -0.5, 0.5, 0.0, 1.0, 1.0 }, /* cyan */ + + /* Bottom face */ + /* Bottom left */ + { -0.5, -0.5, -0.5, 0.0, 1.0, 0.0 }, /* green */ + { 0.5, -0.5, 0.5, 1.0, 0.0, 1.0 }, /* magenta */ + { -0.5, -0.5, 0.5, 0.0, 1.0, 1.0 }, /* cyan */ + + /* Top right */ + { -0.5, -0.5, -0.5, 0.0, 1.0, 0.0 }, /* green */ + { 0.5, -0.5, -0.5, 0.0, 0.0, 1.0 }, /* blue */ + { 0.5, -0.5, 0.5, 1.0, 0.0, 1.0 } /* magenta */ +}; + +static SDL_GPUTexture* +CreateDepthTexture(Uint32 drawablew, Uint32 drawableh) +{ + SDL_GPUTextureCreateInfo createinfo; + SDL_GPUTexture *result; + + createinfo.type = SDL_GPU_TEXTURETYPE_2D; + createinfo.format = SDL_GPU_TEXTUREFORMAT_D16_UNORM; + createinfo.width = drawablew; + createinfo.height = drawableh; + createinfo.layer_count_or_depth = 1; + createinfo.num_levels = 1; + createinfo.sample_count = render_state.sample_count; + createinfo.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET; + createinfo.props = 0; + + result = SDL_CreateGPUTexture(gpu_device, &createinfo); + CHECK_CREATE(result, "Depth Texture") + + return result; +} + +static SDL_GPUTexture* +CreateMSAATexture(Uint32 drawablew, Uint32 drawableh) +{ + SDL_GPUTextureCreateInfo createinfo; + SDL_GPUTexture *result; + + if (render_state.sample_count == SDL_GPU_SAMPLECOUNT_1) { + return NULL; + } + + createinfo.type = SDL_GPU_TEXTURETYPE_2D; + createinfo.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]); + createinfo.width = drawablew; + createinfo.height = drawableh; + createinfo.layer_count_or_depth = 1; + createinfo.num_levels = 1; + createinfo.sample_count = render_state.sample_count; + createinfo.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; + createinfo.props = 0; + + result = SDL_CreateGPUTexture(gpu_device, &createinfo); + CHECK_CREATE(result, "MSAA Texture") + + return result; +} + +static SDL_GPUTexture * +CreateResolveTexture(Uint32 drawablew, Uint32 drawableh) +{ + SDL_GPUTextureCreateInfo createinfo; + SDL_GPUTexture *result; + + if (render_state.sample_count == SDL_GPU_SAMPLECOUNT_1) { + return NULL; + } + + createinfo.type = SDL_GPU_TEXTURETYPE_2D; + createinfo.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]); + createinfo.width = drawablew; + createinfo.height = drawableh; + createinfo.layer_count_or_depth = 1; + createinfo.num_levels = 1; + createinfo.sample_count = SDL_GPU_SAMPLECOUNT_1; + createinfo.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; + createinfo.props = 0; + + result = SDL_CreateGPUTexture(gpu_device, &createinfo); + CHECK_CREATE(result, "Resolve Texture") + + return result; +} + +static void +Render(SDL_Window *window, const int windownum) +{ + WindowState *winstate = &window_states[windownum]; + SDL_GPUTexture *swapchainTexture; + SDL_GPUColorTargetInfo color_target; + SDL_GPUDepthStencilTargetInfo depth_target; + float matrix_rotate[16], matrix_modelview[16], matrix_perspective[16], matrix_final[16]; + SDL_GPUCommandBuffer *cmd; + SDL_GPURenderPass *pass; + SDL_GPUBufferBinding vertex_binding; + SDL_GPUBlitInfo blit_info; + Uint32 drawablew, drawableh; + + /* Acquire the swapchain texture */ + + cmd = SDL_AcquireGPUCommandBuffer(gpu_device); + if (!cmd) { + SDL_Log("Failed to acquire command buffer :%s", SDL_GetError()); + quit(2); + } + if (!SDL_WaitAndAcquireGPUSwapchainTexture(cmd, state->windows[windownum], &swapchainTexture, &drawablew, &drawableh)) { + SDL_Log("Failed to acquire swapchain texture: %s", SDL_GetError()); + quit(2); + } + + if (swapchainTexture == NULL) { + /* Swapchain is unavailable, cancel work */ + SDL_CancelGPUCommandBuffer(cmd); + return; + } + + /* + * Do some rotation with Euler angles. It is not a fixed axis as + * quaternions would be, but the effect is cool. + */ + rotate_matrix((float)winstate->angle_x, 1.0f, 0.0f, 0.0f, matrix_modelview); + rotate_matrix((float)winstate->angle_y, 0.0f, 1.0f, 0.0f, matrix_rotate); + + multiply_matrix(matrix_rotate, matrix_modelview, matrix_modelview); + + rotate_matrix((float)winstate->angle_z, 0.0f, 1.0f, 0.0f, matrix_rotate); + + multiply_matrix(matrix_rotate, matrix_modelview, matrix_modelview); + + /* Pull the camera back from the cube */ + matrix_modelview[14] -= 2.5f; + + perspective_matrix(45.0f, (float)drawablew/drawableh, 0.01f, 100.0f, matrix_perspective); + multiply_matrix(matrix_perspective, matrix_modelview, (float*) &matrix_final); + + winstate->angle_x += 3; + winstate->angle_y += 2; + winstate->angle_z += 1; + + if(winstate->angle_x >= 360) winstate->angle_x -= 360; + if(winstate->angle_x < 0) winstate->angle_x += 360; + if(winstate->angle_y >= 360) winstate->angle_y -= 360; + if(winstate->angle_y < 0) winstate->angle_y += 360; + if(winstate->angle_z >= 360) winstate->angle_z -= 360; + if(winstate->angle_z < 0) winstate->angle_z += 360; + + /* Resize the depth buffer if the window size changed */ + + if (winstate->prev_drawablew != drawablew || winstate->prev_drawableh != drawableh) { + SDL_ReleaseGPUTexture(gpu_device, winstate->tex_depth); + SDL_ReleaseGPUTexture(gpu_device, winstate->tex_msaa); + SDL_ReleaseGPUTexture(gpu_device, winstate->tex_resolve); + winstate->tex_depth = CreateDepthTexture(drawablew, drawableh); + winstate->tex_msaa = CreateMSAATexture(drawablew, drawableh); + winstate->tex_resolve = CreateResolveTexture(drawablew, drawableh); + } + winstate->prev_drawablew = drawablew; + winstate->prev_drawableh = drawableh; + + /* Set up the pass */ + + SDL_zero(color_target); + color_target.clear_color.a = 1.0f; + if (winstate->tex_msaa) { + color_target.load_op = SDL_GPU_LOADOP_CLEAR; + color_target.store_op = SDL_GPU_STOREOP_RESOLVE; + color_target.texture = winstate->tex_msaa; + color_target.resolve_texture = winstate->tex_resolve; + color_target.cycle = true; + color_target.cycle_resolve_texture = true; + } else { + color_target.load_op = SDL_GPU_LOADOP_CLEAR; + color_target.store_op = SDL_GPU_STOREOP_STORE; + color_target.texture = swapchainTexture; + } + + SDL_zero(depth_target); + depth_target.clear_depth = 1.0f; + depth_target.load_op = SDL_GPU_LOADOP_CLEAR; + depth_target.store_op = SDL_GPU_STOREOP_DONT_CARE; + depth_target.stencil_load_op = SDL_GPU_LOADOP_DONT_CARE; + depth_target.stencil_store_op = SDL_GPU_STOREOP_DONT_CARE; + depth_target.texture = winstate->tex_depth; + depth_target.cycle = true; + + /* Set up the bindings */ + + vertex_binding.buffer = render_state.buf_vertex; + vertex_binding.offset = 0; + + /* Draw the cube! */ + + SDL_PushGPUVertexUniformData(cmd, 0, matrix_final, sizeof(matrix_final)); + + pass = SDL_BeginGPURenderPass(cmd, &color_target, 1, &depth_target); + SDL_BindGPUGraphicsPipeline(pass, render_state.pipeline); + SDL_BindGPUVertexBuffers(pass, 0, &vertex_binding, 1); + SDL_DrawGPUPrimitives(pass, 36, 1, 0, 0); + SDL_EndGPURenderPass(pass); + + /* Blit MSAA resolve target to swapchain, if needed */ + if (render_state.sample_count > SDL_GPU_SAMPLECOUNT_1) { + SDL_zero(blit_info); + blit_info.source.texture = winstate->tex_resolve; + blit_info.source.w = drawablew; + blit_info.source.h = drawableh; + + blit_info.destination.texture = swapchainTexture; + blit_info.destination.w = drawablew; + blit_info.destination.h = drawableh; + + blit_info.load_op = SDL_GPU_LOADOP_DONT_CARE; + blit_info.filter = SDL_GPU_FILTER_LINEAR; + + SDL_BlitGPUTexture(cmd, &blit_info); + } + + /* Submit the command buffer! */ + SDL_SubmitGPUCommandBuffer(cmd); + + ++frames; +} + +static SDL_GPUShader* +load_shader(bool is_vertex) +{ + SDL_GPUShaderCreateInfo createinfo; + createinfo.num_samplers = 0; + createinfo.num_storage_buffers = 0; + createinfo.num_storage_textures = 0; + createinfo.num_uniform_buffers = is_vertex ? 1 : 0; + createinfo.props = 0; + + SDL_GPUShaderFormat format = SDL_GetGPUShaderFormats(gpu_device); + if (format & SDL_GPU_SHADERFORMAT_DXIL) { + createinfo.format = SDL_GPU_SHADERFORMAT_DXIL; + createinfo.code = is_vertex ? D3D12_CubeVert : D3D12_CubeFrag; + createinfo.code_size = is_vertex ? SDL_arraysize(D3D12_CubeVert) : SDL_arraysize(D3D12_CubeFrag); + createinfo.entrypoint = is_vertex ? "VSMain" : "PSMain"; + } else if (format & SDL_GPU_SHADERFORMAT_METALLIB) { + createinfo.format = SDL_GPU_SHADERFORMAT_METALLIB; + createinfo.code = is_vertex ? cube_vert_metallib : cube_frag_metallib; + createinfo.code_size = is_vertex ? cube_vert_metallib_len : cube_frag_metallib_len; + createinfo.entrypoint = is_vertex ? "vs_main" : "fs_main"; + } else { + createinfo.format = SDL_GPU_SHADERFORMAT_SPIRV; + createinfo.code = is_vertex ? cube_vert_spv : cube_frag_spv; + createinfo.code_size = is_vertex ? cube_vert_spv_len : cube_frag_spv_len; + createinfo.entrypoint = "main"; + } + + createinfo.stage = is_vertex ? SDL_GPU_SHADERSTAGE_VERTEX : SDL_GPU_SHADERSTAGE_FRAGMENT; + return SDL_CreateGPUShader(gpu_device, &createinfo); +} + +static void +init_render_state(int msaa) +{ + SDL_GPUCommandBuffer *cmd; + SDL_GPUTransferBuffer *buf_transfer; + void *map; + SDL_GPUTransferBufferLocation buf_location; + SDL_GPUBufferRegion dst_region; + SDL_GPUCopyPass *copy_pass; + SDL_GPUBufferCreateInfo buffer_desc; + SDL_GPUTransferBufferCreateInfo transfer_buffer_desc; + SDL_GPUGraphicsPipelineCreateInfo pipelinedesc; + SDL_GPUColorTargetDescription color_target_desc; + Uint32 drawablew, drawableh; + SDL_GPUVertexAttribute vertex_attributes[2]; + SDL_GPUVertexBufferDescription vertex_buffer_desc; + SDL_GPUShader *vertex_shader; + SDL_GPUShader *fragment_shader; + int i; + + gpu_device = SDL_CreateGPUDevice( + TESTGPU_SUPPORTED_FORMATS, + true, + state->gpudriver + ); + CHECK_CREATE(gpu_device, "GPU device"); + + /* Claim the windows */ + + for (i = 0; i < state->num_windows; i++) { + SDL_ClaimWindowForGPUDevice( + gpu_device, + state->windows[i] + ); + } + + /* Create shaders */ + + vertex_shader = load_shader(true); + CHECK_CREATE(vertex_shader, "Vertex Shader") + fragment_shader = load_shader(false); + CHECK_CREATE(fragment_shader, "Fragment Shader") + + /* Create buffers */ + + buffer_desc.usage = SDL_GPU_BUFFERUSAGE_VERTEX; + buffer_desc.size = sizeof(vertex_data); + buffer_desc.props = SDL_CreateProperties(); + SDL_SetStringProperty(buffer_desc.props, SDL_PROP_GPU_BUFFER_CREATE_NAME_STRING, "космонавт"); + render_state.buf_vertex = SDL_CreateGPUBuffer( + gpu_device, + &buffer_desc + ); + CHECK_CREATE(render_state.buf_vertex, "Static vertex buffer") + SDL_DestroyProperties(buffer_desc.props); + + transfer_buffer_desc.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD; + transfer_buffer_desc.size = sizeof(vertex_data); + transfer_buffer_desc.props = SDL_CreateProperties(); + SDL_SetStringProperty(transfer_buffer_desc.props, SDL_PROP_GPU_TRANSFERBUFFER_CREATE_NAME_STRING, "Transfer Buffer"); + buf_transfer = SDL_CreateGPUTransferBuffer( + gpu_device, + &transfer_buffer_desc + ); + CHECK_CREATE(buf_transfer, "Vertex transfer buffer") + SDL_DestroyProperties(transfer_buffer_desc.props); + + /* We just need to upload the static data once. */ + map = SDL_MapGPUTransferBuffer(gpu_device, buf_transfer, false); + SDL_memcpy(map, vertex_data, sizeof(vertex_data)); + SDL_UnmapGPUTransferBuffer(gpu_device, buf_transfer); + + cmd = SDL_AcquireGPUCommandBuffer(gpu_device); + copy_pass = SDL_BeginGPUCopyPass(cmd); + buf_location.transfer_buffer = buf_transfer; + buf_location.offset = 0; + dst_region.buffer = render_state.buf_vertex; + dst_region.offset = 0; + dst_region.size = sizeof(vertex_data); + SDL_UploadToGPUBuffer(copy_pass, &buf_location, &dst_region, false); + SDL_EndGPUCopyPass(copy_pass); + SDL_SubmitGPUCommandBuffer(cmd); + + SDL_ReleaseGPUTransferBuffer(gpu_device, buf_transfer); + + /* Determine which sample count to use */ + render_state.sample_count = SDL_GPU_SAMPLECOUNT_1; + if (msaa && SDL_GPUTextureSupportsSampleCount( + gpu_device, + SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]), + SDL_GPU_SAMPLECOUNT_4)) { + render_state.sample_count = SDL_GPU_SAMPLECOUNT_4; + } + + /* Set up the graphics pipeline */ + + SDL_zero(pipelinedesc); + SDL_zero(color_target_desc); + + color_target_desc.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]); + + pipelinedesc.target_info.num_color_targets = 1; + pipelinedesc.target_info.color_target_descriptions = &color_target_desc; + pipelinedesc.target_info.depth_stencil_format = SDL_GPU_TEXTUREFORMAT_D16_UNORM; + pipelinedesc.target_info.has_depth_stencil_target = true; + + pipelinedesc.depth_stencil_state.enable_depth_test = true; + pipelinedesc.depth_stencil_state.enable_depth_write = true; + pipelinedesc.depth_stencil_state.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL; + + pipelinedesc.multisample_state.sample_count = render_state.sample_count; + + pipelinedesc.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; + + pipelinedesc.vertex_shader = vertex_shader; + pipelinedesc.fragment_shader = fragment_shader; + + vertex_buffer_desc.slot = 0; + vertex_buffer_desc.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX; + vertex_buffer_desc.instance_step_rate = 0; + vertex_buffer_desc.pitch = sizeof(VertexData); + + vertex_attributes[0].buffer_slot = 0; + vertex_attributes[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3; + vertex_attributes[0].location = 0; + vertex_attributes[0].offset = 0; + + vertex_attributes[1].buffer_slot = 0; + vertex_attributes[1].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3; + vertex_attributes[1].location = 1; + vertex_attributes[1].offset = sizeof(float) * 3; + + pipelinedesc.vertex_input_state.num_vertex_buffers = 1; + pipelinedesc.vertex_input_state.vertex_buffer_descriptions = &vertex_buffer_desc; + pipelinedesc.vertex_input_state.num_vertex_attributes = 2; + pipelinedesc.vertex_input_state.vertex_attributes = (SDL_GPUVertexAttribute*) &vertex_attributes; + + pipelinedesc.props = 0; + + render_state.pipeline = SDL_CreateGPUGraphicsPipeline(gpu_device, &pipelinedesc); + CHECK_CREATE(render_state.pipeline, "Render Pipeline") + + /* These are reference-counted; once the pipeline is created, you don't need to keep these. */ + SDL_ReleaseGPUShader(gpu_device, vertex_shader); + SDL_ReleaseGPUShader(gpu_device, fragment_shader); + + /* Set up per-window state */ + + window_states = (WindowState *) SDL_calloc(state->num_windows, sizeof (WindowState)); + if (!window_states) { + SDL_Log("Out of memory!"); + quit(2); + } + + for (i = 0; i < state->num_windows; i++) { + WindowState *winstate = &window_states[i]; + + /* create a depth texture for the window */ + SDL_GetWindowSizeInPixels(state->windows[i], (int*) &drawablew, (int*) &drawableh); + winstate->tex_depth = CreateDepthTexture(drawablew, drawableh); + winstate->tex_msaa = CreateMSAATexture(drawablew, drawableh); + winstate->tex_resolve = CreateResolveTexture(drawablew, drawableh); + + /* make each window different */ + winstate->angle_x = (i * 10) % 360; + winstate->angle_y = (i * 20) % 360; + winstate->angle_z = (i * 30) % 360; + } +} + +static int done = 0; + +void loop(void) +{ + SDL_Event event; + int i; + + /* Check for events */ + while (SDL_PollEvent(&event) && !done) { + SDLTest_CommonEvent(state, &event, &done); + } + if (!done) { + for (i = 0; i < state->num_windows; ++i) { + Render(state->windows[i], i); + } + } +#ifdef __EMSCRIPTEN__ + else { + emscripten_cancel_main_loop(); + } +#endif +} + +int +main(int argc, char *argv[]) +{ + int msaa; + int i; + const SDL_DisplayMode *mode; + Uint64 then, now; + + /* Initialize params */ + msaa = 0; + + /* Initialize test framework */ + state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); + if (!state) { + return 1; + } + for (i = 1; i < argc;) { + int consumed; + + consumed = SDLTest_CommonArg(state, i); + if (consumed == 0) { + if (SDL_strcasecmp(argv[i], "--msaa") == 0) { + ++msaa; + consumed = 1; + } else { + consumed = -1; + } + } + if (consumed < 0) { + static const char *options[] = { "[--msaa]", NULL }; + SDLTest_CommonLogUsage(state, argv[0], options); + quit(1); + } + i += consumed; + } + + state->skip_renderer = 1; + state->window_flags |= SDL_WINDOW_RESIZABLE; + + if (!SDLTest_CommonInit(state)) { + quit(2); + return 0; + } + + mode = SDL_GetCurrentDisplayMode(SDL_GetDisplayForWindow(state->windows[0])); + SDL_Log("Screen bpp: %d", SDL_BITSPERPIXEL(mode->format)); + + init_render_state(msaa); + + /* Main render loop */ + frames = 0; + then = SDL_GetTicks(); + done = 0; + +#ifdef __EMSCRIPTEN__ + emscripten_set_main_loop(loop, 0, 1); +#else + while (!done) { + loop(); + } +#endif + + /* Print out some timing information */ + now = SDL_GetTicks(); + if (now > then) { + SDL_Log("%2.2f frames per second", + ((double) frames * 1000) / (now - then)); + } +#if !defined(__ANDROID__) + quit(0); +#endif + return 0; +} + +/* vi: set ts=4 sw=4 expandtab: */ -- cgit v1.2.3