// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)

////////////////////////////////
//~ rjf: Generated Code

#define D_StackPushImpl(name_upper, name_lower, type, val) \
D_Bucket *bucket = d_top_bucket();\
type old_val = bucket->top_##name_lower->v;\
D_##name_upper##Node *node = push_array(d_thread_ctx->arena, D_##name_upper##Node, 1);\
node->v = (val);\
SLLStackPush(bucket->top_##name_lower, node);\
bucket->stack_gen += 1;\
return old_val

#define D_StackPopImpl(name_upper, name_lower, type) \
D_Bucket *bucket = d_top_bucket();\
type popped_val = bucket->top_##name_lower->v;\
SLLStackPop(bucket->top_##name_lower);\
bucket->stack_gen += 1;\
return popped_val

#define D_StackTopImpl(name_upper, name_lower, type) \
D_Bucket *bucket = d_top_bucket();\
type top_val = bucket->top_##name_lower->v;\
return top_val

#include "generated/draw.meta.c"

////////////////////////////////
//~ rjf: Basic Helpers

internal U64
d_hash_from_string(String8 string)
{
  U64 result = 5381;
  for(U64 i = 0; i < string.size; i += 1)
  {
    result = ((result << 5) + result) + string.str[i];
  }
  return result;
}

////////////////////////////////
//~ rjf: Fancy String Type Functions

internal void
d_fancy_string_list_push(Arena *arena, D_FancyStringList *list, D_FancyString *str)
{
  D_FancyStringNode *n = push_array_no_zero(arena, D_FancyStringNode, 1);
  MemoryCopyStruct(&n->v, str);
  SLLQueuePush(list->first, list->last, n);
  list->node_count += 1;
  list->total_size += str->string.size;
}

internal String8
d_string_from_fancy_string_list(Arena *arena, D_FancyStringList *list)
{
  String8 result = {0};
  result.size = list->total_size;
  result.str = push_array_no_zero(arena, U8, result.size);
  U64 idx = 0;
  for(D_FancyStringNode *n = list->first; n != 0; n = n->next)
  {
    MemoryCopy(result.str+idx, n->v.string.str, n->v.string.size);
    idx += n->v.string.size;
  }
  return result;
}

internal D_FancyRunList
d_fancy_run_list_from_fancy_string_list(Arena *arena, D_FancyStringList *strs)
{
  ProfBeginFunction();
  D_FancyRunList run_list = {0};
  for(D_FancyStringNode *n = strs->first; n != 0; n = n->next)
  {
    D_FancyRunNode *dst_n = push_array(arena, D_FancyRunNode, 1);
    dst_n->v.run = f_push_run_from_string(arena, n->v.font, n->v.size, 0, n->v.string);
    dst_n->v.color = n->v.color;
    dst_n->v.underline_thickness = n->v.underline_thickness;
    dst_n->v.strikethrough_thickness = n->v.strikethrough_thickness;
    SLLQueuePush(run_list.first, run_list.last, dst_n);
    run_list.node_count += 1;
    run_list.dim.x += dst_n->v.run.dim.x;
    run_list.dim.y = Max(run_list.dim.y, dst_n->v.run.dim.y);
  }
  ProfEnd();
  return run_list;
}

////////////////////////////////
//~ rjf: Top-Level API
//
// (Frame boundaries)

internal void
d_begin_frame(void)
{
  if(d_thread_ctx == 0)
  {
    Arena *arena = arena_alloc__sized(GB(64), MB(8));
    d_thread_ctx = push_array(arena, D_ThreadCtx, 1);
    d_thread_ctx->arena = arena;
    d_thread_ctx->arena_frame_start_pos = arena_pos(arena);
  }
  arena_pop_to(d_thread_ctx->arena, d_thread_ctx->arena_frame_start_pos);
  d_thread_ctx->free_bucket_selection = 0;
  d_thread_ctx->top_bucket = 0;
}

internal void
d_submit_bucket(OS_Handle os_window, R_Handle r_window, D_Bucket *bucket)
{
  r_window_submit(os_window, r_window, &bucket->passes);
}

////////////////////////////////
//~ rjf: Bucket Construction & Selection API
//
// (Bucket: Handle to sequence of many render passes, constructed by this layer)

internal D_Bucket *
d_bucket_make(void)
{
  D_Bucket *bucket = push_array(d_thread_ctx->arena, D_Bucket, 1);
  D_BucketStackInits(bucket);
  return bucket;
}

internal void
d_push_bucket(D_Bucket *bucket)
{
  D_BucketSelectionNode *node = d_thread_ctx->free_bucket_selection;
  if(node)
  {
    SLLStackPop(d_thread_ctx->free_bucket_selection);
  }
  else
  {
    node = push_array(d_thread_ctx->arena, D_BucketSelectionNode, 1);
  }
  SLLStackPush(d_thread_ctx->top_bucket, node);
  node->bucket = bucket;
}

internal void
d_pop_bucket(void)
{
  D_BucketSelectionNode *node = d_thread_ctx->top_bucket;
  SLLStackPop(d_thread_ctx->top_bucket);
  SLLStackPush(d_thread_ctx->free_bucket_selection, node);
}

internal D_Bucket *
d_top_bucket(void)
{
  D_Bucket *bucket = 0;
  if(d_thread_ctx->top_bucket != 0)
  {
    bucket = d_thread_ctx->top_bucket->bucket;
  }
  return bucket;
}

////////////////////////////////
//~ rjf: Bucket Stacks
//
// (Pushing/popping implicit draw parameters)

// NOTE(rjf): (The implementation of the push/pop/top functions is auto-generated)

////////////////////////////////
//~ rjf: Draw Calls
//
// (Apply to the calling thread's currently selected bucket)

//- rjf: rectangles

internal inline R_Rect2DInst *
d_rect(Rng2F32 dst, Vec4F32 color, F32 corner_radius, F32 border_thickness, F32 edge_softness)
{
  Arena *arena = d_thread_ctx->arena;
  D_Bucket *bucket = d_top_bucket();
  R_Pass *pass = r_pass_from_kind(arena, &bucket->passes, R_PassKind_UI);
  R_PassParams_UI *params = pass->params_ui;
  R_BatchGroup2DList *rects = &params->rects;
  R_BatchGroup2DNode *node = rects->last;
  if(node == 0 || bucket->stack_gen != bucket->last_cmd_stack_gen)
  {
    node = push_array(arena, R_BatchGroup2DNode, 1);
    SLLQueuePush(rects->first, rects->last, node);
    rects->count += 1;
    node->batches = r_batch_list_make(sizeof(R_Rect2DInst));
    node->params.tex = r_handle_zero();
    node->params.tex_sample_kind = bucket->top_tex2d_sample_kind->v;
    node->params.xform           = bucket->top_xform2d->v;
    node->params.clip            = bucket->top_clip->v;
    node->params.transparency    = bucket->top_transparency->v;
  }
  R_Rect2DInst *inst = (R_Rect2DInst *)r_batch_list_push_inst(arena, &node->batches, 256);
  inst->dst = dst;
  inst->src = r2f32p(0, 0, 0, 0);
  inst->colors[Corner_00] = color;
  inst->colors[Corner_01] = color;
  inst->colors[Corner_10] = color;
  inst->colors[Corner_11] = color;
  inst->corner_radii[Corner_00] = corner_radius;
  inst->corner_radii[Corner_01] = corner_radius;
  inst->corner_radii[Corner_10] = corner_radius;
  inst->corner_radii[Corner_11] = corner_radius;
  inst->border_thickness = border_thickness;
  inst->edge_softness = edge_softness;
  inst->white_texture_override = 1.f;
  bucket->last_cmd_stack_gen = bucket->stack_gen;
  return inst;
}

//- rjf: images

internal inline R_Rect2DInst *
d_img(Rng2F32 dst, Rng2F32 src, R_Handle texture, Vec4F32 color, F32 corner_radius, F32 border_thickness, F32 edge_softness)
{
  Arena *arena = d_thread_ctx->arena;
  D_Bucket *bucket = d_top_bucket();
  R_Pass *pass = r_pass_from_kind(arena, &bucket->passes, R_PassKind_UI);
  R_PassParams_UI *params = pass->params_ui;
  R_BatchGroup2DList *rects = &params->rects;
  R_BatchGroup2DNode *node = rects->last;
  if(node != 0 && bucket->stack_gen == bucket->last_cmd_stack_gen && r_handle_match(node->params.tex, r_handle_zero()))
  {
    node->params.tex = texture;
  }
  else if(node == 0 || bucket->stack_gen != bucket->last_cmd_stack_gen || !r_handle_match(texture, node->params.tex))
  {
    node = push_array(arena, R_BatchGroup2DNode, 1);
    SLLQueuePush(rects->first, rects->last, node);
    rects->count += 1;
    node->batches = r_batch_list_make(sizeof(R_Rect2DInst));
    node->params.tex             = texture;
    node->params.tex_sample_kind = bucket->top_tex2d_sample_kind->v;
    node->params.xform           = bucket->top_xform2d->v;
    node->params.clip            = bucket->top_clip->v;
    node->params.transparency    = bucket->top_transparency->v;
  }
  R_Rect2DInst *inst = (R_Rect2DInst *)r_batch_list_push_inst(arena, &node->batches, 256);
  inst->dst = dst;
  inst->src = src;
  inst->colors[Corner_00] = color;
  inst->colors[Corner_01] = color;
  inst->colors[Corner_10] = color;
  inst->colors[Corner_11] = color;
  inst->corner_radii[Corner_00] = corner_radius;
  inst->corner_radii[Corner_01] = corner_radius;
  inst->corner_radii[Corner_10] = corner_radius;
  inst->corner_radii[Corner_11] = corner_radius;
  inst->border_thickness = border_thickness;
  inst->edge_softness = edge_softness;
  inst->white_texture_override = 0.f;
  bucket->last_cmd_stack_gen = bucket->stack_gen;
  return inst;
}

//- rjf: blurs

internal R_PassParams_Blur *
d_blur(Rng2F32 rect, F32 blur_size, F32 corner_radius)
{
  Arena *arena = d_thread_ctx->arena;
  D_Bucket *bucket = d_top_bucket();
  R_Pass *pass = r_pass_from_kind(arena, &bucket->passes, R_PassKind_Blur);
  R_PassParams_Blur *params = pass->params_blur;
  params->rect = rect;
  params->blur_size = blur_size;
  params->corner_radii[Corner_00] = corner_radius;
  params->corner_radii[Corner_01] = corner_radius;
  params->corner_radii[Corner_10] = corner_radius;
  params->corner_radii[Corner_11] = corner_radius;
  return params;
}

//- rjf: 3d rendering pass params

internal R_PassParams_Geo3D *
d_geo3d_begin(Rng2F32 viewport, Mat4x4F32 view, Mat4x4F32 projection)
{
  Arena *arena = d_thread_ctx->arena;
  D_Bucket *bucket = d_top_bucket();
  R_Pass *pass = r_pass_from_kind(arena, &bucket->passes, R_PassKind_Geo3D);
  R_PassParams_Geo3D *params = pass->params_geo3d;
  params->viewport = viewport;
  params->view = view;
  params->projection = projection;
  return params;
}

//- rjf: meshes

internal R_Mesh3DInst *
d_mesh(R_Handle mesh_vertices, R_Handle mesh_indices, R_GeoTopologyKind mesh_geo_topology, R_GeoVertexFlags mesh_geo_vertex_flags, R_Handle albedo_tex, Mat4x4F32 inst_xform)
{
  Arena *arena = d_thread_ctx->arena;
  D_Bucket *bucket = d_top_bucket();
  R_Pass *pass = r_pass_from_kind(arena, &bucket->passes, R_PassKind_Geo3D);
  R_PassParams_Geo3D *params = pass->params_geo3d;
  
  // rjf: mesh batch map not made yet -> make
  if(params->mesh_batches.slots_count == 0)
  {
    params->mesh_batches.slots_count = 64;
    params->mesh_batches.slots = push_array(arena, R_BatchGroup3DMapNode *, params->mesh_batches.slots_count);
  }
  
  // rjf: hash batch group 3d params
  U64 hash = 0;
  U64 slot_idx = 0;
  {
    U64 buffer[] =
    {
      mesh_vertices.u64[0],
      mesh_vertices.u64[1],
      mesh_indices.u64[0],
      mesh_indices.u64[1],
      (U64)mesh_geo_topology,
      (U64)mesh_geo_vertex_flags,
      albedo_tex.u64[0],
      albedo_tex.u64[1],
      (U64)d_top_tex2d_sample_kind(),
    };
    hash = d_hash_from_string(str8((U8 *)buffer, sizeof(buffer)));
    slot_idx = hash%params->mesh_batches.slots_count;
  }
  
  // rjf: map hash -> existing batch group node
  R_BatchGroup3DMapNode *node = 0;
  {
    for(R_BatchGroup3DMapNode *n = params->mesh_batches.slots[slot_idx]; n != 0; n = n->next)
    {
      if(n->hash == hash)
      {
        node = n;
        break;
      }
    }
  }
  
  // rjf: no batch group node? -> make one
  if(node == 0)
  {
    node = push_array(arena, R_BatchGroup3DMapNode, 1);
    SLLStackPush(params->mesh_batches.slots[slot_idx], node);
    node->hash = hash;
    node->batches = r_batch_list_make(sizeof(R_Mesh3DInst));
    node->params.mesh_vertices = mesh_vertices;
    node->params.mesh_indices = mesh_indices;
    node->params.mesh_geo_topology = mesh_geo_topology;
    node->params.mesh_geo_vertex_flags = mesh_geo_vertex_flags;
    node->params.albedo_tex = albedo_tex;
    node->params.albedo_tex_sample_kind = d_top_tex2d_sample_kind();
    node->params.xform = mat_4x4f32(1.f);
  }
  
  // rjf: push new instance to batch group
  R_Mesh3DInst *inst = (R_Mesh3DInst *)r_batch_list_push_inst(arena, &node->batches, 256);
  inst->xform = inst_xform;
  return inst;
}

//- rjf: collating one pre-prepped bucket into parent bucket

internal void
d_sub_bucket(D_Bucket *bucket)
{
  Arena *arena = d_thread_ctx->arena;
  D_Bucket *src = bucket;
  D_Bucket *dst = d_top_bucket();
  Rng2F32 dst_clip = d_top_clip();
  B32 dst_clip_is_set = !(dst_clip.x0 == 0 && dst_clip.x1 == 0 &&
                          dst_clip.y0 == 0 && dst_clip.y1 == 0);
  for(R_PassNode *n = src->passes.first; n != 0; n = n->next)
  {
    R_Pass *src_pass = &n->v;
    R_Pass *dst_pass = r_pass_from_kind(arena, &dst->passes, src_pass->kind);
    switch(dst_pass->kind)
    {
      default:{dst_pass->params = src_pass->params;}break;
      case R_PassKind_UI:
      {
        R_PassParams_UI *src_ui = src_pass->params_ui;
        R_PassParams_UI *dst_ui = dst_pass->params_ui;
        for(R_BatchGroup2DNode *src_group_n = src_ui->rects.first;
            src_group_n != 0;
            src_group_n = src_group_n->next)
        {
          R_BatchGroup2DNode *dst_group_n = push_array(arena, R_BatchGroup2DNode, 1);
          SLLQueuePush(dst_ui->rects.first, dst_ui->rects.last, dst_group_n);
          dst_ui->rects.count += 1;
          MemoryCopyStruct(&dst_group_n->params, &src_group_n->params);
          dst_group_n->batches = src_group_n->batches;
          dst_group_n->params.xform = d_top_xform2d();
          if(dst_clip_is_set)
          {
            B32 clip_is_set = !(dst_group_n->params.clip.x0 == 0 &&
                                dst_group_n->params.clip.y0 == 0 &&
                                dst_group_n->params.clip.x1 == 0 &&
                                dst_group_n->params.clip.y1 == 0);
            dst_group_n->params.clip = clip_is_set ? intersect_2f32(dst_clip, dst_group_n->params.clip) : dst_clip;
          }
        }
      }break;
    }
  }
}

////////////////////////////////
//~ rjf: Draw Call Helpers

//- rjf: text

internal void
d_truncated_fancy_run_list(Vec2F32 p, D_FancyRunList *list, F32 max_x, F_Run trailer_run)
{
  ProfBeginFunction();
  
  // rjf: grab total advance
  F32 run_list_total_advance = list->dim.x;
  
  // rjf: total advance > max? -> enable trailer
  B32 trailer_enabled = (run_list_total_advance >= max_x && trailer_run.dim.x < max_x);
  
  // rjf: draw runs
  F32 advance = 0;
  B32 trailer_found = 0;
  Vec4F32 last_color = {0};
  for(D_FancyRunNode *n = list->first; n != 0; n = n->next)
  {
    D_FancyRun *fr = &n->v;
    F_Piece *piece_first = fr->run.pieces.v;
    F_Piece *piece_opl = piece_first + fr->run.pieces.count;
    F32 pre_advance = advance;
    last_color = fr->color;
    for(F_Piece *piece = piece_first;
        piece < piece_opl;
        piece += 1)
    {
      if(trailer_enabled && advance + piece->advance >= (max_x - trailer_run.dim.x))
      {
        trailer_found = 1;
        break;
      }
      if(!trailer_enabled && advance + piece->advance >= max_x)
      {
        goto end_draw;
      }
      R_Handle texture = piece->texture;
      Rng2F32 src = r2f32p((F32)piece->subrect.x0, (F32)piece->subrect.y0, (F32)piece->subrect.x1, (F32)piece->subrect.y1);
      Vec2F32 size = dim_2f32(src);
      Rng2F32 dst = r2f32p(p.x + piece->offset.x + advance,
                           p.y + piece->offset.y,
                           p.x + piece->offset.x + advance + size.x,
                           p.y + piece->offset.y + size.y);
      if(!r_handle_match(texture, r_handle_zero()))
      {
        d_img(dst, src, texture, fr->color, 0, 0, 0);
      }
      advance += piece->advance;
    }
    if(fr->underline_thickness > 0)
    {
      d_rect(r2f32p(p.x+pre_advance,
                    p.y+fr->run.descent+fr->run.descent/8,
                    p.x+advance + (advance-pre_advance)/8,
                    p.y+fr->run.descent+fr->run.descent/8+fr->underline_thickness),
             fr->color, 0, 0, 1.f);
    }
    if(fr->strikethrough_thickness > 0)
    {
      d_rect(r2f32p(p.x+pre_advance, p.y+fr->run.descent - fr->run.ascent/2, p.x+advance, p.y+fr->run.descent - fr->run.ascent/2 + fr->strikethrough_thickness), fr->color, 0, 0, 1.f);
    }
    if(trailer_found)
    {
      break;
    }
  }
  end_draw:;
  
  // rjf: draw trailer
  if(trailer_found)
  {
    F_Piece *piece_first = trailer_run.pieces.v;
    F_Piece *piece_opl = piece_first + trailer_run.pieces.count;
    F32 pre_advance = advance;
    Vec4F32 trailer_piece_color = last_color;
    for(F_Piece *piece = piece_first;
        piece < piece_opl;
        piece += 1)
    {
      R_Handle texture = piece->texture;
      Rng2F32 src = r2f32p((F32)piece->subrect.x0, (F32)piece->subrect.y0, (F32)piece->subrect.x1, (F32)piece->subrect.y1);
      Vec2F32 size = dim_2f32(src);
      Rng2F32 dst = r2f32p(p.x + piece->offset.x + advance,
                           p.y + piece->offset.y,
                           p.x + piece->offset.x + advance + size.x,
                           p.y + piece->offset.y + size.y);
      if(!r_handle_match(texture, r_handle_zero()))
      {
        d_img(dst, src, texture, trailer_piece_color, 0, 0, 0);
        trailer_piece_color.w *= 0.5f;
      }
      advance += piece->advance;
    }
  }
  
  ProfEnd();
}

internal void
d_text_run(Vec2F32 p, Vec4F32 color, F_Run run)
{
  F32 advance = 0;
  F_Piece *piece_first = run.pieces.v;
  F_Piece *piece_opl = piece_first + run.pieces.count;
  for(F_Piece *piece = piece_first;
      piece < piece_opl;
      piece += 1)
  {
    R_Handle texture = piece->texture;
    Rng2F32 src = r2f32p((F32)piece->subrect.x0, (F32)piece->subrect.y0, (F32)piece->subrect.x1, (F32)piece->subrect.y1);
    Vec2F32 size = dim_2f32(src);
    Rng2F32 dst = r2f32p(p.x + piece->offset.x + advance,
                         p.y + piece->offset.y,
                         p.x + piece->offset.x + advance + size.x,
                         p.y + piece->offset.y + size.y);
    if(size.x != 0 && size.y != 0 && !r_handle_match(texture, r_handle_zero()))
    {
      d_img(dst, src, texture, color, 0, 0, 0);
    }
    advance += piece->advance;
  }
}

internal void
d_truncated_text_run(Vec2F32 p, Vec4F32 color, F32 max_x, F_Run text_run, F_Run trailer_run)
{
  B32 truncated = 0;
  B32 set_truncation = 0;
  F32 truncation_p = p.x;
  F32 max_x_minus_ellipses = max_x - trailer_run.dim.x;
  F32 available_space = max_x - p.x;
  
  // rjf: find last piece before truncation
  B32 truncation_needed = 0;
  F_Piece *last_piece_before_truncation = 0;
  F32 truncation_offset = 0;
  if(available_space > text_run.dim.x || available_space > trailer_run.dim.x)
  {
    F32 advance = 0;
    F_Piece *text_run_first = text_run.pieces.v;
    F_Piece *text_run_opl = text_run_first + text_run.pieces.count;
    for(F_Piece *piece = text_run_first;
        piece < text_run_opl;
        piece += 1)
    {
      Rng2F32 src = r2f32p((F32)piece->subrect.x0, (F32)piece->subrect.y0, (F32)piece->subrect.x1, (F32)piece->subrect.y1);
      Vec2F32 size = dim_2f32(src);
      Rng2F32 dst = r2f32p(p.x + piece->offset.x + advance,
                           p.y + piece->offset.y,
                           p.x + piece->offset.x + advance + size.x,
                           p.y + piece->offset.y + size.y);
      advance += piece->advance;
      if(last_piece_before_truncation == 0 && p.x + advance > max_x_minus_ellipses)
      {
        truncation_offset = advance - piece->advance;
        last_piece_before_truncation = piece;
      }
      if(p.x + advance > max_x)
      {
        truncation_needed = 1;
      }
    }
  }
  
  // rjf: draw pieces
  if(available_space > text_run.dim.x || available_space > trailer_run.dim.x)
  {
    F32 advance = 0;
    F_Piece *text_run_first = text_run.pieces.v;
    F_Piece *text_run_opl = text_run_first + text_run.pieces.count;
    for(F_Piece *piece = text_run_first;
        piece < text_run_opl;
        piece += 1)
    {
      if(truncation_needed && piece == last_piece_before_truncation)
      {
        break;
      }
      R_Handle texture = piece->texture;
      Rng2F32 src = r2f32p((F32)piece->subrect.x0, (F32)piece->subrect.y0, (F32)piece->subrect.x1, (F32)piece->subrect.y1);
      Vec2F32 size = dim_2f32(src);
      Rng2F32 dst = r2f32p(p.x + piece->offset.x + advance,
                           p.y + piece->offset.y,
                           p.x + piece->offset.x + advance + size.x,
                           p.y + piece->offset.y + size.y);
      if(size.x != 0 && size.y != 0 && !r_handle_match(texture, r_handle_zero()))
      {
        d_img(dst, src, texture, color, 0, 0, 0);
      }
      advance += piece->advance;
    }
  }
  
  // rjf: draw truncation ellipses
  if(truncation_needed && last_piece_before_truncation != 0)
  {
    Vec2F32 ellipses_p = {p.x + truncation_offset, p.y};
    Vec4F32 ellipses_color = color;
    F32 advance = 0;
    F_Piece *trailer_run_first = trailer_run.pieces.v;
    F_Piece *trailer_run_opl = trailer_run_first + trailer_run.pieces.count;
    for(F_Piece *piece = trailer_run_first;
        piece < trailer_run_opl;
        piece += 1)
    {
      R_Handle texture = piece->texture;
      Rng2F32 src = r2f32p((F32)piece->subrect.x0, (F32)piece->subrect.y0, (F32)piece->subrect.x1, (F32)piece->subrect.y1);
      Vec2F32 size = dim_2f32(src);
      Rng2F32 dst = r2f32p(ellipses_p.x + piece->offset.x + advance,
                           ellipses_p.y + piece->offset.y,
                           ellipses_p.x + piece->offset.x + advance + size.x,
                           ellipses_p.y + piece->offset.y + size.y);
      if(size.x != 0 && size.y != 0 && !r_handle_match(texture, r_handle_zero()))
      {
        d_img(dst, src, texture, ellipses_color, 0, 0, 0);
      }
      ellipses_color.w *= 0.5f;
      advance += piece->advance;
    }
  }
}

internal void
d_text(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, String8 string)
{
  Temp scratch = scratch_begin(0, 0);
  F_Run run = f_push_run_from_string(scratch.arena, font, size, 0, string);
  d_text_run(p, color, run);
  scratch_end(scratch);
}

internal void
d_textf(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, char *fmt, ...)
{
  Temp scratch = scratch_begin(0, 0);
  va_list args;
  va_start(args, fmt);
  String8 string = push_str8fv(scratch.arena, fmt, args);
  va_end(args);
  d_text(font, size, p, color, string);
  scratch_end(scratch);
}

internal void
d_truncated_text(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, F32 max_x, String8 string)
{
  Temp scratch = scratch_begin(0, 0);
  F_Run run = f_push_run_from_string(scratch.arena, font, size, 0, string);
  F_Run ellipses_run = f_push_run_from_string(scratch.arena, font, size, 0, str8_lit("..."));
  d_truncated_text_run(p, color, max_x, run, ellipses_run);
  scratch_end(scratch);
}

internal void
d_truncated_textf(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, F32 max_x, char *fmt, ...)
{
  Temp scratch = scratch_begin(0, 0);
  va_list args;
  va_start(args, fmt);
  String8 string = push_str8f(scratch.arena, fmt, args);
  d_truncated_text(font, size, p, color, max_x, string);
  va_end(args);
  scratch_end(scratch);
}