object.h

/*
    This file is part of Nori, a simple educational ray tracer
 
    Copyright (c) 2015 by Wenzel Jakob, Romain Prévost
 
    Nori is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License Version 3
    as published by the Free Software Foundation.
 
    Nori is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
#if !defined(__NORI_OBJECT_H)
#define __NORI_OBJECT_H
 
#include <nori/proplist.h>
 
NORI_NAMESPACE_BEGIN
 
class NoriObject {
public:
    enum EClassType {
        EScene = 0,
        EMesh,
        ETexture,
        EBSDF,
        EPhaseFunction,
        EEmitter,
        EMedium,
        ECamera,
        EIntegrator,
        ESampler,
        ETest,
        EReconstructionFilter,
        EClassTypeCount
    };
 
    static std::string classTypeName(EClassType type) {
        switch (type) {
            case EScene:      return "scene";
            case EMesh:       return "shape";
            case ETexture:    return "texture";
            case EBSDF:       return "bsdf";
            case EEmitter:    return "emitter";
            case ECamera:     return "camera";
            case EIntegrator: return "integrator";
            case ESampler:    return "sampler";
            case ETest:       return "test";
            default:          return "<unknown>";
        }
    }
 
    virtual ~NoriObject() { }
 
    virtual EClassType getClassType() const = 0;
 
    virtual void addChild(NoriObject *child) {
        throw NoriException(
                "NoriObject::addChild() is not implemented for objects of type '%s'!",
                classTypeName(getClassType()));
    }
 
    virtual void setParent(NoriObject *parent) { /* Do nothing */ }
 
    virtual void activate() { /* Do nothing */ }
 
    virtual std::string toString() const = 0;
 
 
    void setIdName(const std::string & name) { m_idname = name; }
    const std::string & getIdName() const { return m_idname; }
 
protected:
    std::string m_idname;
 
};
 
class NoriObjectFactory {
public:
    typedef std::function<NoriObject *(const PropertyList &)> Constructor;
 
    static void registerClass(const std::string &name, const Constructor &constr);
 
    static NoriObject *createInstance(const std::string &name,
            const PropertyList &propList) {
        if (!m_constructors || m_constructors->find(name) == m_constructors->end())
            throw NoriException("A constructor for class \"%s\" could not be found!", name);
        return (*m_constructors)[name](propList);
    }
 
    static void printRegisteredClasses() {
        if(m_constructors)
            for(auto v : *m_constructors)
                std::cout << v.first << std::endl;
    }
 
private:
    static std::map<std::string, Constructor> *m_constructors;
};
 
#define NORI_REGISTER_CLASS(cls, name) \
    cls *cls ##_create(const PropertyList &list) { \
        return new cls(list); \
    } \
    static struct cls ##_{ \
        cls ##_() { \
            NoriObjectFactory::registerClass(name, cls ##_create); \
        } \
    } cls ##__NORI_;
 
#define NORI_REGISTER_TEMPLATED_CLASS(cls, T, name) \
    cls<T> * cls ##_## T ##_create(const PropertyList &list) { \
        return new cls<T>(list); \
    } \
    static struct cls ##_## T ##_{ \
        cls ##_## T ##_() { \
            NoriObjectFactory::registerClass(name, cls ##_## T ##_create); \
        } \
    } cls ## T ##__NORI_;
 
NORI_NAMESPACE_END
 
#endif /* __NORI_OBJECT_H */