examples/code/pointcloud/pointcloud.cpp

/*
Copyright 2014 Autodesk, Inc.  All rights reserved.
Use of this software is subject to the terms of the Autodesk license agreement
provided at the time of installation or download, or which otherwise 
accompanies this software in either electronic or hard copy form.
*/

/*
Beast API Sample: Pointcloud

The purpose of this sample is to demonstrate how to:
 - Create a point cloud
 - Bake a point cloud with a Lua script
 - Read back the results
*/

#define _USE_MATH_DEFINES // for M_PI
#include <math.h>

#include "primitives.h"
#include "textures.h"
#include "xmlwriter.h"

#include <beastapi/beaststring.h>
#include <beastapi/beastutils.h>
#include <beastapi/beastmanager.h>
#include <beastapi/beastscene.h>
#include <beastapi/beastinstance.h>
#include <beastapi/beastlightsource.h>
#include <beastapi/beastcamera.h>
#include <beastapi/beastmaterial.h>
#include <beastapi/beasttarget.h>
#include <beastapi/beastrenderpass.h>
#include <sstream>
#include <fstream>
#include <iostream>

const unsigned int SPHERES = 3;
const float SPHERE_RADIUS = 3.0f;

struct SHData {
    float r[4];
    float g[4];
    float b[4];
};

int main(char argc, char** argv) {
    try {
        ILBManagerHandle bmh;

        // Route errors to stderr
        bex::apiCall(ILBSetLogTarget(ILB_LT_ERROR, ILB_LS_STDERR, 0));

#if defined(WIN32)
        // Route general info to debug output (i.e output window in
        // visual studio)
        bex::apiCall(ILBSetLogTarget(ILB_LT_INFO, ILB_LS_DEBUG_OUTPUT, 0));
#else
        // Route general info to std output
        bex::apiCall(ILBSetLogTarget(ILB_LT_INFO, ILB_LS_NULL, 0));
#endif

        // Setup our beast manager
        bex::apiCall(ILBCreateManager("../../../temp/pointcloud", ILB_CS_LOCAL, bex::getLicenseKey().c_str(), &bmh));

        // Set the path to the Beast binaries
        bex::apiCall(ILBSetBeastPath(bmh, "../../../bin"));

        // Waste the cache from previous runs if present
        bex::apiCall(ILBClearCache(bmh));

        // Create ball and a plane meshes
        std::string sphereMatName = "SphereMaterial";
        std::string boxMatName = "boxMaterial";
        ILBMeshHandle sphereMesh = bex::createSphere(bmh, "Sphere", sphereMatName, 32, 32);
        ILBMeshHandle cornellMesh = bex::createCornellBox(bmh, "Cornell", boxMatName);

        // Create a scene
        ILBSceneHandle scene;
        bex::apiCall(ILBBeginScene(bmh, "BakingScene", &scene));

        // Create an instance of the Cornell Box
        ILBInstanceHandle cornellInstance;
        bex::Matrix4x4 cornellTrans = bex::scaleTranslation(bex::Vec3(10.0f, 10.0f, 10.0f), 
                                                          bex::Vec3(0.0f, 0.0f, 0.0f));
        bex::apiCall(ILBCreateInstance(scene, cornellMesh, "CornellInstance", &cornellTrans, &cornellInstance));

        // Create an area light
        ILBLightHandle light;

        bex::Vec3 pos = bex::Vec3(0.0f, 9.0f, 0.0f);
        bex::Vec3 lookAt(0.0f, 0.0f, 0.0f);
        bex::Matrix4x4 matrix = bex::setAreaLightMatrix(pos, 
            lookAt - pos, 
            bex::Vec3(1.0f, 0.0f, 0.0f), 
            bex::Vec2(2.0f, 2.0f));

        bex::apiCall(ILBCreateAreaLight(scene, 
            _T("Light"), 
            &matrix,
            &bex::ColorRGB(1.0f, 1.0f, 1.0f), 
            &light));

        
        bex::apiCall(ILBSetCastShadows(light, true));
        bex::apiCall(ILBSetShadowSamples(light, 48));

        // Create the spheres on the plane
        const float spherePosRadius = 10.0f - 2.0f*SPHERE_RADIUS;
        for(int i = 0; i < SPHERES; ++i) {
            float x = (bex::frand() - 0.5f) * spherePosRadius * 2.0f;
            float z = (bex::frand() - 0.5f) * spherePosRadius * 2.0f;

            bex::Matrix4x4 trans = bex::scaleTranslation(bex::Vec3(SPHERE_RADIUS, SPHERE_RADIUS, SPHERE_RADIUS), 
                bex::Vec3(x, SPHERE_RADIUS-10.0f, z));
            ILBInstanceHandle tempInstance;
            std::stringstream sphereName;
            sphereName << "SphereInstance_" << i;
            bex::apiCall(ILBCreateInstance(scene, sphereMesh, sphereName.str().c_str(), &trans, &tempInstance));
            bex::apiCall(ILBSetRenderStats(tempInstance, ILB_RS_SHADOW_BIAS, ILB_RSOP_ENABLE));
        }

        // Create the floor material
        ILBMaterialHandle boxMat;
        bex::apiCall(ILBCreateMaterial(scene, boxMatName.c_str(), &boxMat));
        bex::apiCall(ILBSetMaterialUseVertexColors(boxMat, ILB_CC_DIFFUSE));

        // Create the sphere material
        ILBMaterialHandle sphereMat;
        bex::apiCall(ILBCreateMaterial(scene, sphereMatName.c_str(), &sphereMat));
        bex::apiCall(ILBSetMaterialColor(sphereMat, ILB_CC_DIFFUSE, &bex::ColorRGBA(.9f, .9f, .9f, 1.0f)));

        // Setup a camera to render from
        ILBCameraHandle camera;
        bex::Vec3 camPos(0.0f, 0.0f, -20.0f);
        bex::Vec3 camLookAt(0.0f, -3.0f, 0.0f);
        bex::apiCall(ILBCreatePerspectiveCamera(scene, 
            _T("Camera"), 
            &bex::setCameraMatrix(camPos, camLookAt-camPos, bex::Vec3(0.0f, 1.0f, 0.0f)), 
            &camera));

        
        ILBPointCloudHandle pch = bex::createPointCloudGrid(scene, _T("PC1"), 
                                                            bex::Vec3(-9.95f, -9.95f, -9.95f),
                                                            bex::Vec3(9.95f, 9.95f, 9.95f), 10);

        // Finalize the scene
        bex::apiCall(ILBEndScene(scene));

        std::string xmlFileName = "../../data/pointcloud.xml";

        // Create settings xml file
        {
            using namespace bex;
            std::ofstream ofs(xmlFileName.c_str(), std::ios_base::out | std::ios_base::trunc);
            XMLWriter xml(ofs);
            
            {ScopedTag _x(xml, "ILConfig");
                {ScopedTag _x(xml, "AASettings");
                    xml.data("minSampleRate", 0);
                    xml.data("maxSampleRate", 2);
                }
                {ScopedTag _x(xml, "RenderSettings");
                    xml.data("bias", 0.00001f);
                }
                {ScopedTag _x(xml, "GISettings");
                    xml.data("enableGI", true);
                    xml.data("fgRays", 1000);
                    xml.data("fgContrastThreshold", 0.1);
                    xml.data("fgInterpolationPoints", 15);
                    xml.data("primaryIntegrator", "FinalGather");
                    xml.data("secondaryIntegrator", "None");
                }
            }
        }

        ILBJobHandle job;
        bex::apiCall(ILBCreateJob(bmh, _T("TestJob"), scene, xmlFileName.c_str(), &job));

        // Create passes
        ILBRenderPassHandle luaPass;
        bex::apiCall(ILBCreateLuaPass(job, _T("LUA"), "../../data/sh.lua", &luaPass));

        // Create Targets
        ILBTargetHandle pcTarget;
        bex::apiCall(ILBCreatePointCloudTarget(job, _T("pcTarget"), &pcTarget));
        ILBTargetEntityHandle entity;
        bex::apiCall(ILBAddBakePointCloud(pcTarget, pch, &entity));

        // Add pass to targets
        bex::apiCall(ILBAddPassToTarget(pcTarget, luaPass));

        if (!bex::renderJob(job, std::cout, true, false)) {
            return 1;
        } 

        ILBFramebufferHandle fb;
        bex::apiCall(ILBGetVertexbuffer(pcTarget, luaPass, entity, &fb));
        int32 channels;
        bex::apiCall(ILBGetChannelCount(fb, &channels));
        for (int i = 0; i < channels; i++) {
            ILBStringHandle str;
            bex::apiCall(ILBGetChannelName(fb, i, &str));
            std::cout << bex::convertStringHandle(str) << std::endl;
        }
        if (channels != 12) {
            std::cout << "Error: LUA script should output 12 coefficients." << std::endl;
            return 1;
        }
        int32 width, height;
        bex::apiCall(ILBGetResolution(fb, &width, &height));
        std::vector<SHData> results;
        results.resize(width);
        bex::apiCall(ILBReadRegionHDR(fb, 0, 0, width, 1, ILB_CS_ALL, (float*)&results[0]));

        for (int i = 0; i < width; i++) {
            std::cout << "Point " << i << ":" << std::endl;
            for (int sh = 0; sh < 4; sh++) {
                std::cout << "  SH: " << sh << " (" << 
                    results[i].r[sh] << ", " <<
                    results[i].g[sh] << ", " <<
                    results[i].b[sh] << ")" << std::endl;
            } 
        }

        return 0;

    } catch(bex::Exception& ex) {
        ILBStringHandle errorString;
        ILBStringHandle extendedError;
        ILBErrorToString(ex.status, &errorString);
        ILBGetExtendErrorInformation(&extendedError);
        std::cout << "Beast API error" << std::endl;
        std::cout << "Error: " << bex::convertStringHandle(errorString) << std::endl;
        std::cout << "Info: " << bex::convertStringHandle(extendedError) << std::endl;
        return 1;
    }  catch(std::exception& ex) {
        std::cout << "Standard exception" << std::endl;
        std::cout << "Error: " << ex.what() << std::endl;;
        return 1;
    }
}