luxcore.h

Go to the documentation of this file.

/***************************************************************************
 * Copyright 1998-2018 by authors (see AUTHORS.txt)                        *
 *                                                                         *
 *   This file is part of LuxCoreRender.                                   *
 *                                                                         *
 * Licensed under the Apache License, Version 2.0 (the "License");         *
 * you may not use this file except in compliance with the License.        *
 * You may obtain a copy of the License at                                 *
 *                                                                         *
 *     http://www.apache.org/licenses/LICENSE-2.0                          *
 *                                                                         *
 * Unless required by applicable law or agreed to in writing, software     *
 * distributed under the License is distributed on an "AS IS" BASIS,       *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*
 * See the License for the specific language governing permissions and     *
 * limitations under the License.                                          *
 ***************************************************************************/

#ifndef _LUXCORE_H
#define _LUXCORE_H

#include <cstddef>
#include <stdexcept>
#include <string>

#include <luxcore/cfg.h>
#include <luxrays/utils/exportdefs.h>
#include <luxrays/utils/properties.h>
#include <luxrays/utils/cyhair/cyHairFile.h>

namespace luxcore {

CPP_EXPORT CPP_API void (*LuxCore_LogHandler)(const char *msg); // LuxCore Log Handler

#define LC_LOG(a) { if (luxcore::LuxCore_LogHandler) { std::stringstream _LUXCORE_LOG_LOCAL_SS; _LUXCORE_LOG_LOCAL_SS << a; luxcore::LuxCore_LogHandler(_LUXCORE_LOG_LOCAL_SS.str().c_str()); } }

CPP_EXPORT CPP_API void Init(void (*LogHandler)(const char *) = NULL);

CPP_EXPORT CPP_API void SetLogHandler(void (*LogHandler)(const char *) = NULL);

CPP_EXPORT CPP_API void ParseLXS(const std::string &fileName, luxrays::Properties &renderConfig, luxrays::Properties &scene);

CPP_EXPORT CPP_API void KernelCacheFill(const luxrays::Properties &config, void (*ProgressHandler)(const size_t, const size_t) = NULL);

CPP_EXPORT CPP_API luxrays::Properties GetPlatformDesc();

CPP_EXPORT CPP_API luxrays::Properties GetOpenCLDeviceDescs();

class RenderSession;
class RenderState;

CPP_EXPORT class CPP_API Film {
public:
        typedef enum {
                // This list must be aligned with slg::FilmOutputs::FilmOutputType
                OUTPUT_RGB,
                OUTPUT_RGBA,
                OUTPUT_RGB_IMAGEPIPELINE,
                OUTPUT_RGBA_IMAGEPIPELINE,
                OUTPUT_ALPHA,
                OUTPUT_DEPTH,
                OUTPUT_POSITION,
                OUTPUT_GEOMETRY_NORMAL,
                OUTPUT_SHADING_NORMAL,
                OUTPUT_MATERIAL_ID,
                OUTPUT_DIRECT_DIFFUSE,
                OUTPUT_DIRECT_GLOSSY,
                OUTPUT_EMISSION,
                OUTPUT_INDIRECT_DIFFUSE,
                OUTPUT_INDIRECT_GLOSSY,
                OUTPUT_INDIRECT_SPECULAR,
                OUTPUT_MATERIAL_ID_MASK,
                OUTPUT_DIRECT_SHADOW_MASK,
                OUTPUT_INDIRECT_SHADOW_MASK,
                OUTPUT_RADIANCE_GROUP,
                OUTPUT_UV,
                OUTPUT_RAYCOUNT,
                OUTPUT_BY_MATERIAL_ID,
                OUTPUT_IRRADIANCE,
                OUTPUT_OBJECT_ID,
                OUTPUT_OBJECT_ID_MASK ,
                OUTPUT_BY_OBJECT_ID,
                OUTPUT_FRAMEBUFFER_MASK,
                OUTPUT_SAMPLECOUNT,
                OUTPUT_CONVERGENCE
        } FilmOutputType;

        typedef enum {
                // This list must be aligned with slg::Film::FilmChannelType
                CHANNEL_RADIANCE_PER_PIXEL_NORMALIZED = 1 << 0,
                CHANNEL_RADIANCE_PER_SCREEN_NORMALIZED = 1 << 1,
                CHANNEL_ALPHA = 1 << 2,
                CHANNEL_IMAGEPIPELINE = 1 << 3,
                CHANNEL_DEPTH = 1 << 4,
                CHANNEL_POSITION = 1 << 5,
                CHANNEL_GEOMETRY_NORMAL = 1 << 6,
                CHANNEL_SHADING_NORMAL = 1 << 7,
                CHANNEL_MATERIAL_ID = 1 << 8,
                CHANNEL_DIRECT_DIFFUSE = 1 << 9,
                CHANNEL_DIRECT_GLOSSY = 1 << 10,
                CHANNEL_EMISSION = 1 << 11,
                CHANNEL_INDIRECT_DIFFUSE = 1 << 12,
                CHANNEL_INDIRECT_GLOSSY = 1 << 13,
                CHANNEL_INDIRECT_SPECULAR = 1 << 14,
                CHANNEL_MATERIAL_ID_MASK = 1 << 15,
                CHANNEL_DIRECT_SHADOW_MASK = 1 << 16,
                CHANNEL_INDIRECT_SHADOW_MASK = 1 << 17,
                CHANNEL_UV = 1 << 18,
                CHANNEL_RAYCOUNT = 1 << 19,
                CHANNEL_BY_MATERIAL_ID = 1 << 20,
                CHANNEL_IRRADIANCE = 1 << 21,
                CHANNEL_OBJECT_ID = 1 << 22,
                CHANNEL_OBJECT_ID_MASK = 1 << 23,
                CHANNEL_BY_OBJECT_ID = 1 << 24,
                CHANNEL_FRAMEBUFFER_MASK = 1 << 25,
                CHANNEL_SAMPLECOUNT = 1 << 26,
                CHANNEL_CONVERGENCE = 1 << 27
        } FilmChannelType;

        virtual ~Film();

        static Film *Create(const std::string &fileName);
        static Film *Create(const luxrays::Properties &props,
                        const bool hasPixelNormalizedChannel,
                        const bool hasScreenNormalizedChannel);

        virtual unsigned int GetWidth() const = 0;
        virtual unsigned int GetHeight() const = 0;
        virtual luxrays::Properties GetStats() const = 0;
        virtual float GetFilmY(const unsigned int imagePipelineIndex = 0) const = 0;
        virtual void Clear() = 0;
        virtual void AddFilm(const Film &film) = 0;
        virtual void AddFilm(const Film &film,
                const unsigned int srcOffsetX, const unsigned int srcOffsetY,
                const unsigned int srcWidth, const unsigned int srcHeight,
                const unsigned int dstOffsetX, const unsigned int dstOffsetY) = 0;
        virtual void SaveOutputs() const = 0;

        virtual void SaveOutput(const std::string &fileName, const FilmOutputType type, const luxrays::Properties &props) const = 0;

        virtual void SaveFilm(const std::string &fileName) const = 0;

        virtual double GetTotalSampleCount() const = 0;
        virtual size_t GetOutputSize(const FilmOutputType type) const = 0;
        virtual bool HasOutput(const FilmOutputType type) const = 0;
        virtual unsigned int GetOutputCount(const FilmOutputType type) const = 0;
        virtual unsigned int GetRadianceGroupCount() const = 0;
        template<class T> void GetOutput(const FilmOutputType type, T *buffer, const unsigned int index = 0) {
                throw std::runtime_error("Called Film::GetOutput() with wrong type");
        }
        virtual bool HasChannel(const FilmChannelType type) const = 0;
        virtual unsigned int GetChannelCount(const FilmChannelType type) const = 0;
        template<class T> const T *GetChannel(const FilmChannelType type, const unsigned int index = 0) {
                throw std::runtime_error("Called Film::GetChannel() with wrong type");
        }
        virtual void Parse(const luxrays::Properties &props) = 0;
        virtual void DeleteAllImagePipelines() = 0;

protected:
        virtual void GetOutputFloat(const FilmOutputType type, float *buffer, const unsigned int index) = 0;
        virtual void GetOutputUInt(const FilmOutputType type, unsigned int *buffer, const unsigned int index) = 0;
        
        virtual const float *GetChannelFloat(const FilmChannelType type, const unsigned int index) = 0;
        virtual const unsigned int *GetChannelUInt(const FilmChannelType type, const unsigned int index) = 0;
};

template<> CPP_API void Film::GetOutput<float>(const FilmOutputType type, float *buffer, const unsigned int index);
template<> CPP_API void Film::GetOutput<unsigned int>(const FilmOutputType type, unsigned int *buffer, const unsigned int index);
template<> CPP_API const float *Film::GetChannel<float>(const FilmChannelType type, const unsigned int index);
template<> CPP_API const unsigned int *Film::GetChannel<unsigned int>(const FilmChannelType type, const unsigned int index);

class Scene;

CPP_EXPORT class CPP_API Camera {
public:
        typedef enum {
                // This list must be aligned with slg::Camera::CameraType
                PERSPECTIVE,
                ORTHOGRAPHIC,
                STEREO,
                ENVIRONMENT
        } CameraType;

        virtual ~Camera();

        virtual const CameraType GetType() const = 0;
        virtual void Translate(const float x, const float y, const float z) const = 0;
        virtual void TranslateLeft(const float t) const = 0;
        virtual void TranslateRight(const float t) const = 0;
        virtual void TranslateForward(const float t) const = 0;
        virtual void TranslateBackward(const float t) const = 0;

        virtual void Rotate(const float angle, const float x, const float y, const float z) const = 0;
        virtual void RotateLeft(const float angle) const = 0;
        virtual void RotateRight(const float angle) const = 0;
        virtual void RotateUp(const float angle) const = 0;
        virtual void RotateDown(const float angle) const = 0;
};

CPP_EXPORT class CPP_API Scene {
public: 
        typedef enum {
                // This list must be aligned with slg::ImageMapStorage::ChannelSelectionType
                DEFAULT,
                RED,
                GREEN,
                BLUE,
                ALPHA,
                MEAN,
                WEIGHTED_MEAN,
                RGB
        } ChannelSelectionType;
        typedef enum {
                // This list must be aligned with slg::ImageMapStorage::WrapType
                REPEAT,
                BLACK,
                WHITE,
                CLAMP
        } WrapType;
        typedef enum {
                // This list must be aligned with slg::StrendsShape::TessellationType
                TESSEL_RIBBON,
                TESSEL_RIBBON_ADAPTIVE,
                TESSEL_SOLID,
                TESSEL_SOLID_ADAPTIVE
        } StrandsTessellationType;

        static Scene *Create(const float imageScale = 1.f);
        static Scene *Create(const luxrays::Properties &props, const float imageScale = 1.f);
        static Scene *Create(const std::string &fileName, const float imageScale = 1.f);

        virtual ~Scene();

        virtual void GetBBox(float min[3], float max[3]) const = 0;
        virtual const Camera &GetCamera() const = 0;
        template<class T> void DefineImageMap(const std::string &imgMapName,
                        T *pixels, const float gamma, const unsigned int channels,
                        const unsigned int width, const unsigned int height,
                        ChannelSelectionType selectionType = DEFAULT,
                        WrapType wrapType = REPEAT) {
                throw std::runtime_error("Called Scene::DefineImageMap() with wrong type");
        }
        virtual bool IsImageMapDefined(const std::string &imgMapName) const = 0;
        virtual void SetDeleteMeshData(const bool v) = 0;
        virtual void DefineMesh(const std::string &meshName,
                const long plyNbVerts, const long plyNbTris,
                float *p, unsigned int *vi, float *n, float *uv,
                float *cols, float *alphas) = 0;
        virtual void SaveMesh(const std::string &meshName, const std::string &fileName) = 0;
        virtual void DefineStrands(const std::string &shapeName, const luxrays::cyHairFile &strandsFile,
                const StrandsTessellationType tesselType,
                const unsigned int adaptiveMaxDepth, const float adaptiveError,
                const unsigned int solidSideCount, const bool solidCapBottom, const bool solidCapTop,
                const bool useCameraPosition) = 0;
        virtual bool IsMeshDefined(const std::string &meshName) const = 0;
        virtual bool IsTextureDefined(const std::string &texName) const = 0;
        virtual bool IsMaterialDefined(const std::string &matName) const = 0;
        virtual const unsigned int GetLightCount() const = 0;
        virtual const unsigned int GetObjectCount() const = 0;

        virtual void Parse(const luxrays::Properties &props) = 0;

        virtual void DuplicateObject(const std::string &srcObjName, const std::string &dstObjName,
                        const float *transMat) = 0;
        virtual void DuplicateObject(const std::string &srcObjName, const std::string &dstObjNamePrefix,
                        const unsigned int count, const float *transMat) = 0;
        virtual void DuplicateObject(const std::string &srcObjName, const std::string &dstObjName,
                        const unsigned int steps, const float *times, const float *transMat) = 0;
        virtual void DuplicateObject(const std::string &srcObjName, const std::string &dstObjNamePrefix,
                        const unsigned int count, const unsigned int steps, const float *times, const float *transMat) = 0;
        virtual void UpdateObjectTransformation(const std::string &objName, const float *transMat) = 0;
        virtual void UpdateObjectMaterial(const std::string &objName, const std::string &matName) = 0;
        
        virtual void DeleteObject(const std::string &objName) = 0;

        virtual void DeleteLight(const std::string &lightName) = 0;

        virtual void RemoveUnusedImageMaps() = 0;
        virtual void RemoveUnusedTextures() = 0;
        virtual void RemoveUnusedMaterials() = 0;
        virtual void RemoveUnusedMeshes() = 0;

        virtual const luxrays::Properties &ToProperties() const = 0;
        virtual void Save(const std::string &fileName) const = 0;

        static float *AllocVerticesBuffer(const unsigned int meshVertCount);
        static unsigned int *AllocTrianglesBuffer(const unsigned int meshTriCount);

protected:
        virtual void DefineImageMapUChar(const std::string &imgMapName,
                        unsigned char *pixels, const float gamma, const unsigned int channels,
                        const unsigned int width, const unsigned int height,
                        ChannelSelectionType selectionType, WrapType wrapType) = 0;
        virtual void DefineImageMapHalf(const std::string &imgMapName,
                        unsigned short *pixels, const float gamma, const unsigned int channels,
                        const unsigned int width, const unsigned int height,
                        ChannelSelectionType selectionType, WrapType wrapType) = 0;
        virtual void DefineImageMapFloat(const std::string &imgMapName,
                        float *pixels, const float gamma, const unsigned int channels,
                        const unsigned int width, const unsigned int height,
                        ChannelSelectionType selectionType, WrapType wrapType) = 0;
};

template<> void CPP_API Scene::DefineImageMap<unsigned char>(const std::string &imgMapName,
        unsigned char *pixels, const float gamma, const unsigned int channels,
        const unsigned int width, const unsigned int height,
        Scene::ChannelSelectionType selectionType, Scene::WrapType wrapType);
template<> void CPP_API Scene::DefineImageMap<unsigned short>(const std::string &imgMapName,
        unsigned short *pixels, const float gamma, const unsigned int channels,
        const unsigned int width, const unsigned int height,
        Scene::ChannelSelectionType selectionType, Scene::WrapType wrapType);
template<> void CPP_API Scene::DefineImageMap<float>(const std::string &imgMapName,
        float *pixels, const float gamma, const unsigned int channels,
        const unsigned int width, const unsigned int height,
        Scene::ChannelSelectionType selectionType, Scene::WrapType wrapType);

CPP_EXPORT class CPP_API RenderConfig {
public:
        static RenderConfig *Create(const luxrays::Properties &props, Scene *scene = NULL);
        static RenderConfig *Create(const std::string &fileName);
        static RenderConfig *Create(const std::string &fileName, RenderState **startState, Film **startFilm);

        virtual ~RenderConfig();

        virtual const luxrays::Properties &GetProperties() const = 0;
        virtual const luxrays::Property GetProperty(const std::string &name) const = 0;

        virtual const luxrays::Properties &ToProperties() const = 0;

        virtual Scene &GetScene() const = 0;

        virtual void Parse(const luxrays::Properties &props) = 0;
        virtual void Delete(const std::string &prefix) = 0;

        virtual bool GetFilmSize(unsigned int *filmFullWidth, unsigned int *filmFullHeight,
                unsigned int *filmSubRegion) const = 0;

        virtual void DeleteSceneOnExit() = 0;

        virtual void Save(const std::string &fileName) = 0;
        virtual void Export(const std::string &dirName) = 0;

        static const luxrays::Properties &GetDefaultProperties();
};

CPP_EXPORT class CPP_API RenderState {
public:
        static RenderState *Create(const std::string &fileName);
        virtual ~RenderState();
        
        virtual void Save(const std::string &fileName) const = 0;
};

CPP_EXPORT class CPP_API RenderSession {
public:
        static RenderSession *Create(const RenderConfig *config, RenderState *startState = NULL, Film *startFilm = NULL);

        static RenderSession *Create(const RenderConfig *config, const std::string &startStateFileName, const std::string &startFilmFileName);

        virtual ~RenderSession();

        virtual const RenderConfig &GetRenderConfig() const = 0;

        virtual RenderState *GetRenderState() = 0;

        virtual void Start() = 0;
        virtual void Stop() = 0;

        virtual bool IsStarted() const = 0;

        virtual void BeginSceneEdit() = 0;
        virtual void EndSceneEdit() = 0;

        virtual bool IsInSceneEdit() const = 0;

        virtual void Pause() = 0;

        virtual void Resume() = 0;

        virtual bool IsInPause() const = 0;

        virtual bool HasDone() const = 0;

        virtual void WaitForDone() const = 0;

        virtual void WaitNewFrame() = 0;

        virtual Film &GetFilm() = 0;

        virtual void UpdateStats() = 0;
        virtual const luxrays::Properties &GetStats() const = 0;

        virtual void Parse(const luxrays::Properties &props) = 0;

        virtual void SaveResumeFile(const std::string &fileName) = 0;
};

}

#endif  /* _LUXCORE_H */