kc3-lang/kubz/gl_marching_cubes.c

Branch - branch -master- tag -v0

• Show log

  Commit

• Hash : 36df94af
  Author : Thomas de Grivel
  Date : 2025-03-02T16:13:53
  

  Change copyright wording and extend to 2025
  

Download

• gl_marching_cubes.c

• /* 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 <libkc3/kc3.h>
  #include "../gl_object.h"
  #include "../vec3.h"
  #include "gl_marching_cube.h"
  #include "gl_marching_cubes.h"
  
  void
  gl_marching_cubes_clean (s_gl_marching_cubes *marching_cubes)
  {
    free(marching_cubes->field);
  }
  
  void
  gl_marching_cubes_delete (s_gl_marching_cubes *marching_cubes)
  {
    assert(marching_cubes);
    gl_marching_cubes_clean(marching_cubes);
    free(marching_cubes);
  }
  
  f32
  gl_marching_cubes_f (s_gl_marching_cubes *marching_cubes, u32 i, u32 j, u32 k)
  {
    u32 v;
    u32 w;
    assert(marching_cubes);
    assert(i < marching_cubes->dimension[0]);
    assert(j < marching_cubes->dimension[1]);
    assert(k < marching_cubes->dimension[2]);
    v = marching_cubes->dimension[1];
    w = marching_cubes->dimension[2];
    return marching_cubes->field[i * v * w + j * w + k];
  }
  
  f32 *
  gl_marching_cubes_f_w (s_gl_marching_cubes *marching_cubes, u32 i, u32 j,
                         u32 k)
  {
    u32 v;
    u32 w;
    assert(marching_cubes);
    assert(i < marching_cubes->dimension[0]);
    assert(j < marching_cubes->dimension[1]);
    assert(k < marching_cubes->dimension[2]);
    v = marching_cubes->dimension[1];
    w = marching_cubes->dimension[2];
    return marching_cubes->field +
      w * v * i +
      w * j +
      k;
  }
  
  s_gl_marching_cubes *
  gl_marching_cubes_init (s_gl_marching_cubes *marching_cubes,
                          u32 *dimension)
  {
    s_gl_marching_cubes tmp = {0};
    tmp.dimension[0] = dimension[0];
    tmp.dimension[1] = dimension[1];
    tmp.dimension[2] = dimension[2];
    if (! (tmp.field = alloc(tmp.dimension[0] *
                             tmp.dimension[1] *
                             tmp.dimension[2] * sizeof(f32))))
      return NULL;
    if (! gl_object_init(&tmp.object)) {
      free(tmp.field);
      return NULL;
    }
    if (! gl_object_allocate(&tmp.object, tmp.dimension[0] *
                             tmp.dimension[1] * tmp.dimension[2] * 5 * 3,
                             1)) {
      gl_object_clean(&marching_cubes->object);
      free(tmp.field);
      return NULL;
    }
    *marching_cubes = tmp;
    return marching_cubes;
  }
  
  s_gl_marching_cubes *
  gl_marching_cubes_new (u32 *dimension)
  {
    s_gl_marching_cubes *marching_cubes;
    if (! (marching_cubes = alloc(sizeof(s_gl_marching_cubes))))
      return NULL;
    if (! gl_marching_cubes_init(marching_cubes, dimension)) {
      free(marching_cubes);
      return NULL;
    }
    return marching_cubes;
  }
  
  void gl_marching_cubes_render (s_gl_marching_cubes *marching_cubes)
  {
    if (false) {
      err_write_1("gl_marching_cubes_render: triangle_count = ");
      err_inspect_uw_decimal(&marching_cubes->triangle_count);
      err_write_1("\n");
    }
    gl_object_render_triangles(&marching_cubes->object,
                               marching_cubes->triangle_count);
  }
  
  void
  gl_marching_cubes_render_points (s_gl_marching_cubes *marching_cubes)
  {
    if (false) {
      err_write_1("gl_marching_cubes_render: triangle_count = ");
      err_inspect_uw_decimal(&marching_cubes->triangle_count);
      err_write_1("\n");
    }
    gl_object_render_points(&marching_cubes->object,
                            marching_cubes->triangle_count * 3);
  }
  
  void gl_marching_cubes_sphere (s_gl_marching_cubes *marching_cubes,
                                 s_vec3 *center, f32 center_value,
                                 f32 radius)
  {
    s_vec3 *c;
    u32 *d;
    f32 dx;
    f32 dy;
    f32 dz;
    f32  f;
    f32 *field;
    u32 i;
    u32 j;
    u32 k;
    s_vec3 *s;
    u32 u;
    u32 u1;
    u32 v;
    u32 v1;
    u32 w;
    u32 w1;
    assert(marching_cubes);
    assert(center);
    assert(radius >= 0.0f);
    c = center;
    d = marching_cubes->dimension;
    s = &marching_cubes->size;
    u =  f32_clamp(floor(c->x - radius) / s->x + 0.5f, 0, 1) * d[0];
    u1 = f32_clamp( ceil(c->x + radius) / s->x + 0.5f, 0, 1) * d[0];
    v =  f32_clamp(floor(c->y - radius) / s->y + 0.5f, 0, 1) * d[1];
    v1 = f32_clamp( ceil(c->y + radius) / s->y + 0.5f, 0, 1) * d[1];
    w =  f32_clamp(floor(c->z - radius) / s->z + 0.5f, 0, 1) * d[2];
    w1 = f32_clamp( ceil(c->z + radius) / s->z + 0.5f, 0, 1) * d[2];
    if (false) {
      err_write_1("gl_marching_cubes_sphere: u=");
      err_inspect_u32_decimal(&u);
      err_write_1(" u1=");
      err_inspect_u32_decimal(&u1);
      err_write_1(" v=");
      err_inspect_u32_decimal(&v);
      err_write_1(" v1=");
      err_inspect_u32_decimal(&v1);
      err_write_1(" w=");
      err_inspect_u32_decimal(&w);
      err_write_1(" w1=");
      err_inspect_u32_decimal(&w1);
      err_write_1("\n");
    }
    i = u;
    while (i < u1) {
      dx = ((f32) i / d[0] - 0.5f) * s->x - c->x;
      j = v;
      while (j < v1) {
        dy = ((f32) j / d[1] - 0.5f) * s->y - c->y;
        k = w;
        while (k < w1) {
          dz = ((f32) k / d[2] - 0.5f) * s->z - c->z;
          field = gl_marching_cubes_f_w(marching_cubes, i, j, k);
          f = f32_clamp(center_value *
                        (1.0f - (cbrtf(dx * dx + dy * dy + dz * dz) /
                                 radius)),
                        0.0f, center_value);
          if (false) {
            if (f > marching_cubes->threshold) {
              err_write_1("gl_marching_cubes_sphere: f = ");
              err_inspect_f32(&f);
              err_write_1("\n");
            }
          }
          *field += f;
          k++;
        }
        j++;
      }
      i++;
    }
  }
  
  bool gl_marching_cubes_update (s_gl_marching_cubes *marching_cubes)
  {
    s_gl_marching_cube_cell cell;
    sw i;
    sw j;
    sw k;
    s8 r;
    u32 u;
    u32 v;
    s_gl_vertex *vertex;
    u32 w;
    f32 x;
    f32 x1;
    f32 y;
    f32 y1;
    f32 z;
    f32 z1;
    u = marching_cubes->dimension[0];
    v = marching_cubes->dimension[1];
    w = marching_cubes->dimension[2];
    vertex = marching_cubes->object.vertex.data;
    marching_cubes->triangle_count = 0;
    assert(vertex);
    i = 0;
    while (i < u - 1) {
      x =  ((f32)  i      / u - 0.5f) * marching_cubes->size.x;
      x1 = ((f32) (i + 1) / u - 0.5f) * marching_cubes->size.x;
      j = 0;
      while (j < v - 1) {
        y =  ((f32)  j      / v - 0.5f) * marching_cubes->size.y;
        y1 = ((f32) (j + 1) / v - 0.5f) * marching_cubes->size.y;
        k = 0;
        while (k < w - 1) {
          z =  ((f32)  k      / w - 0.5f) * marching_cubes->size.z;
          z1 = ((f32) (k + 1) / w - 0.5f) * marching_cubes->size.z;
          cell = (s_gl_marching_cube_cell) {
            {{x,  y,  z }, {x1, y,  z },
             {x1, y,  z1}, {x,  y,  z1},
             {x,  y1, z }, {x1, y1, z }, 
             {x1, y1, z1}, {x,  y1, z1}},
            {gl_marching_cubes_f(marching_cubes, i,     j,     k),
             gl_marching_cubes_f(marching_cubes, i + 1, j,     k),
             gl_marching_cubes_f(marching_cubes, i + 1, j,     k + 1),
             gl_marching_cubes_f(marching_cubes, i,     j,     k + 1),
             gl_marching_cubes_f(marching_cubes, i,     j + 1, k),
             gl_marching_cubes_f(marching_cubes, i + 1, j + 1, k),
             gl_marching_cubes_f(marching_cubes, i + 1, j + 1, k + 1),
             gl_marching_cubes_f(marching_cubes, i,     j + 1, k + 1)}};
          r = gl_marching_cube_cell_triangles(&cell,
                                              marching_cubes->threshold,
                                              vertex);
          if (r > 5) {
            err_write_1("gl_marching_cubes_update: cell triangles = ");
            err_inspect_s8(&r);
            assert(! "gl_marching_cubes_update: cell triangles > 5");
            abort();
          }
          vertex += r * 3;
          marching_cubes->triangle_count += r;
          k++;
        }
        j++;
      }
      i++;
    }
    return gl_object_update(&marching_cubes->object);
  }
  
  void gl_marching_cubes_zero (s_gl_marching_cubes *marching_cubes)
  {
    f32 *field;
    u32 i;
    u32 j;
    u32 k;
    u32 u;
    u32 v;
    u32 w;
    assert(marching_cubes);
    u = marching_cubes->dimension[0];
    v = marching_cubes->dimension[1];
    w = marching_cubes->dimension[2];
    field = marching_cubes->field;
    i = 0;
    while (i < u) {
      j = 0;
      while (j < v) {
        k = 0;
        while (k < w) {
          *field = 0.0f;
          field++;
          k++;
        }
        j++;
      }
      i++;
    }
  }
  

Download