4coder/custom/4coder_delta_rule.cpp

219 lines
7.0 KiB
C++

/*
4coder_delta_rule.cpp - Built in delta rules and delta rule helpers.
*/
// TOP
function u64
delta_ctx_size(u64 base_size){
return(base_size + sizeof(Delta_Context_Header));
}
function Delta_Context_Header*
delta_ctx_get_header(Data delta_ctx){
return((Delta_Context_Header*)delta_ctx.data);
}
function void*
delta_ctx_get_user_data(Data delta_ctx){
Delta_Context_Header *ctx = (Delta_Context_Header*)delta_ctx.data;
return(ctx + 1);
}
function Buffer_Point_Delta_Result
delta_apply(Application_Links *app, View_ID view,
Delta_Rule_Function *func, Data delta_ctx,
f32 dt, Buffer_Point position, Buffer_Point target){
Buffer_Point_Delta_Result result = {};
Vec2_f32 pending = view_point_difference(app, view, target, position);
if (!near_zero(pending, 0.5f)){
Delta_Context_Header *ctx = delta_ctx_get_header(delta_ctx);
b32 is_new_target = false;
if (!block_match_struct(&ctx->point, &target)){
block_copy_struct(&ctx->point, &target);
is_new_target = true;
}
void *rule_data = delta_ctx_get_user_data(delta_ctx);
Vec2_f32 partial = func(pending, is_new_target, dt, rule_data);
// NOTE(allen): clamp partial into the box from the origin
// to the pending delta.
Range_f32 x = If32(pending.x, 0.f);
Range_f32 y = If32(pending.y, 0.f);
partial.x = clamp_range(x, partial.x);
partial.y = clamp_range(y, partial.y);
result.point = view_move_buffer_point(app, view, position, partial);
result.still_animating = true;
}
else{
result.point = target;
}
return(result);
}
function Buffer_Point_Delta_Result
delta_apply(Application_Links *app, View_ID view,
Delta_Rule_Function *func, Data delta_ctx,
f32 dt, Buffer_Scroll scroll){
return(delta_apply(app, view, func, delta_ctx,
dt, scroll.position, scroll.target));
}
function Buffer_Point_Delta_Result
delta_apply(Application_Links *app, View_ID view,
f32 dt, Buffer_Point position, Buffer_Point target){
View_Context ctx = view_current_context(app, view);
Data delta_ctx = view_current_context_hook_memory(app, view, HookID_DeltaRule);
return(delta_apply(app, view, ctx.delta_rule, delta_ctx,
dt, position, target));
}
function Buffer_Point_Delta_Result
delta_apply(Application_Links *app, View_ID view,
f32 dt, Buffer_Scroll scroll){
View_Context ctx = view_current_context(app, view);
Data delta_ctx = view_current_context_hook_memory(app, view, HookID_DeltaRule);
return(delta_apply(app, view, ctx.delta_rule, delta_ctx,
dt, scroll.position, scroll.target));
}
function Vec2_f32_Delta_Result
delta_apply(Application_Links *app, View_ID view,
Delta_Rule_Function *func, Data delta_ctx,
f32 dt, Vec2_f32 position, Vec2_f32 target){
Vec2_f32_Delta_Result result = {};
Vec2_f32 pending = target - position;
if (!near_zero(pending, 0.5f)){
Delta_Context_Header *ctx = delta_ctx_get_header(delta_ctx);
b32 is_new_target = false;
if (!near_zero(ctx->p - target, 0.1f)){
block_copy_struct(&ctx->p, &target);
is_new_target = true;
}
void *rule_data = delta_ctx_get_user_data(delta_ctx);
Vec2_f32 partial = func(pending, is_new_target, dt, rule_data);
// NOTE(allen): clamp partial into the box from the origin
// to the pending delta.
Range_f32 x = If32(pending.x, 0.f);
Range_f32 y = If32(pending.y, 0.f);
partial.x = clamp_range(x, partial.x);
partial.y = clamp_range(y, partial.y);
result.p = position + partial;
result.still_animating = true;
}
else{
result.p = target;
}
return(result);
}
function Vec2_f32_Delta_Result
delta_apply(Application_Links *app, View_ID view,
Delta_Rule_Function *func, Data delta_ctx,
f32 dt, Basic_Scroll scroll){
return(delta_apply(app, view, func, delta_ctx,
dt, scroll.position, scroll.target));
}
function Vec2_f32_Delta_Result
delta_apply(Application_Links *app, View_ID view,
f32 dt, Vec2_f32 position, Vec2_f32 target){
View_Context ctx = view_current_context(app, view);
Data delta_ctx = view_current_context_hook_memory(app, view, HookID_DeltaRule);
return(delta_apply(app, view, ctx.delta_rule, delta_ctx,
dt, position, target));
}
function Vec2_f32_Delta_Result
delta_apply(Application_Links *app, View_ID view,
f32 dt, Basic_Scroll scroll){
View_Context ctx = view_current_context(app, view);
Data delta_ctx = view_current_context_hook_memory(app, view, HookID_DeltaRule);
return(delta_apply(app, view, ctx.delta_rule, delta_ctx,
dt, scroll.position, scroll.target));
}
////////////////////////////////
internal Smooth_Step
smooth_camera_step(f32 target, f32 v, f32 S, f32 T){
Smooth_Step step = {};
step.v = v;
if (step.p != target){
if (step.p > target - .1f && step.p < target + .1f){
step.p = target;
step.v = 1.f;
}
else{
f32 L = step.p + T*(target - step.p);
i32 sign = (target > step.p) - (target < step.p);
f32 V = step.p + sign*step.v;
if (sign > 0){
step.p = (L<V)?(L):(V);
}
else{
step.p = (L>V)?(L):(V);
}
if (step.p == V){
step.v *= S;
}
}
}
return(step);
}
DELTA_RULE_SIG(original_delta){
Vec2_f32 *velocity = (Vec2_f32*)data;
if (velocity->x == 0.f){
velocity->x = 1.f;
velocity->y = 1.f;
}
Smooth_Step step_x = smooth_camera_step(pending.x, velocity->x, 80.f, 1.f/2.f);
Smooth_Step step_y = smooth_camera_step(pending.y, velocity->y, 80.f, 1.f/2.f);
*velocity = V2f32(step_x.v, step_y.v);
return(V2f32(step_x.p, step_y.p));
}
global_const u64 original_delta_memory_size = sizeof(Vec2_f32);
DELTA_RULE_SIG(snap_delta){
return(pending);
}
global_const u64 snap_delta_memory_size = 0;
function f32
cubic_reinterpolate(f32 t){
f32 t2 = t*t;
f32 t3 = t2*t;
return(3*t2 - 2*t3);
}
DELTA_RULE_SIG(fixed_time_cubic_delta){
local_const f32 duration_in_seconds = (1.f/8.f);
local_const f32 dt_multiplier = 1.f/duration_in_seconds;
f32 step = dt*dt_multiplier;
f32 *t = (f32*)data;
*t = clamp(0.f, *t, 1.f);
f32 prev_t = *t;
if (is_new_target){
prev_t = 0.f;
*t = step;
}
else{
*t += step;
}
*t = clamp(0.f, *t, 1.f);
Vec2_f32 result = pending;
if (*t < 1.f){
f32 prev_x = cubic_reinterpolate(prev_t);
f32 x = cubic_reinterpolate(*t);
f32 portion = ((x - prev_x)/(1.f - prev_x));
result *= portion;
}
return(result);
}
global_const u64 fixed_time_cubic_delta_memory_size = sizeof(f32);
// BOTTOM