poki.h

/*
Poki - minimal creative coding framework

Copyright (c) 2025, Arne Koenig
Redistribution and use in source and binary forms, with or without modification, are permitted.
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.
*/

#ifndef POKI_H
#define POKI_H

#include "deps/sokol_gfx.h"
#include "deps/sokol_fetch.h"
#include "deps/hmm.h"
#include "shaders/shaders.glsl.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifndef pk_assert
#include <assert.h>
#define pk_assert(x) assert(x)
#endif
#ifndef pk_printf
#include <stdio.h>
#define pk_printf printf
#endif

#if defined(_WIN32) && !defined(SOKOL_GLES3)
#define PK_REQUEST_DEDICATED_DEVICE \
_declspec(dllexport) unsigned long NvOptimusEnablement = 1; \
_declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
#else
#define PK_REQUEST_DEDICATED_DEVICE
#endif


//--FORWARD--------------

typedef struct m3d_t m3d_t;
typedef struct cgltf_data cgltf_data;
#ifndef PK_NO_SAPP
typedef struct sapp_event sapp_event;
#endif

//--ALLOCATOR--------------------------------------------

//TODO: Hook to dependencies.

typedef void* (*pk_alloc_fn)(size_t size, void* udata);
typedef void  (*pk_free_fn)(void* ptr, void* udata);

typedef struct pk_allocator {
	pk_alloc_fn alloc;
	pk_free_fn free;
	void* udata;
} pk_allocator;

void* pk_alloc(pk_allocator* alloc, size_t size);
void pk_free(pk_allocator* alloc, void* ptr);

//returns an allocator which just uses malloc and free.
pk_allocator pk_default_allocator(void);


//--INIT&SHUTDOWN----------------------------------------

typedef struct pk_desc {
    sg_desc gfx;
    sfetch_desc_t fetch;
} pk_desc;

void pk_setup(const pk_desc* desc);
void pk_shutdown(void);


//--CAMERA------------------------------------------------------------
//modified from https://github.com/floooh/sokol-samples

typedef struct pk_cam_desc {
    float mindist;
    float maxdist;
    float minlat;
    float maxlat;
    float distance;
    float latitude;
    float longitude;
    float aspect;
    float nearz;
    float farz;
    float sensitivity;
    HMM_Vec3 center;
} pk_cam_desc;

typedef struct pk_cam {
    float mindist;
    float maxdist;
    float minlat;
    float maxlat;
    float distance;
    float latitude;
    float longitude;
    float aspect;
    float nearz;
    float farz;
    float sensitivity;
    HMM_Vec3 center;
    HMM_Vec3 eyepos;
    HMM_Mat4 view;
    HMM_Mat4 proj;
    HMM_Mat4 viewproj;
} pk_cam;

void pk_init_cam(pk_cam* cam, const pk_cam_desc* desc);
void pk_orbit_cam(pk_cam* cam, float dx, float dy);
void pk_zoom_cam(pk_cam* cam, float d);
void pk_update_cam(pk_cam* cam, int fb_width, int fb_height);
#ifndef PK_NO_SAPP
void pk_cam_input(pk_cam* cam, const sapp_event* ev);
#endif //PK_NO_SAPP


//--TEXTURES&IMAGES---------------------------------------------------

//Generate mips on gpu. Not supported on GLES backend.
sg_image pk_gen_mipmaps_gpu(sg_image src, int width, int height, int mip_levels);
//Generate mips on cpu. Assumes RGBA8 format for now.
sg_image_desc pk_gen_mipmaps_cpu(pk_allocator* allocator, const sg_image_desc* src, int mip_levels);

typedef struct pk_texture {
    sg_image image;
    sg_sampler sampler;
} pk_texture;

#ifdef __cplusplus
#define PK_TEXTURE(img, smp) pk_texture{ img, smp }
#else
#define PK_TEXTURE(img, smp) (pk_texture){ .image = img, .sampler = smp }
#endif

void pk_checker_texture(pk_texture* tex);
void pk_release_texture(pk_texture* tex);


//--RENDERTARGET-------------------------------------------------------

typedef struct pk_rendertarget_desc {
    int width, height;
    sg_pixel_format color_format;
    uint16_t color_attachment_count;
    sg_pixel_format depth_format;
    sg_pass_action action;
} pk_rendertarget_desc;

typedef struct pk_rendertarget {
    sg_pass pass;
    sg_image color_images[SG_MAX_COLOR_ATTACHMENTS];
    sg_image depth_image;
} pk_rendertarget;

void pk_init_rendertarget(pk_rendertarget* rt, const pk_rendertarget_desc* desc);
void pk_release_rendertarget(pk_rendertarget* rt);
void pk_begin_rendertarget(const pk_rendertarget* rt);
void pk_end_rendertarget(void);


//--NODE-----------------------------------------------------------------

#define PK_MAX_NAME_LEN 32

typedef struct pk_node {
    char name[PK_MAX_NAME_LEN];
    struct pk_node* parent;
    HMM_Vec3 position;
    HMM_Vec3 scale;
    HMM_Quat rotation;
} pk_node;

void pk_init_node(pk_node* node);
HMM_Mat4 pk_node_transform(const pk_node* node);


//--PRIMITIVE--------------------------------------------------------------

typedef struct pk_vertex_pnt {
    HMM_Vec3 pos;
    HMM_Vec3 nrm;
    HMM_Vec2 uv;
} pk_vertex_pnt;

sg_vertex_layout_state pk_pnt_layout(void);

typedef struct pk_vertex_skin {
    uint8_t indices[4];
    float weights[4];
} pk_vertex_skin;

sg_vertex_layout_state pk_skinned_layout(void);

typedef struct {
	sg_range vertices;
	sg_range indices;
	int num_elements;
    bool is_mutable;
} pk_primitive_desc;

typedef struct pk_primitive {
	sg_bindings bindings;
	int base_element;
	int num_elements;
} pk_primitive;

void pk_alloc_primitive(pk_primitive* primitive, uint16_t vubf_count, uint16_t view_count);
void pk_init_primitive(pk_primitive* primitive, const pk_primitive_desc* desc);
bool pk_load_m3d(pk_allocator* allocator, pk_primitive* mesh, pk_node* node, m3d_t* m3d);
void pk_release_primitive(pk_primitive* primitive);
void pk_texture_primitive(pk_primitive* primitive, const pk_texture* tex, int slot);
void pk_draw_primitive(const pk_primitive* primitive, int num_instances);

//--MESH------------------------------------------------------------------

typedef struct pk_mesh {
    pk_primitive* primitives;
    uint16_t primitive_count;
    pk_node* node;
} pk_mesh;

void pk_draw_mesh(pk_mesh* mesh, pk_vs_params_t* vs_params);
void pk_release_mesh(pk_mesh* mesh);


//--MODEL-----------------------------------------------------------------

typedef struct pk_model {
    pk_mesh* meshes;
    pk_node* nodes;
    uint16_t mesh_count;
    uint16_t node_count;
} pk_model;

bool pk_load_gltf(pk_allocator* allocator, pk_model* model, cgltf_data* data);
void pk_release_model(pk_allocator* allocator, pk_model* model);
pk_node* pk_find_model_node(const pk_model*, const char* name);
void pk_set_model_texture(pk_model* model, const pk_texture* tex, int slot);
void pk_draw_model(pk_model* model, pk_vs_params_t* vs_params);


//--ANIMATION-------------------------------------------------------------

//--GLTF---------------------------

typedef enum {
    PK_ANIM_PATH_UNDEFINED,
    PK_ANIM_PATH_TRANSLATION,
    PK_ANIM_PATH_ROTATION,
    PK_ANIM_PATH_SCALE,
} pk_gltf_anim_path_type;

typedef enum {
    PK_ANIM_INTERP_UNDEFINED,
    PK_ANIM_INTERP_LINEAR,
    PK_ANIM_INTERP_STEP,
    PK_ANIM_INTERP_CUBIC, //not used - atm we force cubic to linear
} pk_gltf_anim_interp_type;

typedef struct pk_gltf_keyframe {
    float time;
    float* value;
} pk_gltf_keyframe;

typedef struct pk_gltf_anim_channel {
    pk_node* target_node;
    pk_gltf_keyframe* keyframes;
    int num_keyframes;
    pk_gltf_anim_path_type path;
    pk_gltf_anim_interp_type interpolation;
} pk_gltf_anim_channel;

typedef struct pk_gltf_anim {
    pk_gltf_anim_channel* channels;
    int num_channels;
    float duration;
    float elapsed_time;
    bool loop;
    bool ready;
} pk_gltf_anim;

bool pk_load_gltf_anim(pk_allocator* allocator, pk_gltf_anim* anim, pk_model* model, cgltf_data* data);
void pk_release_gltf_anim(pk_allocator* allocator, pk_gltf_anim* anim);
void pk_play_gltf_anim(pk_gltf_anim* anim, float delta_time);

//--M3D------------------------------

#define PK_MAX_BONES 32

typedef struct pk_bone {
    char name[PK_MAX_NAME_LEN];
    int parent;
} pk_bone;

typedef struct pk_transform {
    HMM_Quat rot;
    HMM_Vec3 pos;
    HMM_Vec3 scale;
} pk_transform;

typedef struct pk_bone_keyframe {
    pk_transform* pose;
    float time;
} pk_bone_keyframe;

typedef struct pk_bone_anim {
    pk_bone_keyframe* keyframes;
    int keyframe_count;
} pk_bone_anim;

typedef struct pk_bone_anim_set {
    HMM_Mat4* inv_bind_matrices;
    pk_bone* bones;
    pk_bone_anim* anims;
    int bone_count;
    int anim_count;
} pk_bone_anim_set;

typedef struct pk_bone_anim_state {
    int anim;
    float time;
    bool loop;
} pk_bone_anim_state;

bool pk_load_bone_anims(pk_allocator* allocator, pk_bone_anim_set* set, m3d_t* m3d);
void pk_sample_bone_anim(pk_transform* pose, pk_bone_anim_set* set, pk_bone_anim_state* state, float dt);
void pk_blend_poses(pk_transform* pose_a, const pk_transform* pose_b, float weight, int bone_count);
void pk_local_to_model_pose(pk_transform* model_pose, const pk_transform* local_pose, pk_bone_anim_set* set);
void pk_apply_pose(HMM_Mat4* trs, const pk_transform* pose, pk_bone_anim_set* set);
void pk_play_bone_anim(HMM_Mat4* trs, pk_bone_anim_set* set, pk_bone_anim_state* state, float dt);
void pk_release_bone_anims(pk_allocator* allocator, pk_bone_anim_set* set);


//--IO---------------------------------------------------------------------------

//Maybe add optional automatic texture loading for models.

typedef void(*pk_fail_callback)(const sfetch_response_t* response, void* udata);

//--IMAGE-LOADING----------

void pk_release_image_desc(pk_allocator* allocator, sg_image_desc* desc);

typedef void(*pk_image_loaded_callback)(sg_image_desc* desc, void* udata);

typedef struct pk_image_request {
    const char* path;
    sfetch_range_t buffer;
    pk_image_loaded_callback loaded_cb;
    pk_fail_callback fail_cb;
    void* udata;
} pk_image_request;

//Supports qoi, png, webp and dds. Will generate a 4x4 checker texture on fail, if no fail callback is provided.
sfetch_handle_t pk_load_image_data(const pk_image_request* req);

//--M3D-LOADING----------------

typedef void(*pk_m3d_loaded_callback)(m3d_t* m3d, void* udata);

typedef struct pk_m3d_request {
    const char* path;
    sfetch_range_t buffer;
    pk_m3d_loaded_callback loaded_cb;
    pk_fail_callback fail_cb;
    void* udata;
} pk_m3d_request;

sfetch_handle_t pk_load_m3d_data(const pk_m3d_request* req);
void pk_release_m3d_data(m3d_t* m3d);


//--GLTF-LOADING---------------

typedef void(*pk_gltf_loaded_callback)(cgltf_data* gltf, void* udata);

typedef struct pk_gltf_request {
    const char* path;
    sfetch_range_t buffer;
    pk_gltf_loaded_callback loaded_cb;
    pk_fail_callback fail_cb;
    void* udata;
} pk_gltf_request;

sfetch_handle_t pk_load_gltf_data(const pk_gltf_request* req);
void pk_release_gltf_data(cgltf_data* data);


#ifdef __cplusplus
} //extern "C"
#endif

#endif // POKI_H