/* See {rdo_scene.h} */
#define rdo_scene_C_COPYRIGHT "Copyright © 2008 Danillo Pereira and J. Stolfi, UNICAMP"
/* Last edited on 2024-12-21 11:51:37 by stolfi */ 

#include <stdio.h>
#include <assert.h>

#include <frgb.h>
#include <frgb_ops.h>
#include <argparser.h>
#include <filefmt.h>
#include <jsfile.h>
#include <nget.h>
#include <fget.h>
#include <fget_geo.h>
#include <vec.h>
#include <affirm.h>
#include <bool.h>
#include <dspmat.h>

#include <rdo_geometry.h>
#include <rdo_solid.h>
#include <rdo_site.h>
#include <rdo_lighting.h>
#include <rdo_finish.h>
#include <rdo_approx_basis.h>
#include <rdo_scene.h>
  

#define scene_FILE_VERSION "2008-07-14"
  /* Identifies the format version of a scene file. */

scene_t *rdo_scene_read
  )
  {
    scene_t *scn = NOTNULL(malloc(sizeof(scene_t)));

    if (solids_filename != NULL)
      { FILE *solids_file = open_read(solids_filename, TRUE);
        scn->sds = rdo_solid_vec_read(solids_file);
        fclose(solids_file);
      }
    else 
      { scn->sds = solid_vec_new(0); }
    fprintf(stderr, "got %d solids\n", scn->sds.ne);

    if (finishes_filename != NULL)
      { FILE *finishes_file = open_read(finishes_filename, TRUE);
        scn->fns = rdo_finish_vec_read(finishes_file);
        fclose(finishes_file);
        rdo_scene_associate_finishes(&(scn->sds), &(scn->fns));
      }
    else 
      { scn->fns = finish_vec_new(0); }
    fprintf(stderr, "got %d finishes\n", scn->fns.ne);

    if (sites_filename != NULL)
      { FILE *sites_file = open_read(sites_filename, TRUE);
        scn->smp = rdo_site_vec_read(sites_file);
        fclose(sites_file);
      }
    else 
      { scn->smp = site_vec_new(0); }
    fprintf(stderr, "got %d sampling sites\n", scn->smp.ne);

    if (transferMatrix_filename != NULL)
      { FILE *transferMatrix_file = open_read(transferMatrix_filename, TRUE);
        scn->T = dspmat_new(0,0,0); dspmat_read(transferMatrix_file, &(scn->T));
        fclose(transferMatrix_file);
      }
    else 
      { scn->T = dspmat_new(0,0,0); }
    fprintf(stderr, "got %d T-matrix entries\n", scn->T.ents);

    if (approxBasis_filename != NULL)
      { FILE *approxBasis_file = open_read(approxBasis_filename, TRUE);
        scn->bas = rdo_approx_basis_read(approxBasis_file);
        fclose(approxBasis_file);
      }
    else 
      { scn->bas = approx_basis_new(0); }
    fprintf(stderr, "got %d approx basis elements\n", scn->bas.ne);

    if (basisMatrix_filename != NULL)
      { FILE *basisMatrix_file = open_read(basisMatrix_filename, TRUE);
        scn->M = dspmat_new(0,0,0); dspmat_read(basisMatrix_file, &(scn->M));
        fclose(basisMatrix_file);
      }
    else 
      { scn->M = dspmat_new(0,0,0); }
    fprintf(stderr, "got %d M-matrix entries\n", scn->M.ents);

    return scn;
  }

void rdo_scene_write(char *outDir, char *name, scene_t *scn)
  { 
    if (scn->sds.ne != 0)
        char *solids_filename = jsprintf("%s/%s.sds", outDir, name);
        FILE *solids_file = open_write(solids_filename, TRUE);
        rdo_solid_vec_write(solids_file, &(scn->sds));
        fclose(solids_file);
        free(solids_filename);
      }

    if (scn->fns.ne != 0)
        char *finishes_filename = jsprintf("%s/%s.fns", outDir, name);
        FILE *finishes_file = open_write(finishes_filename, TRUE);
        rdo_finish_vec_write(finishes_file, &(scn->fns));
        fclose(finishes_file);
        free(finishes_filename);
      }

    if (scn->smp.ne != 0)
        char *sites_filename = jsprintf("%s/%s.smp", outDir, name);
        FILE *sites_file = open_write(sites_filename, TRUE);
        rdo_site_vec_write(sites_file, &(scn->smp));
        fclose(sites_file);
        free(sites_filename);
      }

    if (scn->T.ents != 0)
        char *transferMatrix_filename = jsprintf("%s/%s.T", outDir, name);
        FILE *transferMatrix_file = open_write(transferMatrix_filename, TRUE);
        dspmat_write(transferMatrix_file, &(scn->T));
        fclose(transferMatrix_file);
        free(transferMatrix_filename);
      }

    if (scn->bas.ne != 0)
        char *approxBasis_filename = jsprintf("%s/%s.bas", outDir, name);
        FILE *approxBasis_file = open_write(approxBasis_filename, TRUE);
        rdo_approx_basis_write(approxBasis_file, &(scn->bas));
        fclose(approxBasis_file);
        free(approxBasis_filename);
      }

    if (scn->M.ents != 0)
        char *basisMatrix_filename = jsprintf("%s/%s.M", outDir, name);
        FILE *basisMatrix_file = open_write(basisMatrix_filename, TRUE);
        dspmat_write(basisMatrix_file, &(scn->M));
        fclose(basisMatrix_file);
        free(basisMatrix_filename);
      }
  }

void rdo_scene_associate_finishes(solid_vec_t *sds, finish_vec_t *fns)
  {
    int i;
    for (i = 0; i < sds->ne; i++)
      { solid_t *obi = &(sds->e[i]);
        /* Find the index {obi->ifn} of the finish for solid object {obi}: */
        obi->ifn = -1;
        int j;
        for (j = 0; j < fns->ne; j++)
          { finish_t *fnj = &(fns->e[j]);
            if (strcmp(obi->name, fnj->name) == 0)
              { obi->ifn = j; break; }
          }
        if (obi->ifn < 0) 
          { fprintf(stderr, "  ** solid object %d name = \"%s\"\n", i, obi->name);
            demand(FALSE, "finish not found");
          }
      }
  }

void rdo_scene_free(scene_t *scn)
  { solid_vec_trim(&scn->sds, 0);
    site_vec_trim(&scn->smp, 0);
    dspmat_trim(&scn->T, 0);
    approx_basis_trim(&scn->bas, 0);
    dspmat_trim(&scn->M, 0);
    finish_vec_trim(&scn->fns, 0);
  }