Layer.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#ifndef GDCORE_LAYER_H
#define GDCORE_LAYER_H
#include <memory>
#include <vector>
 
#include "EffectsContainer.h"
#include "GDCore/String.h"
 
namespace gd {
class Effect;
class Camera;
class SerializerElement;
class EffectsContainer;
}
 
namespace gd {
 
class GD_CORE_API Camera {
 public:
  Camera();
  ~Camera(){};
 
  void SetViewport(float x1_, float y1_, float x2_, float y2_) {
    x1 = x1_;
    x2 = x2_;
    y1 = y1_;
    y2 = y2_;
  };
  void SetViewportX1(float x1_) { x1 = x1_; };
  void SetViewportY1(float y1_) { y1 = y1_; };
  void SetViewportX2(float x2_) { x2 = x2_; };
  void SetViewportY2(float y2_) { y2 = y2_; };
  float GetViewportX1() const { return x1; };
  float GetViewportY1() const { return y1; };
  float GetViewportX2() const { return x2; };
  float GetViewportY2() const { return y2; };
 
  void SetSize(float width_, float height_) {
    width = width_;
    height = height_;
  };
  float GetWidth() const { return width; };
  float GetHeight() const { return height; };
 
  void SetUseDefaultSize(bool useDefaultSize = true) {
    defaultSize = useDefaultSize;
  };
  bool UseDefaultSize() const { return defaultSize; }
 
  void SetUseDefaultViewport(bool useDefaultViewport = true) {
    defaultViewport = useDefaultViewport;
  };
  bool UseDefaultViewport() const { return defaultViewport; }
 
 private:
  bool defaultSize;      
  bool defaultViewport;  
 
  float x1;
  float y1;
  float x2;
  float y2;
  float width;   
  float height;  
};
 
class GD_CORE_API Layer {
 public:
  Layer();
  virtual ~Layer(){};
 
  void SetName(const gd::String& name_) { name = name_; }
 
  const gd::String& GetName() const { return name; }
 
  const gd::String& GetRenderingType() const { return renderingType; }
 
  void SetRenderingType(const gd::String& renderingType_) {
    renderingType = renderingType_;
  }
 
  const gd::String& GetCameraType() const { return cameraType; }
 
  void SetCameraType(const gd::String& cameraType_) {
    cameraType = cameraType_;
  }
 
  void SetVisibility(bool isVisible_) { isVisible = isVisible_; }
 
  bool GetVisibility() const { return isVisible; }
 
  void SetLocked(bool isLocked_) { isLocked = isLocked_; }
 
  bool IsLocked() const { return isLocked; }
 
  void SetLightingLayer(bool isLightingLayer_) {
    isLightingLayer = isLightingLayer_;
  }
 
  bool IsLightingLayer() const { return isLightingLayer; }
 
  void SetFollowBaseLayerCamera(bool followBaseLayerCamera_) {
    followBaseLayerCamera = followBaseLayerCamera_;
  }
 
  bool IsFollowingBaseLayerCamera() const { return followBaseLayerCamera; }
 
  double GetCamera3DNearPlaneDistance() const {
    return camera3DNearPlaneDistance;
  }
  void SetCamera3DNearPlaneDistance(double distance) {
    camera3DNearPlaneDistance = distance;
  }
  double GetCamera3DFarPlaneDistance() const {
    return camera3DFarPlaneDistance;
  }
  void SetCamera3DFarPlaneDistance(double distance) {
    camera3DFarPlaneDistance = distance;
  }
  double GetCamera3DFieldOfView() const { return camera3DFieldOfView; }
  void SetCamera3DFieldOfView(double angle) { camera3DFieldOfView = angle; }
 
 
  void SetCameraCount(std::size_t n);
 
  inline std::size_t GetCameraCount() const { return cameras.size(); };
 
  inline const Camera& GetCamera(std::size_t n) const {
    if (n >= GetCameraCount()) return badCamera;
    return cameras[n];
  }
 
  inline Camera& GetCamera(std::size_t n) {
    if (n >= GetCameraCount()) return badCamera;
    return cameras[n];
  }
 
  inline void DeleteCamera(std::size_t n) {
    if (n >= GetCameraCount()) return;
    cameras.erase(cameras.begin() + n);
  }
 
  inline void AddCamera(const Camera& camera) { cameras.push_back(camera); };
 
 
  unsigned int GetAmbientLightColorRed() const { return ambientLightColorR; }
 
  unsigned int GetAmbientLightColorGreen() const { return ambientLightColorG; }
 
  unsigned int GetAmbientLightColorBlue() const { return ambientLightColorB; }
 
  void SetAmbientLightColor(unsigned int r, unsigned int g, unsigned int b) {
    ambientLightColorR = r;
    ambientLightColorG = g;
    ambientLightColorB = b;
  }
 
 
  EffectsContainer& GetEffects();
 
  const EffectsContainer& GetEffects() const;
 
  void SerializeTo(SerializerElement& element) const;
 
  void UnserializeFrom(const SerializerElement& element);
 
 private:
  gd::String name;           
  gd::String renderingType;  
  gd::String cameraType;
  bool isVisible;            
  bool isLocked;             
  bool isLightingLayer;  
  bool followBaseLayerCamera;  
  double camera3DNearPlaneDistance;  
  double camera3DFarPlaneDistance;   
  double camera3DFieldOfView;        
  unsigned int ambientLightColorR;   
  unsigned int ambientLightColorG;   
  unsigned int ambientLightColorB;   
  std::vector<gd::Camera> cameras;   
  gd::EffectsContainer effectsContainer;  
 
  static gd::Camera badCamera;
};
 
struct LayerHasName : public std::binary_function<gd::Layer, gd::String, bool> {
  bool operator()(const Layer& layer, const gd::String& name) const {
    return layer.GetName() == name;
  }
};
 
}  // namespace gd
 
#endif  // GDCORE_LAYER_H