jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

readd mesh shader

Browse Source
This commit is contained in:
jacob 2025-05-27 04:25:59 -05:00
parent ee96df51e3
commit dc46fb270d
6 changed files with 130 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
res/shaders/triangle.hlsl → res/shaders/mesh.hlsl
View File

@ -2,24 +2,18 @@
struct vs_input { struct vs_input {
DECL(float4, pos); DECL(float4, pos);
DECL(float2, uv); DECL(float4, color_srgb);
DECL(float4, tint_srgb);
}; };
struct ps_input { struct ps_input {
DESV(float4, screen_pos, SV_POSITION); DESV(float4, screen_pos, SV_POSITION);
DECL(float2, uv); DECL(float4, color_lin);
DECL(float4, tint_lin);
}; };
/* ========================== * /* ========================== *
* Globals * Globals
* ========================== */ * ========================== */
SamplerState G_sampler : register(s0);
Texture2D G_texture : register(t0);
cbuffer constants : register(b0) cbuffer constants : register(b0)
{ {
float4x4 G_projection; float4x4 G_projection;
@ -33,8 +27,7 @@ ps_input vs_main(vs_input input)
{ {
ps_input output; ps_input output;
output.screen_pos = mul(G_projection, float4(input.pos.xy, 0.f, 1.f)); output.screen_pos = mul(G_projection, float4(input.pos.xy, 0.f, 1.f));
output.uv = input.uv; output.color_lin = linear_from_srgb(input.color_srgb);
output.tint_lin = linear_from_srgb(input.tint_srgb);
return output; return output;
} }
@ -45,6 +38,5 @@ ps_input vs_main(vs_input input)
float4 ps_main(ps_input input) : SV_TARGET float4 ps_main(ps_input input) : SV_TARGET
{ {
float4 color = G_texture.Sample(G_sampler, input.uv) * input.tint_lin; return input.color_lin;
return color;
} }

8
src/draw.c
View File

@ -47,10 +47,10 @@ void draw_texture(struct gpu_cmd_store store, struct draw_texture_params params)
void draw_poly_ex(struct gpu_cmd_store store, struct v2_array vertices, struct gpu_indices indices, u32 color) void draw_poly_ex(struct gpu_cmd_store store, struct v2_array vertices, struct gpu_indices indices, u32 color)
{ {
struct gpu_cmd_params cmd = ZI; struct gpu_cmd_params cmd = ZI;
cmd.kind = GPU_CMD_KIND_DRAW_TRIANGLES; cmd.kind = GPU_CMD_KIND_DRAW_MESH;
cmd.triangles.vertices = vertices; cmd.mesh.vertices = vertices;
cmd.triangles.indices = indices; cmd.mesh.indices = indices;
cmd.triangles.color = color; cmd.mesh.color = color;
gpu_push_cmd(store, cmd); gpu_push_cmd(store, cmd);
} }

4
src/gpu.h
View File

@ -63,7 +63,7 @@ struct gpu_indices {
enum gpu_cmd_kind { enum gpu_cmd_kind {
GPU_CMD_KIND_NONE, GPU_CMD_KIND_NONE,
GPU_CMD_KIND_DRAW_TRIANGLES, GPU_CMD_KIND_DRAW_MESH,
GPU_CMD_KIND_DRAW_TEXTURE, GPU_CMD_KIND_DRAW_TEXTURE,
GPU_CMD_KIND_DRAW_GRID, GPU_CMD_KIND_DRAW_GRID,
@ -77,7 +77,7 @@ struct gpu_cmd_params {
struct v2_array vertices; struct v2_array vertices;
struct gpu_indices indices; struct gpu_indices indices;
u32 color; u32 color;
} triangles; } mesh;
struct { struct {
struct xform xf; struct xform xf;
struct sprite_tag sprite; struct sprite_tag sprite;

179
src/gpu_dx11.c
View File

@ -30,7 +30,7 @@
/* FIXME: Enable this and resolve unreleased references */ /* FIXME: Enable this and resolve unreleased references */
#if RTC #if RTC
# define DX11_DEBUG 1 # define DX11_DEBUG 0
# define DX11_SHADER_DEBUG 1 # define DX11_SHADER_DEBUG 1
#else #else
# define DX11_DEBUG 0 # define DX11_DEBUG 0
@ -44,7 +44,7 @@
enum dx11_shader_kind { enum dx11_shader_kind {
DX11_SHADER_KIND_NONE, DX11_SHADER_KIND_NONE,
DX11_SHADER_KIND_TRIANGLE, DX11_SHADER_KIND_MESH,
DX11_SHADER_KIND_TEXTURE, DX11_SHADER_KIND_TEXTURE,
DX11_SHADER_KIND_GRID, DX11_SHADER_KIND_GRID,
@ -80,7 +80,7 @@ struct dx11_cmd_buffers {
struct { struct {
struct dx11_buffer *vertex_buffer; struct dx11_buffer *vertex_buffer;
struct dx11_buffer *index_buffer; struct dx11_buffer *index_buffer;
} triangles; } mesh;
struct { struct {
struct dx11_buffer *instance_buffer; struct dx11_buffer *instance_buffer;
} texture; } texture;
@ -98,7 +98,7 @@ struct dx11_cmd {
u32 vertex_count; u32 vertex_count;
u32 index_offset; u32 index_offset;
u32 index_count; u32 index_count;
} triangles; } mesh;
struct { struct {
struct gpu_texture texture; /* Overrides sprite if set */ struct gpu_texture texture; /* Overrides sprite if set */
struct sprite_tag sprite; struct sprite_tag sprite;
@ -128,7 +128,7 @@ struct dx11_cmd_store {
struct { struct {
struct dx11_buffer *vertex_buffer; struct dx11_buffer *vertex_buffer;
struct dx11_buffer *index_buffer; struct dx11_buffer *index_buffer;
} triangles; } mesh;
struct { struct {
struct dx11_buffer *instance_buffer; struct dx11_buffer *instance_buffer;
} texture; } texture;
@ -495,16 +495,15 @@ struct gpu_startup_receipt gpu_startup(struct sys_window *window)
* Shader table * Shader table
* ========================== */ * ========================== */
/* Triangle structs */ /* Mesh structs */
PACK(struct dx11_triangle_uniform { PACK(struct dx11_mesh_uniform {
struct mat4x4 vp; struct mat4x4 vp;
}); });
PACK(struct dx11_triangle_vertex { PACK(struct dx11_mesh_vertex {
struct v2 pos; struct v2 pos;
struct v2 uv; u32 color_srgb;
u32 tint_srgb;
}); });
/* Texture structs */ /* Texture structs */
@ -544,14 +543,13 @@ INTERNAL void init_shader_table(void)
{ {
MEMZERO_ARRAY(G.shader_info); MEMZERO_ARRAY(G.shader_info);
/* Triangle shader layout */ /* Mesh shader layout */
G.shader_info[DX11_SHADER_KIND_TRIANGLE] = (struct dx11_shader_desc) { G.shader_info[DX11_SHADER_KIND_MESH] = (struct dx11_shader_desc) {
.kind = DX11_SHADER_KIND_TRIANGLE, .kind = DX11_SHADER_KIND_MESH,
.name_cstr = "shaders/triangle.hlsl", .name_cstr = "shaders/mesh.hlsl",
.input_layout_desc = { .input_layout_desc = {
{ "pos", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "pos", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "uv", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "color_srgb", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
{ "tint_srgb", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
} }
}; };
@ -1070,12 +1068,21 @@ struct gpu_cmd_store gpu_cmd_store_alloc(void)
store->buffers.constant_buffer = dx11_buffer_alloc(constant_buffer_desc, NULL); store->buffers.constant_buffer = dx11_buffer_alloc(constant_buffer_desc, NULL);
} }
/* Triangle buffers */ /* Mesh buffers */
{ {
#if 0 D3D11_BUFFER_DESC vdesc = ZI;
store->buffers.triangles.vertex_buffer = dx11_buffer_alloc(D3D11_BIND_VERTEX_BUFFER); vdesc.Usage = D3D11_USAGE_DYNAMIC;
store->buffers.triangles.index_buffer = dx11_buffer_alloc(D3D11_BIND_INDEX_BUFFER); vdesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
#endif vdesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
/* Quad index buffer */
D3D11_BUFFER_DESC idesc = ZI;
idesc.Usage = D3D11_USAGE_DYNAMIC;
idesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
idesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
store->buffers.mesh.vertex_buffer = dx11_buffer_alloc(vdesc, NULL);
store->buffers.mesh.index_buffer = dx11_buffer_alloc(idesc, NULL);
} }
/* Texture buffers */ /* Texture buffers */
@ -1115,9 +1122,47 @@ void gpu_push_cmd(struct gpu_cmd_store gpu_cmd_store, struct gpu_cmd_params para
ASSERT(false); ASSERT(false);
} break; } break;
case GPU_CMD_KIND_DRAW_TRIANGLES: case GPU_CMD_KIND_DRAW_MESH:
{ {
/* TODO */ struct dx11_cmd *cmd = store->cpu_last_cmd;
if (cmd && cmd->kind != params.kind) {
/* Cannot batch */
cmd = NULL;
}
/* Start new cmd */
if (!cmd) {
/* TODO: Better count method */
cmd = arena_push(&store->cpu_cmds_arena, struct dx11_cmd);
cmd->kind = params.kind;
cmd->mesh.vertex_offset = (store->buffers.mesh.vertex_buffer->cpu_buffer_arena.pos / sizeof(struct dx11_mesh_vertex));
cmd->mesh.index_offset = (store->buffers.mesh.index_buffer->cpu_buffer_arena.pos / sizeof(u16));
if (store->cpu_last_cmd) {
store->cpu_last_cmd->next = cmd;
} else {
store->cpu_first_cmd = cmd;
}
store->cpu_last_cmd = cmd;
}
/* Push vertices */
u64 vertex_count = params.mesh.vertices.count;
u64 start_index = cmd->mesh.vertex_count;
cmd->mesh.vertex_count += vertex_count;
struct dx11_mesh_vertex *verts = dx11_buffer_push(store->buffers.mesh.vertex_buffer, sizeof(struct dx11_mesh_vertex) * vertex_count);
for (u64 i = 0; i < vertex_count; ++i) {
struct dx11_mesh_vertex *vert = &verts[i];
vert->pos = params.mesh.vertices.points[i];
vert->color_srgb = params.mesh.color;
}
/* Push indices */
u64 index_count = params.mesh.indices.count;
u16 *indices = dx11_buffer_push(store->buffers.mesh.index_buffer, sizeof(u16) * index_count);
cmd->mesh.index_count += index_count;
for (u64 i = 0; i < index_count; ++i) {
indices[i] = start_index + params.mesh.indices.indices[i];
}
} break; } break;
case GPU_CMD_KIND_DRAW_TEXTURE: case GPU_CMD_KIND_DRAW_TEXTURE:
@ -1211,9 +1256,9 @@ void gpu_submit_cmds(struct gpu_cmd_store gpu_cmd_store)
store->cpu_last_cmd = NULL; store->cpu_last_cmd = NULL;
arena_reset(&store->cpu_cmds_arena); arena_reset(&store->cpu_cmds_arena);
/* Submit triangle buffers */ /* Submit mesh buffers */
//dx11_buffer_submit(store->buffers.triangles.vertex_buffer); dx11_buffer_submit(store->buffers.mesh.vertex_buffer);
//dx11_buffer_submit(store->buffers.triangles.index_buffer); dx11_buffer_submit(store->buffers.mesh.index_buffer);
/* Submit texture buffers */ /* Submit texture buffers */
dx11_buffer_submit(store->buffers.texture.instance_buffer); dx11_buffer_submit(store->buffers.texture.instance_buffer);
@ -1261,60 +1306,56 @@ void gpu_run_cmds(struct gpu_cmd_store gpu_cmd_store, struct gpu_texture target,
ASSERT(false); ASSERT(false);
} break; } break;
case GPU_CMD_KIND_DRAW_TRIANGLES: case GPU_CMD_KIND_DRAW_MESH:
{ {
/* TODO */ __profscope(Draw mesh);
#if 0 __profscope_dx11(G.profiling_ctx, Draw mesh, RGB_F(0.5, 0.2, 0.2));
__profscope_dx11(G.profiling_ctx, Triangles, RGB_F(0.2, 0.2, 0.5)); struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_MESH];
if (shader->valid) {
struct dx11_buffer *constant_buffer = store->buffers.constant_buffer;
struct dx11_buffer *vertex_buffer = store->buffers.mesh.vertex_buffer;
struct dx11_buffer *index_buffer = store->buffers.mesh.index_buffer;
/* FIXME: Texture refcount needs to be increased here to prevent release mid-render */ u32 vertex_offset = cmd->mesh.vertex_offset;
ID3D11Texture2D *texture = NULL; u32 index_offset = cmd->mesh.index_offset;
if (cmd->texture.handle) { u32 index_count = cmd->mesh.index_count;
/* Load texture if handle is set */
texture = ((struct dx11_texture *)cmd->texture.handle)->texture; /* Bind shader */
} else { ID3D11DeviceContext_VSSetShader(G.devcon, shader->vs, 0, 0);
/* Otherwise load sprite */ ID3D11DeviceContext_PSSetShader(G.devcon, shader->ps, 0, 0);
struct sprite_texture *sprite_texture = sprite_texture_from_tag_async(sprite_scope, cmd->sprite);
if (sprite_texture->loaded) { /* Bind input layout */
texture = ((struct dx11_texture *)sprite_texture->texture.handle)->texture; ID3D11DeviceContext_IASetInputLayout(G.devcon, shader->input_layout);
}
/* Fill & bind constant buffer */
{
struct dx11_mesh_uniform *uniform = dx11_buffer_push(constant_buffer, sizeof(struct dx11_mesh_uniform));
uniform->vp = vp_matrix;
dx11_buffer_submit(constant_buffer);
} }
ID3D11DeviceContext_VSSetConstantBuffers(G.devcon, 0, 1, &constant_buffer->gpu_buffer);
ID3D11DeviceContext_PSSetConstantBuffers(G.devcon, 0, 1, &constant_buffer->gpu_buffer);
if (texture) { /* Bind vertex buffer */
/* Create SRV */
D3D11_TEXTURE2D_DESC texture_desc = ZI;
ID3D11Texture2D_GetDesc(texture, &texture_desc);
D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc = { .Format = texture_desc.Format, .ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D, .Texture2D.MipLevels = texture_desc.MipLevels, .Texture2D.MostDetailedMip = 0 };
ID3D11ShaderResourceView *texture_srv = NULL;
ID3D11Device_CreateShaderResourceView(G.dev, (ID3D11Resource *)texture, &srv_desc, &texture_srv);
/* Bind texture */
ID3D11DeviceContext_PSSetShaderResources(G.devcon, 0, 1, &texture_srv);
/* Activate buffer */
u32 zero = 0; u32 zero = 0;
UINT vertex_stride = shader->vertex_size; u32 stride = sizeof(struct dx11_mesh_vertex);
ID3D11DeviceContext_IASetVertexBuffers(G.devcon, 0, 1, &buffer->gpu_vertex_buffer, &vertex_stride, &zero); ID3D11DeviceContext_IASetVertexBuffers(G.devcon, 0, 1, &vertex_buffer->gpu_buffer, &stride, &zero);
ID3D11DeviceContext_IASetIndexBuffer(G.devcon, buffer->gpu_index_buffer, DXGI_FORMAT_R32_UINT, zero); ID3D11DeviceContext_IASetIndexBuffer(G.devcon, index_buffer->gpu_buffer, DXGI_FORMAT_R16_UINT, zero);
/* Draw */ /* Draw */
u32 vertex_offset = cmd->vertex_offset;
u32 index_offset = cmd->index_offset;
u32 index_count = cmd->index_count;
ID3D11DeviceContext_IASetPrimitiveTopology(G.devcon, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); ID3D11DeviceContext_IASetPrimitiveTopology(G.devcon, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ID3D11DeviceContext_DrawIndexed(G.devcon, index_count, index_offset, vertex_offset); ID3D11DeviceContext_DrawIndexed(G.devcon, index_count, index_offset, vertex_offset);
/* Release SRV */ /* Unbind SRVs */
ID3D11ShaderResourceView_Release(texture_srv); ID3D11DeviceContext_VSSetShaderResources(G.devcon, 0, 8, null_srvs);
ID3D11DeviceContext_PSSetShaderResources(G.devcon, 0, 8, null_srvs);
/* Unbind */ }
ID3D11DeviceContext_PSSetShaderResources(G.devcon, 0, 1, null_srv);
#endif
} break; } break;
case GPU_CMD_KIND_DRAW_TEXTURE: case GPU_CMD_KIND_DRAW_TEXTURE:
{ {
__profscope_dx11(G.profiling_ctx, Texture, RGB_F(0.2, 0.2, 0.5)); __profscope(Draw texture);
__profscope_dx11(G.profiling_ctx, Draw texture, RGB_F(0.2, 0.5, 0.2));
struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_TEXTURE]; struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_TEXTURE];
if (shader->valid) { if (shader->valid) {
struct dx11_texture *texture = NULL; struct dx11_texture *texture = NULL;
@ -1327,9 +1368,6 @@ void gpu_run_cmds(struct gpu_cmd_store gpu_cmd_store, struct gpu_texture target,
if (sprite_texture->loaded) { if (sprite_texture->loaded) {
texture = (struct dx11_texture *)sprite_texture->texture.handle; texture = (struct dx11_texture *)sprite_texture->texture.handle;
} }
if (cmd->texture.sprite.hash == 13036381201575792585ULL) {
DEBUGBREAKABLE;
}
} }
if (texture && texture->srv && shader->valid) { if (texture && texture->srv && shader->valid) {
@ -1378,7 +1416,8 @@ void gpu_run_cmds(struct gpu_cmd_store gpu_cmd_store, struct gpu_texture target,
case GPU_CMD_KIND_DRAW_GRID: case GPU_CMD_KIND_DRAW_GRID:
{ {
__profscope_dx11(G.profiling_ctx, Grid, RGB_F(0.2, 0.5, 0.2)); __profscope(Draw grid);
__profscope_dx11(G.profiling_ctx, Draw grid, RGB_F(0.2, 0.2, 0.5));
struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_GRID]; struct dx11_shader *shader = &G.shaders[DX11_SHADER_KIND_GRID];
if (shader->valid) { if (shader->valid) {
struct dx11_buffer *constant_buffer = store->buffers.constant_buffer; struct dx11_buffer *constant_buffer = store->buffers.constant_buffer;

2
src/host.c
View File

@ -209,7 +209,7 @@ void host_release(struct host *host)
{ {
atomic_i32_eval_exchange(&host->receiver_thread_shutdown_flag, 1); atomic_i32_eval_exchange(&host->receiver_thread_shutdown_flag, 1);
sock_wake(host->sock); sock_wake(host->sock);
while (!sys_thread_try_release(&host->receiver_thread, 0.001)) { while (!sys_thread_try_release(&host->receiver_thread, 0.001f)) {
sock_wake(host->sock); sock_wake(host->sock);
} }
sys_mutex_release(&host->rcv_buffer_write_mutex); sys_mutex_release(&host->rcv_buffer_write_mutex);

20
src/sim_step.c
View File

@ -109,7 +109,7 @@ INTERNAL struct sim_ent *test_spawn_chucker(struct sim_ent *parent)
struct collider_shape collider = ZI; struct collider_shape collider = ZI;
collider.count = 2; collider.count = 2;
collider.points[1] = V2(0, -0.5); collider.points[1] = V2(0, -0.5);
collider.radius = 0.1; collider.radius = 0.1f;
zone->local_collider = collider; zone->local_collider = collider;
chucker->chucker_zone = zone->id; chucker->chucker_zone = zone->id;
@ -517,7 +517,7 @@ INTERNAL void test_generate_walls(struct sim_snapshot *world)
if (wall_end == SIM_TILES_PER_CHUNK_SQRT) { if (wall_end == SIM_TILES_PER_CHUNK_SQRT) {
u64 end_hash = rand_u64_from_seed(*(u64 *)&end); u64 end_hash = rand_u64_from_seed(*(u64 *)&end);
end_hash = rand_u64_from_seeds(end_hash, wall_dir); end_hash = rand_u64_from_seeds(end_hash, wall_dir);
dict_set(scratch.arena, &horizontal_ends_dict, end_hash, node); dict_set(scratch.arena, &horizontal_ends_dict, end_hash, (u64)node);
} }
wall_start = -1; wall_start = -1;
wall_end = -1; wall_end = -1;
@ -607,7 +607,7 @@ INTERNAL void test_generate_walls(struct sim_snapshot *world)
if (wall_end == SIM_TILES_PER_CHUNK_SQRT) { if (wall_end == SIM_TILES_PER_CHUNK_SQRT) {
u64 end_hash = rand_u64_from_seed(*(u64 *)&end); u64 end_hash = rand_u64_from_seed(*(u64 *)&end);
end_hash = rand_u64_from_seeds(end_hash, wall_dir); end_hash = rand_u64_from_seeds(end_hash, wall_dir);
dict_set(scratch.arena, &vertical_ends_dict, end_hash, node); dict_set(scratch.arena, &vertical_ends_dict, end_hash, (u64)node);
} }
wall_start = -1; wall_start = -1;
wall_end = -1; wall_end = -1;
@ -643,7 +643,7 @@ INTERNAL void test_generate_walls(struct sim_snapshot *world)
wall_ent->local_collider.count = 2; wall_ent->local_collider.count = 2;
wall_ent->local_collider.points[1] = v2_sub(end, start); wall_ent->local_collider.points[1] = v2_sub(end, start);
LOCAL_PERSIST struct v2 dirs[4] = { V2(0, -1), V2(1, 0), V2(0, 1), V2(-1, 0) }; struct v2 dirs[4] = { V2(0, -1), V2(1, 0), V2(0, 1), V2(-1, 0) };
ASSERT(node->wall_dir >= 0 && (u32)node->wall_dir < ARRAY_COUNT(dirs)); ASSERT(node->wall_dir >= 0 && (u32)node->wall_dir < ARRAY_COUNT(dirs));
wall_ent->collision_dir = dirs[node->wall_dir]; wall_ent->collision_dir = dirs[node->wall_dir];
@ -729,7 +729,7 @@ INTERNAL PHYS_COLLISION_CALLBACK_FUNC_DEF(on_collision, data, step_ctx)
linear_velocity = v2_add(linear_velocity, v2_mul(v2_perp(normal), rand_f64_from_state(&step_ctx->rand, -perp_range, perp_range))); linear_velocity = v2_add(linear_velocity, v2_mul(v2_perp(normal), rand_f64_from_state(&step_ctx->rand, -perp_range, perp_range)));
f32 angular_velocity_range = 5; f32 angular_velocity_range = 5;
f32 angular_velocity = rand_f64_from_seed(&step_ctx->rand, -angular_velocity_range, angular_velocity_range); f32 angular_velocity = rand_f64_from_state(&step_ctx->rand, -angular_velocity_range, angular_velocity_range);
sim_ent_enable_prop(decal, SEPROP_KINEMATIC); sim_ent_enable_prop(decal, SEPROP_KINEMATIC);
sim_ent_set_linear_velocity(decal, linear_velocity); sim_ent_set_linear_velocity(decal, linear_velocity);
@ -1383,7 +1383,7 @@ void sim_step(struct sim_step_ctx *ctx)
/* Point collider */ /* Point collider */
bullet->local_collider.points[0] = V2(0, 0); bullet->local_collider.points[0] = V2(0, 0);
bullet->local_collider.count = 1; bullet->local_collider.count = 1;
bullet->local_collider.radius = 0.05; bullet->local_collider.radius = 0.05f;
} }
@ -1422,9 +1422,9 @@ void sim_step(struct sim_step_ctx *ctx)
def.e1 = target->id; def.e1 = target->id;
def.xf = xf0_to_xf1; def.xf = xf0_to_xf1;
def.linear_spring_hz = 10; def.linear_spring_hz = 10;
def.linear_spring_damp = 0.3; def.linear_spring_damp = 0.3f;
def.angular_spring_hz = 10; def.angular_spring_hz = 10;
def.angular_spring_damp = 0.3; def.angular_spring_damp = 0.3f;
joint_ent->weld_joint_data = phys_weld_joint_from_def(def); joint_ent->weld_joint_data = phys_weld_joint_from_def(def);
ent->chucker_joint = joint_ent->id; ent->chucker_joint = joint_ent->id;
} }
@ -1647,9 +1647,9 @@ void sim_step(struct sim_step_ctx *ctx)
def.point_end = cursor; def.point_end = cursor;
def.max_force = F32_INFINITY; def.max_force = F32_INFINITY;
def.linear_spring_hz = 5; def.linear_spring_hz = 5;
def.linear_spring_damp = 0.7; def.linear_spring_damp = 0.7f;
def.angular_spring_hz = 1; def.angular_spring_hz = 1;
def.angular_spring_damp = 0.1; def.angular_spring_damp = 0.1f;
joint_ent->mouse_joint_data = phys_mouse_joint_from_def(def); joint_ent->mouse_joint_data = phys_mouse_joint_from_def(def);
} else if (sim_ent_is_valid_and_active(joint_ent)) { } else if (sim_ent_is_valid_and_active(joint_ent)) {
joint_ent->mouse_joint_data.target = target_ent->id; joint_ent->mouse_joint_data.target = target_ent->id;