kmx git

/* kc3
 * Copyright from 2022 to 2025 kmx.io <contact@kmx.io>
 *
 * Permission is hereby granted to use this software granted the above
 * copyright notice and this permission paragraph are included in all
 * copies and substantial portions of this software.
 *
 * THIS SOFTWARE IS PROVIDED "AS-IS" WITHOUT ANY GUARANTEE OF
 * PURPOSE AND PERFORMANCE. IN NO EVENT WHATSOEVER SHALL THE
 * AUTHOR BE CONSIDERED LIABLE FOR THE USE AND PERFORMANCE OF
 * THIS SOFTWARE.
 */
#include <math.h>
#include <libkc3/kc3.h>
#include "../gl_box.h"
#include "../gl_camera.h"
#include "../gl_object.h"
#include "../gl_sprite.h"
#include "../gl_square.h"
#include "../gl_vertex.h"
#include "../mat4.h"
#include "info.h"
#include "intro.h"
#include "gl_marching_cubes.h"

#define INTRO_SPHERES_MAX 128
#define INTRO_SQUARES_MAX 100

static s_vec4      g_intro_sphere_center[INTRO_SPHERES_MAX] = {0};
static s_gl_sprite g_intro_sprite_kmx_io = {0};
static s_gl_square g_intro_square[INTRO_SQUARES_MAX] = {0};

bool intro_load (s_sequence *seq)
{
  s_gl_marching_cubes *blob = NULL;
  s_gl_box *    box = NULL;
  const s_vec3  box_size = {16.0f, 9.0f, 9.0f};
  s_gl_camera *camera = NULL;
  s_vec4 *center;
  u32 i;
  s_map *map = NULL;
  s_mat4 matrix = {0};
  f32 point_per_pixel;
  s_gl_square *square;
  s_window_sdl2 *window = NULL;
  assert(seq);
  window = seq->window;
  assert(window);
  assert(glGetError() == GL_NO_ERROR);
  point_per_pixel = (f32) window->w / window->gl_w;
  camera = gl_camera_new(window->w, window->h);
  if (! camera)
    return false;
  box = gl_box_new(16, 9, 9);
  if (! box)
    return false;
  mat4_init_scale(&matrix, box_size.x, box_size.y, box_size.z);
  gl_object_transform(&box->object, &matrix);
  gl_object_update(&box->object);
  blob = gl_marching_cubes_new((u32[]) {16 * 2, 9 * 2, 9});
  if (! blob)
    return false;
  blob->size = box_size;
  blob->threshold = 0.5f;
  center = g_intro_sphere_center;
  i = 0;
  while (i < INTRO_SPHERES_MAX) {
    center->x = (f32_random() - 0.5f) * 12.0;
    center->y = -4.0 - f32_random() * 128.0f;
    center->z = (f32_random() - 0.5f) * 5.0;
    center->t = f32_random() * 0.05f;
    center++;
    i++;
  }
  if (! gl_sprite_init(&g_intro_sprite_kmx_io,
                       "img/kmx.logo.text.256.a20.png",
                       1, 1, 1, point_per_pixel))
    return false;
  square = g_intro_square;
  i = 0;
  while (i < INTRO_SQUARES_MAX) {
    gl_square_init(square, 1, 1);
    mat4_init_translate(&matrix, -0.5f, -0.5f,
                        -((f32) i / (INTRO_SQUARES_MAX - 1) - 0.5f) *
                        9.0f);
    mat4_scale(&matrix, box_size.x + 4.0f, box_size.y + 4.0f, 1.0f);
    gl_object_transform(&square->object, &matrix);
    gl_object_update(&square->object);
    square++;
    i++;
  }
  if (! tag_map(&seq->tag, 3))
    return false;
  map = &seq->tag.data.map;
  tag_init_psym(             map->key   + 0, sym_1("blob"));
  tag_init_pstruct_with_data(map->value + 0, sym_1("GL.MarchingCubes"),
                             blob, false);
  tag_init_psym(             map->key   + 1, sym_1("box"));
  tag_init_pstruct_with_data(map->value + 1, sym_1("GL.Box"),
                             box, false);
  tag_init_psym(             map->key   + 2, sym_1("camera"));
  tag_init_ptr_free(         map->value + 2, camera);
  err_puts("intro_load: ok");
  return true;
}

void intro_animate_blob (s_gl_marching_cubes *blob, f32 dt)
{
  s_vec4 *center;
  uw i;
  gl_marching_cubes_zero(blob);
  i = 0;
  // FIXME: OpenMP
  while (i < INTRO_SPHERES_MAX) {
    center = g_intro_sphere_center + i;
    center->y += dt * center->t;
    gl_marching_cubes_sphere(blob, (s_vec3 *) center, 1.0f, 2.0f);
    i++;
  }
}

bool intro_render (s_sequence *seq)
{
  s_gl_marching_cubes *blob;
  s_gl_box *box;
  s_gl_camera *camera;
  u32 i;
  s_map *map;
  s_gl_square *square;
  s_window_sdl2 *window = NULL;
  assert(glGetError() == GL_NO_ERROR);
  assert(seq);
  window = seq->window;
  assert(window);
  if (! seq || seq->tag.type != TAG_MAP ||
      seq->tag.data.map.count != 3) {
    err_puts("intro_render: invalid sequence tag");
    return false;
  }
  map = &seq->tag.data.map;
  if (map->value[0].type != TAG_PSTRUCT ||
      map->value[1].type != TAG_PSTRUCT ||
      map->value[2].type != TAG_PTR_FREE) {
    err_puts("intro_render: invalid map");
    return false;
  }
  blob = map->value[0].data.pstruct->data;
  box = map->value[1].data.pstruct->data;
  camera = map->value[2].data.ptr_free.p;
  glEnable(GL_DEPTH_TEST);
  assert(glGetError() == GL_NO_ERROR);
  glDepthFunc(GL_LESS);
  assert(glGetError() == GL_NO_ERROR);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  assert(glGetError() == GL_NO_ERROR);
  glDepthMask(GL_TRUE);
  assert(glGetError() == GL_NO_ERROR);
  glEnable(GL_BLEND);
  assert(glGetError() == GL_NO_ERROR);
  glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
                      GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  assert(glGetError() == GL_NO_ERROR);
  info_render_fps(seq);
  assert(glGetError() == GL_NO_ERROR);
  gl_camera_set_aspect_ratio(camera, window->w, window->h);
  camera->clip_z_far = camera->position.z * 2.0f;
  camera->rotation.y = sin(seq->t * M_PI / 6.0f) * M_PI / 8.0f;
  camera->rotation.x = sin(seq->t * M_PI / 8.0f) * M_PI / 8.0f;
  camera->position.z = -10.0f + cosf(seq->t * M_PI / 2.0f) * 2.0f;
  gl_camera_render(camera);
  assert(glGetError() == GL_NO_ERROR);
  gl_box_render_points(box);
  assert(glGetError() == GL_NO_ERROR);
  intro_animate_blob(blob, seq->t);
  gl_marching_cubes_update(blob);
  gl_marching_cubes_render(blob);
  assert(glGetError() == GL_NO_ERROR);
  gl_camera_bind_texture(camera, g_intro_sprite_kmx_io.texture[0]);
  square = g_intro_square;
  i = 0;
  while (i < INTRO_SQUARES_MAX) {
    gl_square_render(square);
    assert(glGetError() == GL_NO_ERROR);
    square++;
    i++;
  }
  gl_camera_bind_texture(camera, 0);
  assert(glGetError() == GL_NO_ERROR);
  glDisable(GL_DEPTH_TEST);
  assert(glGetError() == GL_NO_ERROR);
  glDisable(GL_BLEND);
  assert(glGetError() == GL_NO_ERROR);
  return true;
}

bool intro_unload (s_sequence *seq)
{
  (void) seq;
  return true;
}
kc3-lang/kubz/intro.c

Commit

intro.c
