RenderSettings.h

// Copyright (c) 2013 The Foundry Visionmongers Ltd. All Rights Reserved.

#ifndef FNRENDER_RENDERSETTINGS_H
#define FNRENDER_RENDERSETTINGS_H

#include "FnAttribute/FnAttribute.h"
#include "FnAttribute/FnConstVector.h"

#include "FnRender/FnRenderAPI.h"
#include "FnRender/plugin/CameraSettings.h"

#include "FnScenegraphIterator/FnScenegraphIterator.h"

namespace Foundry
{
namespace Katana
{
namespace Render
{
    class FNRENDER_API RenderSettings
    {
    public:
        RenderSettings(
            FNSCENEGRAPHITERATOR_NAMESPACE::FnScenegraphIterator rootIterator);

        virtual ~RenderSettings() {}

        virtual int initialise();

        struct ChannelBuffer
        {
            std::string channelName;
            std::string bufferId;
        };

        typedef std::map<std::string, ChannelBuffer>    ChannelBuffers;

        typedef std::map<std::string, std::string>      Settings;
        typedef std::map<std::string, FnAttribute::Attribute>        AttributeSettings;

        typedef std::map<std::string, CameraSettings*>  CameraMap;

        struct RenderOutput
        {
            std::string type;                       
            std::string locationType;               
            std::string renderLocation;             
            AttributeSettings rendererSettings;     
            std::string colorSpace;                 
            std::string channel;                    
            std::string fileExtension;              
            std::string cameraName;                 
            AttributeSettings convertSettings;      
            bool clampOutput;                       
            bool colorConvert;                      
            std::string computeStats;               
            std::string tempRenderLocation;         
            std::string tempRenderId;               
            bool enabled;                           
        };

        typedef std::map<std::string, RenderOutput> RenderOutputs;

        bool isValid() const { return _valid; }

        virtual std::string getCameraName() const { return _cameraName; }

        virtual CameraSettings* getCameraSettings() const { return _camera.get(); }

        virtual CameraMap getAdditionalCameras() const {
            // Translate the internal shared pointer map into a map of raw
            // pointers.
            CameraMap result;
            for (CameraMapPtrs::const_iterator it = _additionalCameras.begin();
                    it != _additionalCameras.end(); ++it)
            {
                result[it->first] = it->second.get();
            }

            return result;
        }

        virtual void getCropWindow(float cropWindow[4]) const;

        virtual void getSampleRate(float sampleRate[2]) const;

        virtual std::string getResolutionName() const { return _resolution; }

        virtual int getResolutionX() const { return _xRes; }

        virtual int getResolutionY() const { return _yRes; }

        virtual void getDisplayWindow(int displayWindow[4]) const;

        virtual void getOverscan(int overscan[4]) const;

        virtual void getDataWindow(int dataWindow[4]) const;

        virtual void getRegionOfInterest(int regionOfInterest[4]) const;

        virtual void getRegionOfInterest(float regionOfInterest[4]) const;

        virtual std::string getRenderer() const { return _renderer; }

        virtual bool applyRenderThreads(int& renderThreads) const;

        virtual void getInteractiveOutputs(std::vector<std::string>& outputs) const;

        virtual void getChannelBuffers(ChannelBuffers& channelBuffers);

        virtual RenderOutputs getRenderOutputs() const { return _renderOutputs; }

        virtual std::vector<std::string> getRenderOutputNames(const bool onlyEnabledOutputs = true) const;

        virtual int getNumberOfRenderOutputs() const { return int(_renderOutputs.size()); }

        virtual RenderOutput getRenderOutputByName(const std::string& outputName) const;

        virtual int getMaxTimeSamples() const { return _maxTimeSamples; }

        virtual float getShutterOpen() const { return _shutterOpen; }

        virtual float getShutterClose() const { return _shutterClose; }

        virtual bool isTileRender() const { return _useTileRender; }

        virtual void getWindowOrigin(int windowOrigin[2]) const;

        virtual void getDisplayWindowSize(int displayWindowSize[2]) const;

        virtual void getDataWindowSize(int dataWindowSize[2]) const;

        virtual std::string getRenderFinishedFilename() const
        {
            return _renderFinishedFilename;
        }

    protected:
        // Internal shared-pointer equivallent of a CameraMap
        typedef std::map<std::string, CameraSettings::Ptr> CameraMapPtrs;

        void calculateCropWindow(float calculatedCropWindow[4]) const;
        void processColorOutput(RenderOutput& output, FnAttribute::GroupAttribute rendererSettingsAttr) const;

        FNSCENEGRAPHITERATOR_NAMESPACE::FnScenegraphIterator _rootIterator;
        bool _valid;

        CameraSettings::Ptr _camera;
        CameraMapPtrs _additionalCameras;

        std::string _renderer;
        std::string _cameraName;
        std::string _resolution;
        int _overscan[4];
        int _displayWindow[4];
        int _finalDisplayWindow[4];
        int _dataWindow[4];
        int _finalDataWindow[4];
        float _cropWindow[4];
        float _regionOfInterest[4];
        int _finalRegionOfInterest[4];
        int _xRes, _yRes;
        float _sampleRate[2];
        bool _useTileRender;
        int _tileRender[4];
        FnAttribute::IntAttribute _renderThreadsAttr;

        int _maxTimeSamples;
        float _shutterOpen;
        float _shutterClose;

        std::string _interactiveOutputs;
        ChannelBuffers _buffers;

        RenderOutputs _renderOutputs;
        std::vector<std::string> _renderOutputNames;
        std::vector<std::string> _enabledRenderOutputNames;

        std::string _tempDir;

        std::string _renderFinishedFilename;
    };
}
}
}

namespace FnKat = Foundry::Katana;

#endif