Encoder.h

/*
  COPYRIGHT (c) 2012-2024 Esri R&D Center Zurich
  TRADE SECRETS: ESRI PROPRIETARY AND CONFIDENTIAL
  Unpublished material - all rights reserved under the
  Copyright Laws of the United States and applicable international
  laws, treaties, and conventions.

  For additional information, contact:
  Environmental Systems Research Institute, Inc.
  Attn: Contracts and Legal Services Department
  380 New York Street
  Redlands, California, 92373
  USA

  email: contracts@esri.com
*/

#ifndef PRTX_ENCODER_H_
#define PRTX_ENCODER_H_

#include "prtx/prtx.h"
#include "prtx/Content.h"
#include "prtx/Log.h"
#include "prtx/Extension.h"
#include "prtx/GenerateContext.h"

#include "prt/AttributeMap.h"
#include "prt/InitialShape.h"
#include "prt/Callbacks.h"
#include "prt/ContentType.h"
#include "prt/Status.h"
#include "prt/CGAErrorLevel.h"

#include <vector>
#include <memory>

#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning (disable : 4251) // 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
#endif


namespace prtx {


class Encoder;
using EncoderPtr = std::shared_ptr<Encoder>;
using EncoderPtrVector = std::vector<EncoderPtr>;

class PRTX_EXPORTS_API Encoder : public Extension {
public:
    Encoder() = delete;

    Encoder(
            const std::wstring&         id,             
            const prt::AttributeMap*    options,        
            prt::Callbacks*             callbacks       
    );

    virtual ~Encoder() = default;

    virtual void init(
            GenerateContext& context                    
    );

    virtual bool validate(
            GenerateContext& context,                   
            size_t initialShapeIndex                    
    ) const;

    virtual void encode(
            GenerateContext& context,                   
            size_t initialShapeIndex                    
    );

    virtual void encode(
            const prtx::ContentPtrVector& content       
    );

    virtual void finish(
            prtx::GenerateContext& context              
    );

    virtual ExtensionType getExtensionType() const final override {
        return Extension::ET_ENCODER;
    }

    const std::wstring& getID() const;

protected:
    const prt::AttributeMap* getOptions() const;

    prt::Callbacks* getCallbacks() const;

private:
    std::wstring                mID;
    const prt::AttributeMap*    mOptions;
    prt::Callbacks*             mCallbacks;
};


class PRTX_EXPORTS_API GeometryEncoder : public Encoder {
public:
    GeometryEncoder() = delete;
    GeometryEncoder(const std::wstring& id, const prt::AttributeMap* options, prt::Callbacks* callbacks) : Encoder(id, options, callbacks) { }
    virtual ~GeometryEncoder() = default;

    virtual prt::ContentType getContentType() const final override { 
        return prt::CT_GEOMETRY;
    }
};


class PRTX_EXPORTS_API MaterialEncoder : public Encoder {
public:
    MaterialEncoder() = delete;
    MaterialEncoder(const std::wstring& id, const prt::AttributeMap* options, prt::Callbacks* callbacks) : Encoder(id, options, callbacks) { }
    virtual ~MaterialEncoder() = default;

    virtual prt::ContentType getContentType() const final override {
        return prt::CT_MATERIAL;
    }
};


class PRTX_EXPORTS_API TextureEncoder : public Encoder {
public:
    TextureEncoder() = delete;
    TextureEncoder(const std::wstring& id, const prt::AttributeMap* options, prt::Callbacks* callbacks) : Encoder(id, options, callbacks) { }
    virtual ~TextureEncoder() = default;

    virtual prt::ContentType getContentType() const {
        return prt::CT_TEXTURE;
    }
};


} // namespace prtx


#ifdef _MSC_VER
#   pragma warning(pop)
#endif


#endif /* PRTX_ENCODER_H_ */