PhxGraphicsEngine.h

Go to the documentation of this file.

#ifndef PHX_GRAPHICS_ENGINE_H
#define PHX_GRAPHICS_ENGINE_H

#include <Phx/PhxConfig.h>
#include <Phx/PhxTypes.h>
#include <Phx/Core/PhxCore.h>
#include <Phx/Core/PhxNamedInterface.h>
#include <Phx/Util/PhxMatrix.h>
#include <Phx/Util/PhxQuaternion.h>
#include <Phx/Util/PhxColor.h>
#include <Phx/Graphics/PhxWindowInformation.h>

namespace Phx {


  class GraphicsEngine : public NamedInterface {
  public:
    static const NamedInterface::Type  INTERFACE_TYPE;
    static const String                INTERFACE_TYPE_NAME;

    static const NamedInterface::Identifier GRAPHICS_ENGINE_IDENTIFIER;
    static const String                     GRAPHICS_ENGINE_NAME;

    class Node;

    // Scene element types
    class Light;
    class PointLight;
    class DirectionalLight;
    class SpotLight;
    class Geometry;
    class BillboardGroup;
    class Billboard;
    class Camera;
    class SkyBox;
    class TerrainGeometry;

    // Descriptions for various elements
    class GraphicsEngineDescription;
    class GeometryDescription;
    class BillboardGroupDescription;
    class BillboardDescription;
    class MeshDescription;
    class MaterialDescription;
    class LightDescription;
    class PointLightDescription;
    class DirectionalLightDescription;
    class SpotLightDescription;
    class TerrainGeometryDescription;

    virtual Ptr<Node> newNode(const String& name = "") = 0;

    virtual Ptr<Node> skyBoxNode() = 0;

    virtual Ptr<WindowInformation> windowInformation(void) const = 0;

    // ------- primary client interface --------

    // Camera control
    virtual String currentCamera(void) const = 0;
    virtual void currentCamera(const String& cameraName) = 0;
    // std::vector<String> cameraNames(void) const = 0;

    // Ambrient light control
    virtual void setAmbrientLight(RgbaColor color) = 0;

    // Fog control
    virtual void setFog(void) = 0;

    virtual void setFog(RgbaColor color, double start, double end) = 0;

    virtual void setFog(RgbaColor color, double density) = 0;
  };

  class GraphicsEngine::Node : public LockedPtrInterface<Node> {
  public:

    virtual Ptr<Node> newNode(const String& name = "") = 0;


    // Scene graph element interfaces
    virtual Ptr<PointLight> newPointLight(const String& name = "") = 0;
    virtual Ptr<DirectionalLight> newDirectionalLight(const String& name = "") = 0;
    virtual Ptr<SpotLight> newSpotLight(const String& name = "") = 0;

    virtual Ptr<PointLight> newPointLight(const Ptr<const PointLightDescription>& description,
                                          const String& name = "") = 0;
    virtual Ptr<DirectionalLight> newDirectionalLight(const Ptr<const DirectionalLightDescription>& description,
                                                      const String& name = "") = 0;
    virtual Ptr<SpotLight> newSpotLight(const Ptr<const SpotLightDescription>& description,
                                        const String& name = "") = 0;

    virtual Ptr<SkyBox> newSkyBox(const Ptr<const GeometryDescription>& description,
                                      const String& name = "") = 0;

    virtual Ptr<BillboardGroup> newBillboardGroup(const Ptr<const BillboardGroupDescription>& description,
                                      const String& name = "") = 0;
    virtual Ptr<Geometry> newGeometry(const String& name = "") = 0;
    
    virtual Ptr<Geometry> newGeometry(const Ptr<const GeometryDescription>& description,
                                      const String& name = "") = 0;

    virtual Ptr<Camera> newCamera(const String& cameraName) = 0;

    virtual Ptr<TerrainGeometry> newTerrainGeometry(const Ptr<const TerrainGeometryDescription>& description,
                                                    const String& terrainName) = 0;

    virtual void position(const Vector3& position) = 0;

    virtual void orientation(const Quaternion& orientation) = 0;

    const Vector3& position(void) const { return mPosition; }

    const Quaternion& orientation(void) const { return mOrientation; }

    const String& name(void) const { return mName; }

  protected:
    void setName(const String& name) { mName = name; }
    void setPosition(const Vector3& position) { mPosition = position; }
    void setOrientation(const Quaternion& orientation) { mOrientation = orientation; }

  private:
    String     mName;
    Vector3    mPosition;
    Quaternion mOrientation;
  };


  class GraphicsEngine::Geometry : public LockedPtrInterface<Geometry> {
  public:

    virtual void mesh(const Ptr<const MeshDescription>& mesh) = 0;

    virtual Ptr<const MeshDescription> mesh(void) const = 0;

    virtual void material(uint32_t index,
                          const Ptr<const MaterialDescription>& material) = 0;

    virtual Ptr<const MaterialDescription> material(uint32_t index) const = 0;

    const String& name(void) const { return mName; }

  protected:
    void setName(const String& name) { mName = name; }
  private:
    String mName;
  };

  class GraphicsEngine::Camera : public LockedPtrInterface<Camera> {
  public:
    virtual double aspectRatio(void) const = 0;

    virtual void horizontalFieldOfView(double fovRadians) = 0;
    virtual double horizontalFieldOfView(void) const = 0;

    /*    virtual void verticalFieldOfView(double fovRadians) = 0;
    virtual double verticalFieldOfView(void) const = 0;

    virtual void focalLength(double focalLength) = 0;
    virtual double focalLength(void) const = 0;*/

    const String& name(void) const { return mName; }

  protected:
    void setName(const String& name) { mName = name; }
  private:
    String mName;
  };


  class GraphicsEngine::Light : public LockedPtrInterface<Camera> {
  public:
    virtual void specular(const RgbaColor& specular) = 0;
    
    virtual RgbaColor specular(void) const = 0;
    
    virtual void diffuse(const RgbaColor& diffuse) = 0;
    
    virtual RgbaColor diffuse(void) const = 0;

    // virtual double void attenuationRange(void) = 0;
    // double void attenuationRange(double attenuationRange) = 0;
    // virtual double void attenuationConstant(void) = 0;
    // double void attenuationConstant(double attenuationConstant) = 0;
    // virtual double void attenuationLinear(void) = 0;
    // double void attenuationLinear(double attenuationLinear) = 0;
    // virtual double void attenuationQuadratic(void) = 0;
    // double void attenuationQuadratic(double attenuationQuadratic) = 0;

    const String& name(void) const { return mName; }

  protected:
    void setName(const String& name) { mName = name; }
  private:
    String mName;
  };

  class GraphicsEngine::PointLight : public GraphicsEngine::Light {
  public:
  };

  class GraphicsEngine::DirectionalLight : public GraphicsEngine::Light {
  public:
    virtual void direction(const Vector3& direction) = 0;
    virtual Vector3 direction(void) const = 0;
  };

  class GraphicsEngine::SpotLight : public GraphicsEngine::Light {
  public:
    virtual void direction(const Vector3& direction) = 0;
    virtual Vector3 direction(void) const = 0;

    virtual void innerAngle(double innerAngle) = 0;
    virtual double innerAngle(void) const = 0;

    virtual void outerAngle(double outerAngle) = 0;
    virtual double outerAngle(void) const = 0;
  };

  class GraphicsEngine::SkyBox : public LockedPtrInterface<Geometry>{
  public:
    virtual void mesh(const Ptr<const MeshDescription>& mesh) = 0;

    virtual Ptr<const MeshDescription> mesh(void) const = 0;

    virtual void material(uint32_t index,
                          const Ptr<const MaterialDescription>& material) = 0;

    virtual Ptr<const MaterialDescription> material(uint32_t index) const = 0;

    const String& name(void) const { return mName; }

    virtual void setCustomParameter(int subEntity, int index, Vector4 parameters) = 0;

  protected:
    void setName(const String& name) { mName = name; }
  private:
    String mName;
  };

  class GraphicsEngine::BillboardGroup : public LockedPtrInterface<BillboardGroup>{
  public:
    virtual void material(const Ptr<const MaterialDescription>& material) = 0;

    virtual Ptr<const MaterialDescription> material() const = 0;
    
    virtual void billboard(int index, const Ptr<const BillboardDescription>& billboard) = 0;
    virtual Ptr<const BillboardDescription> billboard(int index) const = 0;

    const String& name(void) const { return mName; }

    virtual void setCustomParameter(int index, Vector4 parameters) = 0;

  protected:
    void setName(const String& name) { mName = name; }
  private:
    String mName;
  };
  
  class GraphicsEngine::Billboard : public LockedPtrInterface<BillboardGroup>{
    public:
      virtual void offset(Vector3 offset) = 0;
      virtual void offset(double x, double y, double z) = 0;
      virtual Vector3 offset(void) = 0;

      virtual void dimentions(Vector2 dim) = 0;
      virtual void dimentions(double width, double height) = 0;
      virtual Vector2 dimentions(void) = 0;
    };

  // ---------- DESCRIPTIONS ----------

  class GraphicsEngine::GraphicsEngineDescription : public Description {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    virtual void dataPath(const String& path) = 0;

    virtual String dataPath(void) const = 0;
  };


  class GraphicsEngine::LightDescription : public Description {
  public:
    virtual void specular(const RgbaColor& specular) = 0;
    
    const RgbaColor& specular(void) const { return mSpecular; }
    
    virtual void diffuse(const RgbaColor& diffuse) = 0;
    
    const RgbaColor& diffuse(void) const { return mDiffuse; }

  private:
    RgbaColor mSpecular;
    RgbaColor mDiffuse;
    
  protected:
    void setDiffuse(const RgbaColor& c) { mDiffuse = c; }
    void setSpecular(const RgbaColor& c) { mSpecular = c; }
  };


  class GraphicsEngine::PointLightDescription : 
  public GraphicsEngine::LightDescription {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;
  };

  class GraphicsEngine::DirectionalLightDescription : 
  public GraphicsEngine::LightDescription {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    virtual void direction(const Vector3& direction) = 0;
    virtual Vector3 direction(void) const = 0;
  };

  class GraphicsEngine::SpotLightDescription : 
  public GraphicsEngine::LightDescription {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    virtual void direction(const Vector3& direction) = 0;
    virtual Vector3 direction(void) const = 0;

    virtual void innerAngle(double innerAngle) = 0;
    virtual double innerAngle(void) const = 0;

    virtual void outerAngle(double outerAngle) = 0;
    virtual double outerAngle(void) const = 0;
  };

  class GraphicsEngine::GeometryDescription : public Description {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    typedef std::set<uint32_t> IndexSetType;

    virtual void mesh(const Ptr<const MeshDescription>& mesh) = 0;

    virtual Ptr<const MeshDescription> mesh(void) const = 0;
    
    virtual IndexSetType materialIndices(void) const = 0;

    virtual void material(uint32_t index, const Ptr<const MaterialDescription>& material) = 0;
    
    virtual Ptr<const MaterialDescription> material(uint32_t index) const = 0;
  };

  class GraphicsEngine::BillboardGroupDescription : public Description {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    typedef std::set<uint32_t> IndexSetType;

    virtual void material(const Ptr<const MaterialDescription>& material) = 0;
    
    virtual Ptr<const MaterialDescription> material() const = 0;

    virtual IndexSetType billboardIndices(void) const = 0;
    
    virtual void billboard(uint32_t index, const Ptr<const BillboardDescription>& billbard) = 0;
    virtual Ptr<const BillboardDescription> billboard(uint32_t index) const = 0;
  };
  
  class GraphicsEngine::BillboardDescription : public Description {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    virtual void position(Real x, Real y, Real z) = 0;
    virtual void position(const Vector3& pos) = 0;
    const Vector3& position(void) const { return m_Pos; }
    
  protected:
    void setPosition(Real x, Real y, Real z) { setPosition(Vector3(x,y,z)); }
    void setPosition(const Vector3& pos) { m_Pos = pos; }

  private:
    Vector3 m_Pos;
  };

  class GraphicsEngine::MeshDescription : public Description {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    virtual void resourceName(const String& resourceName) = 0;
    const String& resourceName(void) const { return mResourceName; }

  protected:
    void setResourceName(const String& name) { mResourceName = name; }
  private:
    String mResourceName;
  };
  

  class GraphicsEngine::MaterialDescription : public Description {
  public:
    static const Description::Type DESCRIPTION_TYPE;
    static const String DESCRIPTION_TYPE_NAME;

    virtual void resourceName(const String& resourceName) = 0;
    const String& resourceName(void) const { return mResourceName; }
  protected:
    void setResourceName(const String& name) { mResourceName = name; }
  private:
    String mResourceName;
  };

 
  
}; // namespace Phx


#endif /* PHX_GRAPHICS_ENGINE_H */

---