level1.cpp

/*
Create a levelset of the stanford bunny with key rim and fill lights
*/
#include "ImageRender.h"
#include "ImplicitVolumeShapes.h"
#include "ImageRender.h"
#include "Fields.h"
#include "Camera.h"
#include "RectangularGrid.h"
#include "VolumeGrid.h"
#include "SparseGrid.h"
#include "Grids.h"
#include "ArgumentParser.h"
#include "ObjParser.h"
#include "Levelset.h"
#include <iostream>
#include <fstream>
#include <OpenImageIO/imageio.h>

#include <ctime>

using namespace OIIO;

using namespace lux;

int main(int argc, char *argv[])
{
    // ********************** Parse inputs ************************
    ArgumentParser parser(argc, argv);

    if (parser.hasFlag("help"))
    {
        parser.help();
        return 0;
    }

    int fStart = std::stoi(parser.getValue("fstart", "0"));
    int fStop = std::stoi(parser.getValue("fstop", "0"));
    bool cache = parser.hasFlag("cache");

    std::cout << "Settings:\n\tfstart = " << fStart << ",\n\tfstop = " << fStop << ",\n\tcache = " << cache << "\n\n";

    // ****************************Main Code*****************************

    std::string ObjPath = "/home/eport/Documents/spring25/cpsc8190/physically-based-effects/starter/models/bunny/bunny.obj";

    ScalarGrid level;
    level->init(500, 500, 500, 11, 11, 11, Vector(-5.5, -5.5, -5.5));

    Levelset mySDF(level, ObjPath, 5, 10);

    // initialize grid
    ScalarGrid sb;

    // cache the grid if flag is set
    if (cache) {
        size_t pos = ObjPath.rfind(".obj");

        if (pos != std::string::npos) {
            ObjPath.erase(pos);
    
            ObjPath += "-levelset.bin";
        }

        std::ifstream file(ObjPath);

        if (file.is_open()) { // check if there is a file that exists to read it in
            std::cout << "File exists!\n";

            // read in file
            ReadVolumeGrid(*sb, file);

        } else { // create a new levelset if the file path isn't already there
            std::cout << "Levelset does not already exist. Creating a new one...\n";

            mySDF.ProcessA();

            sb = mySDF.getLevelset();

            std::ofstream out(ObjPath);
            WriteVolumeGrid(*sb, out);
        }

    } else { // if cache flag is not set
        mySDF.ProcessA();

        sb = mySDF.getLevelset();
    }

    ScalarField stanfordBunny = gridded(sb);

    Vector rotationAxis(1.0, 0.0, 0.0);
    rotationAxis = rotationAxis * M_PI;
    stanfordBunny = rotate(stanfordBunny, rotationAxis);

    stanfordBunny = translate(stanfordBunny, Vector(0, 1, 0));
    stanfordBunny = scale(stanfordBunny, 4);


    // Color bunny
    ColorField bunny_color = constant(Color(0.0, 0.0, 0.0, 1.0));
    ColorField bunnyColor = constant(Color(1.0, 1.0, 1.0, 1.0));
    bunny_color = bunny_color * mask(-stanfordBunny) + bunnyColor * mask(stanfordBunny);

    // clamp the sphere
    float thickness = 0.05;
    stanfordBunny = clamp(stanfordBunny/constant(thickness),0.0,1.0);


    // Initialize raymarcher
    RayMarcher rm(25, 10, 0.02, 0.5);

    // make key light
    ScalarGrid key;
    key->init(500, 500, 500, 10, 10, 10, Vector(-5, -5, -5));

    rm.AddDSM(Vector(0, -20, 0), Color(1, 0, 0, 1), key, stanfordBunny);

    // make rim 40%
    ScalarGrid rim;
    rim->init(500, 500, 500, 10, 10, 10, Vector(-5, -5, -5));

    rm.AddDSM(Vector(0, -2, -20), Color(0, 0.4, 0, 1), rim, stanfordBunny);

    // make fill 20%
    ScalarGrid fill;
    fill->init(500, 500, 500, 10, 10, 10, Vector(-5, -5, -5));

    rm.AddDSM(Vector(0, 20, 5), Color(0, 0, 0.2, 1), fill, stanfordBunny);

    // create image render object
    ImageRender ir(1920, 1080, 4);
    ir.reset(1920, 1080, 4);

    ir.setRayMarch(rm);
    ir.setMarchType(1);

    Camera cam = Camera();

    // looking down
    // cam.setEyeViewUp(Vector(0,30,0), Vector(0,-1,0), Vector(0,0,1));

    // Look from the side
    // cam.setEyeViewUp(Vector(30,0,0), Vector(-1,0,0), Vector(0,1,0));

    // looking at the front
    cam.setEyeViewUp(Vector(0, 0, 15), Vector(0, 0, -1), Vector(0, 1, 0));

    ir.turntable("bunny", stanfordBunny, bunny_color, cam, fStart, fStop);

    return 0;
}