RenderBase.h

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

#ifndef FNRENDER_RENDERBASE_H
#define FNRENDER_RENDERBASE_H

#include <stdlib.h>

#include "FnAttribute/FnAttribute.h"

#include "FnPluginSystem/FnPlugin.h"
#include "FnPluginSystem/FnPluginSystem.h"

#include "FnRender/FnRenderAPI.h"
#include "FnRender/plugin/DiskRenderOutputProcess.h"
#include "FnRender/suite/FnRenderPluginSuite.h"

#include "FnScenegraphIterator/FnScenegraphIterator.h"

namespace Foundry
{
namespace Katana
{
namespace Render
{
    class FNRENDER_API RenderBase
    {
    public:
        RenderBase(
            FNSCENEGRAPHITERATOR_NAMESPACE::FnScenegraphIterator rootIterator,
            FnAttribute::GroupAttribute arguments) :
                _rootIterator(rootIterator),
                _arguments(arguments)
        {
        }
        virtual ~RenderBase() {}

        virtual int setup() { return 0; }

        virtual int cleanup() { return 0; }

        virtual void setRootIterator(
            FNSCENEGRAPHITERATOR_NAMESPACE::FnScenegraphIterator rootIterator)
        {
            _rootIterator = rootIterator;
        }

        virtual int start() = 0;

        virtual int pause() { return 0; }

        virtual int resume() { return 0; }

        virtual int stop() { return 0; }

        virtual int startLiveEditing() { return 0; }

        virtual int stopLiveEditing() { return 0; }

        virtual int processControlCommand(const std::string & command) { return 0; }

        virtual int queueDataUpdates(FnAttribute::GroupAttribute updateAttribute) { return 0; }

        virtual int applyPendingDataUpdates() { return 0; }

        virtual bool hasPendingDataUpdates() const { return false; }

        virtual void configureDiskRenderOutputProcess(DiskRenderOutputProcess& diskRenderOutputProcess,
                                                      const std::string& outputName,
                                                      const std::string& outputPath,
                                                      const std::string& renderMethodName,
                                                      const float& frameTime) const {}

        // non-virtual implementations to do conversions from virtual functions above
        FnAttribute::Attribute _configureDiskRenderOutputProcess(const std::string& outputName,
                                                    const std::string& outputPath,
                                                    const std::string& renderMethodName,
                                                    const float& frameTime) const;

        static FnPlugStatus setHost(FnPluginHost* host);
        static FnPluginHost* getHost();

        static FnRenderPluginSuite createSuite(FnRenderPluginHandle(*create)(
            FnSgIteratorHandle, FnAttributeHandle));
        static FnRenderPluginHandle newRenderHandle(RenderBase* renderBase);

        static unsigned int _apiVersion;
        static const char*  _apiName;

    protected:
        FNSCENEGRAPHITERATOR_NAMESPACE::FnScenegraphIterator
        getRootIterator() const { return _rootIterator; }

        std::string getRenderMethodName() const;

        std::string findArgument(const std::string& argumentName, const std::string & defaultValue="") const;

        bool applyRenderThreadsOverride(int& numberOfRenderThreads) const;

        std::string getKatanaBasePath() const { return findArgument("katanaRoot"); }

        std::string getKatanaTempDirectory() const { return findArgument("tempDir"); }

        std::string getKatanaHost() const { return findArgument("host"); }

        float getRenderTime() const;

        bool useRenderPassID() const;

        std::string getRenderOutputFile() const { return findArgument("renderOutputFile"); }

        bool isExpandProceduralActive(bool defaultValue=false) const;

        std::string getRenderPluginDirectory() const { return findArgument("pluginDsoPath"); }

        std::string getEnvironmentVariable(const std::string& name) const;

        template <typename T, typename A>
        T getAttrValue(const FnAttribute::Attribute& attr, const T& defaultValue) const
        {
            A typedAttr = attr;
            if(typedAttr.isValid())
                return typedAttr.getValue();

            return defaultValue;
        }

        inline std::string getStringAttrValue(const FnAttribute::Attribute& attr, const std::string & defaultValue = "") const
        {
            return getAttrValue<std::string, FnAttribute::StringAttribute>(attr, defaultValue);
        }

    private:
        FNSCENEGRAPHITERATOR_NAMESPACE::FnScenegraphIterator _rootIterator;
        FnAttribute::GroupAttribute _arguments;

        static FnPluginHost* _host;
    };
}
}
}

namespace FnKat = Foundry::Katana;

// Plugin Registering Macro.
#define DEFINE_RENDER_PLUGIN(RENDER_CLASS)                               \
                                                                         \
    FnPlugin RENDER_CLASS##_plugin;                                      \
                                                                         \
    FnRenderPluginHandle RENDER_CLASS##_create(FnSgIteratorHandle sg,    \
                                               FnAttributeHandle args)   \
    {                                                                    \
        return Foundry::Katana::Render::RenderBase::newRenderHandle(     \
                RENDER_CLASS::create(                                    \
                        Foundry::Katana::FnScenegraphIterator(sg),       \
                        FnAttribute::Attribute::CreateAndRetain(args))); \
    }                                                                    \
                                                                         \
    FnRenderPluginSuite RENDER_CLASS##_suite =                           \
            Foundry::Katana::Render::RenderBase::createSuite(            \
                    RENDER_CLASS##_create);                              \
                                                                         \
    const void* RENDER_CLASS##_getSuite()                                \
    {                                                                    \
        return &RENDER_CLASS##_suite;                                    \
    }

#endif