RendererInfoBase.h

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

#ifndef FNRENDERERINFO_RENDERERINFOBASE_H
#define FNRENDERERINFO_RENDERERINFOBASE_H

#include <FnPluginSystem/FnPluginSystem.h>
#include <FnPluginSystem/FnPlugin.h>

#include <FnAttribute/FnAttribute.h>
#include <FnAttribute/FnGroupBuilder.h>

#include <FnRendererInfo/suite/RendererObjectDefinitions.h>
#include <FnRendererInfo/suite/FnRendererInfoSuite.h>

#include <FnRendererInfo/plugin/RenderMethod.h>
#include <FnRendererInfo/plugin/LiveRenderControlModule.h>
#include <FnRendererInfo/plugin/LiveRenderFilter.h>
#include <FnRendererInfo/FnRendererInfoAPI.h>

#include <FnPlatform/internal/UniquePtr.h>

#include <iostream>
#include <string>
#include <memory>
#include <map>
#include <set>
#include <deque>
#include <utility>

namespace Foundry
{
namespace Katana
{
namespace RendererInfo
{
    class FNRENDERERINFO_API RendererInfoBase
    {
    public:
        RendererInfoBase();
        virtual ~RendererInfoBase() {}

        virtual void configureBatchRenderMethod(RendererInfo::DiskRenderMethod& batchRenderMethod) const = 0;

        virtual void fillRenderMethods(std::vector<RendererInfo::RenderMethod*>& renderMethods) const = 0;

        virtual void fillRendererObjectTypes(std::vector<std::string>& renderObjectTypes,
                                             const std::string& type) const = 0;

        virtual std::string getRendererObjectDefaultType(const std::string& type) const;

        typedef std::pair<std::string, FnAttribute::GroupAttribute> OpDefinition;
        typedef std::deque<OpDefinition> OpDefinitionQueue;

        virtual void fillLiveRenderTerminalOps(OpDefinitionQueue& terminalOps,
                const FnAttribute::GroupAttribute& stateArgs) const {}

        virtual void fillRenderTerminalOps(OpDefinitionQueue& terminalOps,
                const FnAttribute::GroupAttribute& stateArgs) const {}


        virtual void fillRendererObjectNames(std::vector<std::string>& rendererObjectNames,
                                             const std::string& type,
                                             const std::vector<std::string>& typeTags) const = 0;

        virtual std::string getRegisteredRendererName() const = 0;

        virtual std::string getRegisteredRendererVersion() const = 0;

        virtual bool isPresetLocalFileNeeded(const std::string& outputType) const { return false; }

        virtual bool isNodeTypeSupported(const std::string& nodeType) const { return false; }

        virtual bool isPolymeshFacesetSplittingEnabled() const { return false; }

        virtual void fillShaderInputNames(std::vector<std::string>& shaderInputNames,
                                          const std::string& shaderName) const;

        virtual void fillShaderInputTags(std::vector<std::string>& shaderInputTags,
                                         const std::string& shaderName,
                                         const std::string& inputName) const;

        virtual void fillShaderOutputNames(std::vector<std::string>& shaderOutputNames,
                                           const std::string& shaderName) const;

        virtual void fillShaderOutputTags(std::vector<std::string>& shaderOutputTags,
                                          const std::string& shaderName,
                                          const std::string& outputName) const;

        virtual void fillRendererShaderTypeTags(std::vector<std::string>& shaderTypeTags,
                                                const std::string& shaderType) const;

        virtual std::string getRendererCoshaderType() const  { return ""; }

        virtual void buildLiveRenderControlModules(FnAttribute::GroupBuilder& liveRenderControlModules) const {}

        virtual bool buildRendererObjectInfo(FnAttribute::GroupBuilder& rendererObjectInfo,
                                             const std::string& name,
                                             const std::string& type,
                                             const FnAttribute::GroupAttribute inputAttr) const = 0;

        virtual void flushCaches() {}

        std::string getPluginPath() const;

        std::string getPluginRootPath() const;

        void setPluginPath(const std::string& pluginPath);
        void setPluginRootPath(const std::string& pluginRootPath);

        void setKatanaPath(const std::string& katana_path);
        std::string getKatanaPath() const;

        void setTmpPath(const std::string& tmp_path);
        std::string getTmpPath() const;

        // non-virtual implementations to do conversions and cache results from virtual functions above
        FnAttribute::Attribute _getRenderMethods();
        FnAttribute::Attribute _getBatchRenderMethod();
        FnAttribute::Attribute _getRendererObjectNames(const std::string& type,
                                          const std::vector<std::string>& typeTags);
        FnAttribute::Attribute _getRendererObjectTypes(const std::string& type);
        FnAttribute::Attribute _getRendererShaderTypeTags(const std::string& shaderType);
        FnAttribute::Attribute _getRendererCoshaderType();
        FnAttribute::Attribute _getRegisteredRendererName();
        FnAttribute::Attribute _getRegisteredRendererVersion();
        FnAttribute::Attribute _getRendererObjectDefaultType(const std::string& type);

        FnAttribute::Attribute _getShaderInputNames(const std::string& shaderName);
        FnAttribute::Attribute _getShaderInputTags(const std::string& shaderName,
                                      const std::string& inputName);

        FnAttribute::Attribute _getShaderOutputNames(const std::string& shaderName);
        FnAttribute::Attribute _getShaderOutputTags(const std::string& shaderName,
                                       const std::string& outputName);

        FnAttribute::Attribute _getRendererObjectInfo(const std::string& name,
                                         const std::string& typeTag,
                                         const FnAttributeHandle inputData = 0x0);

        void _setTypeTagNameFilter(const std::string& filter,
                                   const std::string& typeTag);

        void _addObjectLocation(const std::string& type,
                                const std::string& location);

        void _clearObjectLocations(const std::string& type);

        void _flushCaches();

        FnAttribute::Attribute _getLiveRenderTerminalOps(
                const FnAttributeHandle stateArgs);
        FnAttribute::Attribute _getRenderTerminalOps(
                const FnAttributeHandle stateArgs);

        static FnPlugStatus                 setHost(FnPluginHost* host);
        static FnPluginHost*                getHost();
        static RendererInfoPluginSuite_v2   createSuite(RendererInfoPluginHandle (*create)());

        static RendererInfoPluginHandle     newRendererInfoPluginHandle(RendererInfoBase* rendererInfoPlugin);

        static unsigned int                 _apiVersion;
        static const char*                  _apiName;

        static void configureBasicRenderObjectInfo(FnAttribute::GroupBuilder& renderObjectInfo,
                                                   const std::string& type,
                                                   const std::vector<std::string>& typeTags,
                                                   const std::string& location,
                                                   const std::string& fullPath,
                                                   int outputType,
                                                   FnAttribute::Attribute containerHints);

    protected:
        typedef std::pair<std::string, int> EnumPair;
        typedef std::vector<EnumPair> EnumPairVector;

        void addRenderObjectParam(FnAttribute::GroupBuilder& renderObjectInfo,
                                  const std::string& name,
                                  int type,
                                  int arraySize,
                                  FnAttribute::Attribute defaultAttr,
                                  FnAttribute::Attribute hintsAttr,
                                  const EnumPairVector& enumValues) const;

        void setShaderParameterMapping(
            FnAttribute::GroupBuilder& renderObjectInfo,
            const std::string& metaName, const std::string& actualName) const;

        void setShaderParameterMapping(
            FnAttribute::GroupBuilder& renderObjectInfo,
            const std::string& metaName,
            const std::vector<std::string>& actualNames) const;

        void getTypeTagsUsingNameFilters(const std::string& name,
                                         std::set<std::string>& typeTags) const;

        bool findTypeTagsInObjectTypeTags(const std::vector<std::string>& typeTags,
                                          const std::set<std::string>& objectTypeTags) const;

        typedef std::map<std::string, std::vector<std::string> > ObjectLocationsMap;

        const ObjectLocationsMap& getAdditionalObjectLocations() const {return _additionalObjectLocations;}
        const std::vector<std::string>& getAdditionalObjectLocations(const std::string& type) const {return _additionalObjectLocations[type];}

    private:

        static FnPluginHost* _host;

        typedef std::map<std::string, std::string> StringMap;
        typedef std::map<std::string, FnAttribute::Attribute> AttributeMap;

        AttributeMap _objectNames;
        AttributeMap _objectTypes;
        AttributeMap _shaderInputNames;
        AttributeMap _shaderInputTags;
        AttributeMap _shaderOutputNames;
        AttributeMap _shaderOutputTags;
        AttributeMap _objectInfo;

        bool _liveRenderControlModulesCached;
        FnAttribute::GroupAttribute _liveRenderControlModules;

        mutable ObjectLocationsMap _additionalObjectLocations;  // (locations by primary type)

        StringMap _typeTagFilters;

        std::string _pluginPath;
        std::string _pluginRootPath;
        std::string _katanaPath;
        std::string _tmpPath;

    };

}
}
}

namespace FnKat = Foundry::Katana;


#define DEFINE_RENDERERINFO_PLUGIN(RENDERERINFO_CLASS)                                          \
                                                                                                \
  FnPlugin RENDERERINFO_CLASS##_plugin;                                                         \
                                                                                                \
  RendererInfoPluginHandle RENDERERINFO_CLASS##_create()                                        \
  {                                                                                             \
        return Foundry::Katana::RendererInfo::RendererInfoBase::newRendererInfoPluginHandle(    \
            RENDERERINFO_CLASS::create());                                                      \
  }                                                                                             \
                                                                                                \
  RendererInfoPluginSuite_v2 RENDERERINFO_CLASS##_suite =                                       \
    Foundry::Katana::RendererInfo::RendererInfoBase::createSuite(RENDERERINFO_CLASS##_create);  \
                                                                                                \
  const void* RENDERERINFO_CLASS##_getSuite()                                                   \
  {                                                                                             \
        return &RENDERERINFO_CLASS##_suite;                                                     \
  }                                                                                             \

struct FNRENDERERINFO_API RendererInfoPluginStruct
{
public:
    RendererInfoPluginStruct(Foundry::Katana::RendererInfo::RendererInfoBase* rendererInfoPlugin) :
    _rendererInfoPlugin(rendererInfoPlugin) { /* Empty */ }
    ~RendererInfoPluginStruct() { /* Empty */ }

    Foundry::Katana::RendererInfo::RendererInfoBase& getRendererInfoPlugin()
    {
        return *_rendererInfoPlugin;
    }

private:
    FnPlatform::internal::UniquePtr<
        Foundry::Katana::RendererInfo::RendererInfoBase>::type
            _rendererInfoPlugin;
};


#endif