star-meshtool

mtool.c (6564B)

---

 /* Copyright (C) 2025 |Méso|Star> (contact@meso-star.com)
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
 #include "mtool.h"
 
 #include <star/sstl.h>
 
 #include <rsys/cstr.h>
 #include <rsys/double3.h>
 #include <rsys/double33.h>
 #include <rsys/float3.h>
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 static void
 print_description(struct sstl_desc* desc)
 {
   float low[3], upp[3];
   size_t i;
 
   ASSERT(desc);
 
   /* Calculate the mesh AABB */
   f3_splat(low, FLT_MAX);
   f3_splat(upp,-FLT_MAX);
   FOR_EACH(i, 0, desc->vertices_count) {
     f3_min(low, low, desc->vertices+3*i);
     f3_max(upp, upp, desc->vertices+3*i);
   }
 
   /* Display the mesh description */
   fprintf(stderr,
     "Type: %s, Vertice count: %ld, Triangle count: %ld\n"
     "Xrange: [%g %g], Yrange: [%g %g], Zrange: [%g %g]\n",
     desc->type == SSTL_ASCII ? "ACII" : "BINARY",
     desc->vertices_count,
     desc->triangles_count,
     SPLIT3(low),
     SPLIT3(upp));
 }
 
 static res_T
 create_writer(struct mtool* mtool, struct sstl_writer** out_writer)
 {
   struct sstl_writer_create_args writer_args = SSTL_WRITER_CREATE_ARGS_DEFAULT;
   struct sstl_writer* writer = NULL;
   res_T res = RES_OK;
 
   ASSERT(mtool && out_writer);
 
   if(mtool->args.output) {
     /* Write StL to the destination file */
     writer_args.filename = mtool->args.output;
     writer_args.stream = NULL;
 
   } else {
     /*  Write StL to stdout */
     writer_args.filename = "stdout";
     writer_args.stream = stdout;
   }
 
   /* The output type is the one defined in the command line. Note that this
    * option can also be used to define the type of input data provided on stdin.
    * This is confusing, as the option is used for two files: input and output.
    * TODO: correct this confusion */
   writer_args.type = mtool->args.type;
   writer_args.triangles_count = (long)mtool->desc.triangles_count;
 
   if((res = sstl_writer_create(&writer_args, &writer)) != RES_OK) goto error;
 
 exit:
   *out_writer = writer;
   return res;
 error:
   if(writer) { SSTL(writer_ref_put(writer)); writer = NULL; }
   goto exit;
 }
 
 static res_T
 load(struct mtool* mtool, const struct mtool_args* args)
 {
   res_T res = RES_OK;
   ASSERT(mtool && args);
 
   res = sstl_create(NULL, NULL, args->verbose, &mtool->sstl);
   if(res != RES_OK) goto error;
 
   if(args->input) {
     /* Load data from the provided input file */
     if((res = sstl_load(mtool->sstl, args->input)) != RES_OK) goto error;
 
   } else {
     /* Data are loaded from stdin. The StL type must be defined because the
      * standard input is not searchable. */
     switch(args->type) {
       case SSTL_ASCII:
         res = sstl_load_stream_ascii(mtool->sstl, stdin, "stdin (ASCII)");
         break;
       case SSTL_BINARY:
         res = sstl_load_stream_binary(mtool->sstl, stdin, "stdin (binary)");
         break;
       default: FATAL("Unreachable code\n"); break;
     }
     if(res != RES_OK) goto error;
   }
 
   if((res = sstl_get_desc(mtool->sstl, &mtool->desc)) != RES_OK) goto error;
 
 exit:
   return res;
 error:
   if(mtool->sstl) { SSTL(ref_put(mtool->sstl)); mtool->sstl = NULL; }
   goto exit;
 }
 
 static res_T
 transform_mesh(struct mtool* mtool)
 {
   struct sstl_writer* writer = NULL;
   size_t itri = 0;
   res_T res = RES_OK;
 
   if((res = create_writer(mtool, &writer)) != RES_OK) goto error;
 
   FOR_EACH(itri, 0, mtool->desc.triangles_count) {
     struct sstl_facet facet = SSTL_FACET_NULL;
 
     /* Get the facet */
     res = sstl_desc_get_facet(&mtool->desc, itri, &facet);
     if(res != RES_OK) goto error;
 
     /* Multiply the vertices by the transformation matrix constructed from the
      * transformations submitted on the command line */
     #define TRANSFORM(Vertex) { \
       double vec[3] = {0,0,0}; \
       d3_set_f3(vec, Vertex); \
       d33_muld3(vec, mtool->args.transform, vec); \
       d3_add(vec, mtool->args.transform+9, vec); \
       f3_set_d3(Vertex, vec); \
     } (void) 0
     TRANSFORM(facet.vertices[0]);
     TRANSFORM(facet.vertices[1]);
     TRANSFORM(facet.vertices[2]);
     #undef TRANSFORM
 
     if(mtool->args.reverse_normals) {
       /* Swap the first two vertices to flip the orientation of the triangle */
       SWAP(float, facet.vertices[0][0], facet.vertices[1][0]);
       SWAP(float, facet.vertices[0][1], facet.vertices[1][1]);
       SWAP(float, facet.vertices[0][2], facet.vertices[1][2]);
 
       /* Reverse the normal even if, in reality, Star-StL does not provide it:
        * it will be automatically calculated during writing from the vertices of
        * the facet. However, this may not always be true, hence the explicit
        * reversal of this normal, which allows for robustness against possible
        * future changes without adding significant computational cost */
       f3_minus(facet.normal, facet.normal);
     }
 
     /* Write the facet */
     if((res = sstl_write_facet(writer, &facet)) != RES_OK) goto error;
   }
 
 exit:
   if(writer) SSTL(writer_ref_put(writer));
   return res;
 error:
   goto exit;
 }
 
 /*******************************************************************************
  * Local functions
  ******************************************************************************/
 res_T
 mtool_init(struct mtool* mtool, const struct mtool_args* args)
 {
   res_T res = RES_OK;
   ASSERT(mtool && args);
 
   *mtool = MTOOL_NULL;
 
   /* Load the StL */
   if((res = load(mtool, args)) != RES_OK) goto error;
   mtool->args = *args;
 
 exit:
   return res;
 error:
   mtool_release(mtool);
   goto exit;
 }
 
 void
 mtool_release(struct mtool* mtool)
 {
   ASSERT(mtool);
   if(mtool->sstl) SSTL(ref_put(mtool->sstl));
   mtool_args_release(&mtool->args);
 }
 
 res_T
 mtool_run(struct mtool* mtool)
 {
   res_T res = RES_OK;
 
   if(mtool->args.print_desc) {
     print_description(&mtool->desc);
 
   } else {
     res = transform_mesh(mtool);
     if(res != RES_OK) goto error;
   }
 
 exit:
   return res;
 error:
   goto exit;
 }