mirror of
https://github.com/4ian/GDevelop.git
synced 2025-10-15 10:19:04 +00:00
d1f4d26e49
* Also make the update real time (any change in the settings are shown directly in the editor) Don't show the rest in the changelog: * Add various Flow typings where missing (SetupGridDialog and various InstancesEditor files) * Serialize the settings into a generic "EditorSetting" (so that the Project is agnostic of any editor related stuff) * Rename uiSettings/options/LayoutEditorCanvasOptions to InstancesEditorSettings * Handle everything inside the IDE (so that the Project remains agnostic of any editor related stuff) Note that in the future, this kind of EditorSetting that is stored inside the project could be moved to its own structure (living outside of the project file).
513 lines
14 KiB
C++
513 lines
14 KiB
C++
/*
|
|
* GDevelop Core
|
|
* Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
|
|
* reserved. This project is released under the MIT License.
|
|
*/
|
|
|
|
#ifndef GDCORE_LAYOUT_H
|
|
#define GDCORE_LAYOUT_H
|
|
#include <map>
|
|
#include <memory>
|
|
#include <vector>
|
|
#include "GDCore/Events/EventsList.h"
|
|
#include "GDCore/Project/BehaviorsSharedData.h"
|
|
#include "GDCore/Project/InitialInstancesContainer.h"
|
|
#include "GDCore/Project/Layer.h"
|
|
#include "GDCore/Project/ObjectGroupsContainer.h"
|
|
#include "GDCore/Project/ObjectsContainer.h"
|
|
#include "GDCore/Project/VariablesContainer.h"
|
|
#include "GDCore/String.h"
|
|
#if defined(GD_IDE_ONLY)
|
|
#include "GDCore/IDE/Dialogs/LayoutEditorCanvas/EditorSettings.h"
|
|
#endif
|
|
namespace gd {
|
|
class BaseEvent;
|
|
class Object;
|
|
class Project;
|
|
class BehaviorContent;
|
|
class InitialInstancesContainer;
|
|
} // namespace gd
|
|
class TiXmlElement;
|
|
class BaseProfiler;
|
|
#undef GetObject // Disable an annoying macro
|
|
|
|
namespace gd {
|
|
|
|
/**
|
|
* \brief Represent a layout ( also called a scene ) of a project.
|
|
*
|
|
* \ingroup PlatformDefinition
|
|
*/
|
|
class GD_CORE_API Layout : public ObjectsContainer {
|
|
public:
|
|
Layout();
|
|
Layout(const Layout&);
|
|
virtual ~Layout();
|
|
Layout& operator=(const Layout& rhs);
|
|
|
|
/**
|
|
* \brief Return a pointer to a copy of the layout.
|
|
*/
|
|
Layout* Clone() const { return new Layout(*this); };
|
|
|
|
/** \name Common properties
|
|
* Members functions related to common properties of layouts
|
|
*/
|
|
///@{
|
|
|
|
/**
|
|
* Change the name of the layout with the name passed as parameter.
|
|
*/
|
|
void SetName(const gd::String& name_);
|
|
|
|
/**
|
|
* Return the name of the layout.
|
|
*/
|
|
const gd::String& GetName() const { return name; };
|
|
|
|
/**
|
|
* Return the name of the layout mangled by SceneNameMangler.
|
|
*/
|
|
const gd::String& GetMangledName() const { return mangledName; };
|
|
|
|
/**
|
|
* Set the background color
|
|
*/
|
|
void SetBackgroundColor(unsigned int r, unsigned int g, unsigned int b) {
|
|
backgroundColorR = r;
|
|
backgroundColorG = g;
|
|
backgroundColorB = b;
|
|
}
|
|
|
|
/**
|
|
* Get the background color red component
|
|
*/
|
|
unsigned int GetBackgroundColorRed() const { return backgroundColorR; }
|
|
|
|
/**
|
|
* Get the background color green component
|
|
*/
|
|
unsigned int GetBackgroundColorGreen() const { return backgroundColorG; }
|
|
|
|
/**
|
|
* Get the background color blue component
|
|
*/
|
|
unsigned int GetBackgroundColorBlue() const { return backgroundColorB; }
|
|
|
|
/**
|
|
* Get scene window default title
|
|
*/
|
|
const gd::String& GetWindowDefaultTitle() const { return title; };
|
|
|
|
/**
|
|
* Set scene window default title
|
|
*/
|
|
void SetWindowDefaultTitle(const gd::String& title_) { title = title_; };
|
|
|
|
///@}
|
|
|
|
/** \name Layout's initial instances
|
|
* Members functions related to initial instances of objects created at the
|
|
* layout start up
|
|
*/
|
|
///@{
|
|
/**
|
|
* Return the container storing initial instances.
|
|
*/
|
|
const gd::InitialInstancesContainer& GetInitialInstances() const {
|
|
return initialInstances;
|
|
}
|
|
|
|
/**
|
|
* Return the container storing initial instances.
|
|
*/
|
|
gd::InitialInstancesContainer& GetInitialInstances() {
|
|
return initialInstances;
|
|
}
|
|
///@}
|
|
|
|
/** \name Layout's events
|
|
* Members functions related to events management.
|
|
*/
|
|
///@{
|
|
|
|
#if defined(GD_IDE_ONLY)
|
|
/**
|
|
* Get the events of the layout
|
|
*/
|
|
const gd::EventsList& GetEvents() const { return events; }
|
|
|
|
/**
|
|
* Get the events of the layout
|
|
*/
|
|
gd::EventsList& GetEvents() { return events; }
|
|
#endif
|
|
///@}
|
|
|
|
/** \name Variable management
|
|
* Members functions related to layout variables management.
|
|
*/
|
|
///@{
|
|
|
|
/**
|
|
* Provide access to the gd::VariablesContainer member containing the layout
|
|
* variables \see gd::VariablesContainer
|
|
*/
|
|
inline const gd::VariablesContainer& GetVariables() const {
|
|
return variables;
|
|
}
|
|
|
|
/**
|
|
* Provide access to the gd::VariablesContainer member containing the layout
|
|
* variables \see gd::VariablesContainer
|
|
*/
|
|
inline gd::VariablesContainer& GetVariables() { return variables; }
|
|
|
|
///@}
|
|
|
|
/** \name Layout layers management
|
|
* Members functions related to layout layers management.
|
|
* TODO: This could be moved to a separate class
|
|
*/
|
|
///@{
|
|
|
|
/**
|
|
* \brief Return true if the layer called "name" exists.
|
|
*/
|
|
bool HasLayerNamed(const gd::String& name) const;
|
|
|
|
/**
|
|
* \brief Return a reference to the layer called "name".
|
|
*/
|
|
Layer& GetLayer(const gd::String& name);
|
|
|
|
/**
|
|
* \brief Return a reference to the layer called "name".
|
|
*/
|
|
const Layer& GetLayer(const gd::String& name) const;
|
|
|
|
/**
|
|
* \brief Return a reference to the layer at position "index" in the layers
|
|
* list
|
|
*/
|
|
Layer& GetLayer(std::size_t index);
|
|
|
|
/**
|
|
* \brief Return a reference to the layer at position "index" in the layers
|
|
* list
|
|
*/
|
|
const Layer& GetLayer(std::size_t index) const;
|
|
|
|
/**
|
|
* \brief Return the position of the layer called "name" in the layers list
|
|
*/
|
|
std::size_t GetLayerPosition(const gd::String& name) const;
|
|
|
|
/**
|
|
* Must return the number of layers.
|
|
*/
|
|
std::size_t GetLayersCount() const;
|
|
|
|
/**
|
|
* Must add a new empty the layer sheet called "name" at the specified
|
|
* position in the layout list.
|
|
*/
|
|
void InsertNewLayer(const gd::String& name, std::size_t position);
|
|
|
|
/**
|
|
* Must add a new the layer constructed from the layout passed as parameter.
|
|
* \note No pointer or reference must be kept on the layer passed as
|
|
* parameter. \param theLayer The the layer that must be copied and inserted
|
|
* into the project \param position Insertion position. Even if the position
|
|
* is invalid, the layer must be inserted at the end of the layers list.
|
|
*/
|
|
void InsertLayer(const Layer& theLayer, std::size_t position);
|
|
|
|
/**
|
|
* Must delete the layer named "name".
|
|
*/
|
|
void RemoveLayer(const gd::String& name);
|
|
|
|
/**
|
|
* Swap the position of the specified layers.
|
|
*/
|
|
void SwapLayers(std::size_t firstLayerIndex, std::size_t secondLayerIndex);
|
|
|
|
/**
|
|
* Change the position of the specified layer.
|
|
*/
|
|
void MoveLayer(std::size_t oldIndex, std::size_t newIndex);
|
|
|
|
#if defined(GD_IDE_ONLY)
|
|
/**
|
|
* \brief Serialize the layers.
|
|
*/
|
|
void SerializeLayersTo(SerializerElement& element) const;
|
|
#endif
|
|
|
|
/**
|
|
* \brief Unserialize the layers.
|
|
*/
|
|
void UnserializeLayersFrom(const SerializerElement& element);
|
|
///@}
|
|
|
|
/**
|
|
* This ensures that the scene had an instance of shared data for
|
|
* every behavior of every object that can be used on the scene
|
|
* (i.e. the objects of the scene and the global objects)
|
|
*
|
|
* Must be called when a behavior have been added/deleted
|
|
* or when a scene have been added to a project.
|
|
*/
|
|
void UpdateBehaviorsSharedData(gd::Project& project);
|
|
|
|
/**
|
|
* \brief Get the names of all shared data stored for behaviors
|
|
*/
|
|
std::vector<gd::String> GetAllBehaviorSharedDataNames() const;
|
|
|
|
/**
|
|
* \brief Check if shared data are stored for a behavior
|
|
*/
|
|
bool HasBehaviorSharedData(const gd::String& behaviorName);
|
|
|
|
/**
|
|
* \brief Get the shared data stored for a behavior
|
|
*/
|
|
const gd::BehaviorContent& GetBehaviorSharedData(
|
|
const gd::String& behaviorName) const;
|
|
|
|
/**
|
|
* \brief Get the shared data stored for a behavior
|
|
*/
|
|
gd::BehaviorContent& GetBehaviorSharedData(const gd::String& behaviorName);
|
|
|
|
/**
|
|
* \brief Get a map of all shared data stored for behaviors
|
|
*/
|
|
const std::map<gd::String, std::unique_ptr<gd::BehaviorContent>>&
|
|
GetAllBehaviorSharedData() const;
|
|
|
|
#if defined(GD_IDE_ONLY)
|
|
/**
|
|
* Return the settings associated to the layout.
|
|
* \see gd::EditorSettings
|
|
*/
|
|
const gd::EditorSettings& GetAssociatedEditorSettings() const {
|
|
return editorSettings;
|
|
}
|
|
|
|
/**
|
|
* Return the settings associated to the layout.
|
|
* \see gd::EditorSettings
|
|
*/
|
|
gd::EditorSettings& GetAssociatedEditorSettings() {
|
|
return editorSettings;
|
|
}
|
|
#endif
|
|
|
|
/** \name Other properties
|
|
*/
|
|
///@{
|
|
/**
|
|
* Set if the input must be disabled when window lose focus.
|
|
*/
|
|
void DisableInputWhenFocusIsLost(bool disable = true) {
|
|
disableInputWhenNotFocused = disable;
|
|
}
|
|
|
|
/**
|
|
* Return true if the input must be disabled when window lost focus.
|
|
*/
|
|
bool IsInputDisabledWhenFocusIsLost() { return disableInputWhenNotFocused; }
|
|
|
|
/**
|
|
* Set if the objects z-order are sorted using the standard method
|
|
*/
|
|
void SetStandardSortMethod(bool enable = true) {
|
|
standardSortMethod = enable;
|
|
}
|
|
|
|
/**
|
|
* Return true if the objects z-order are sorted using the standard method
|
|
*/
|
|
bool StandardSortMethod() const { return standardSortMethod; }
|
|
|
|
/**
|
|
* Set if the scene must stop all the sounds being played when it is launched.
|
|
*/
|
|
void SetStopSoundsOnStartup(bool enable = true) {
|
|
stopSoundsOnStartup = enable;
|
|
}
|
|
|
|
/**
|
|
* Return true if the scene must stop all the sounds being played when it is
|
|
* launched
|
|
*/
|
|
bool StopSoundsOnStartup() const { return stopSoundsOnStartup; }
|
|
|
|
/**
|
|
* Set OpenGL default field of view
|
|
*/
|
|
void SetOpenGLFOV(float oglFOV_) { oglFOV = oglFOV_; }
|
|
|
|
/**
|
|
* Get OpenGL default field of view
|
|
*/
|
|
float GetOpenGLFOV() const { return oglFOV; }
|
|
|
|
/**
|
|
* Set OpenGL near clipping plan
|
|
*/
|
|
void SetOpenGLZNear(float oglZNear_) { oglZNear = oglZNear_; }
|
|
|
|
/**
|
|
* Get OpenGL near clipping plan
|
|
*/
|
|
float GetOpenGLZNear() const { return oglZNear; }
|
|
|
|
/**
|
|
* Set OpenGL far clipping plan
|
|
*/
|
|
void SetOpenGLZFar(float oglZFar_) { oglZFar = oglZFar_; }
|
|
|
|
/**
|
|
* Get OpenGL far clipping plan
|
|
*/
|
|
float GetOpenGLZFar() const { return oglZFar; }
|
|
///@}
|
|
|
|
/** \name Saving and loading
|
|
* Members functions related to saving and loading the object.
|
|
*/
|
|
///@{
|
|
#if defined(GD_IDE_ONLY)
|
|
/**
|
|
* \brief Serialize the layout.
|
|
*/
|
|
void SerializeTo(SerializerElement& element) const;
|
|
#endif
|
|
|
|
/**
|
|
* \brief Unserialize the layout.
|
|
*/
|
|
void UnserializeFrom(gd::Project& project, const SerializerElement& element);
|
|
///@}
|
|
|
|
// TODO: GD C++ Platform specific code below
|
|
#if defined(GD_IDE_ONLY)
|
|
/**
|
|
* Get the profiler associated with the scene. Can be NULL.
|
|
*/
|
|
BaseProfiler* GetProfiler() const { return profiler; };
|
|
|
|
/**
|
|
* Set the profiler associated with the scene. Can be NULL.
|
|
*/
|
|
void SetProfiler(BaseProfiler* profiler_) { profiler = profiler_; };
|
|
#endif
|
|
|
|
private:
|
|
gd::String name; ///< Scene name
|
|
gd::String mangledName; ///< The scene name mangled by SceneNameMangler
|
|
unsigned int backgroundColorR; ///< Background color Red component
|
|
unsigned int backgroundColorG; ///< Background color Green component
|
|
unsigned int backgroundColorB; ///< Background color Blue component
|
|
gd::String title; ///< Title displayed in the window
|
|
gd::VariablesContainer variables; ///< Variables list
|
|
gd::InitialInstancesContainer initialInstances; ///< Initial instances
|
|
std::vector<gd::Layer> initialLayers; ///< Initial layers
|
|
std::map<gd::String, std::unique_ptr<gd::BehaviorContent>>
|
|
behaviorsSharedData; ///< Initial shared datas of behaviors
|
|
bool stopSoundsOnStartup; ///< True to make the scene stop all sounds at
|
|
///< startup.
|
|
bool standardSortMethod; ///< True to sort objects using standard sort.
|
|
float oglFOV; ///< OpenGL Field Of View value
|
|
float oglZNear; ///< OpenGL Near Z position
|
|
float oglZFar; ///< OpenGL Far Z position
|
|
bool disableInputWhenNotFocused; /// If set to true, the input must be
|
|
/// disabled when the window do not have the
|
|
/// focus.
|
|
static gd::Layer badLayer; ///< Null object, returned when GetLayer can not
|
|
///< find an appropriate layer.
|
|
static gd::BehaviorContent
|
|
badBehaviorContent; ///< Null object, returned when
|
|
///< GetBehaviorSharedData can not find the
|
|
///< specified behavior shared data.
|
|
#if defined(GD_IDE_ONLY)
|
|
EventsList events; ///< Scene events
|
|
gd::EditorSettings editorSettings;
|
|
#endif
|
|
|
|
// TODO: GD C++ Platform specific code below
|
|
#if defined(GD_IDE_ONLY)
|
|
BaseProfiler* profiler; ///< Pointer to the profiler. Can be NULL.
|
|
#endif
|
|
|
|
/**
|
|
* Initialize from another layout. Used by copy-ctor and assign-op.
|
|
* Don't forget to update me if members were changed!
|
|
*/
|
|
void Init(const gd::Layout& other);
|
|
};
|
|
|
|
/**
|
|
* \brief Functor testing layout name.
|
|
* \see gd::Layout
|
|
*/
|
|
struct LayoutHasName
|
|
: public std::binary_function<std::unique_ptr<Layout>, gd::String, bool> {
|
|
bool operator()(const std::unique_ptr<Layout>& layout,
|
|
gd::String name) const {
|
|
return layout->GetName() == name;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* \brief Get the names of all layers from the given layout
|
|
* that are invisible.
|
|
* \see gd::Layout
|
|
*/
|
|
std::vector<gd::String> GetHiddenLayers(const Layout& layout);
|
|
|
|
/**
|
|
* \brief Get a type from an object/group name.
|
|
* \note If a group contains only objects of a same type, then the group has
|
|
* this type. Otherwise, it is considered as an object without any specific
|
|
* type.
|
|
*
|
|
* @return Type of the object/group.
|
|
*/
|
|
gd::String GD_CORE_API GetTypeOfObject(const ObjectsContainer& game,
|
|
const ObjectsContainer& layout,
|
|
gd::String objectName,
|
|
bool searchInGroups = true);
|
|
|
|
/**
|
|
* \brief Get a type from a behavior name
|
|
* @return Type of the behavior.
|
|
*/
|
|
gd::String GD_CORE_API GetTypeOfBehavior(const ObjectsContainer& game,
|
|
const ObjectsContainer& layout,
|
|
gd::String behaviorName,
|
|
bool searchInGroups = true);
|
|
|
|
/**
|
|
* \brief Get behaviors of an object/group
|
|
* \note The behaviors of a group are the behaviors which are found in common
|
|
* when looking all the objects of the group.
|
|
*
|
|
* @return Vector containing names of behaviors
|
|
*/
|
|
std::vector<gd::String> GD_CORE_API
|
|
GetBehaviorsOfObject(const ObjectsContainer& game,
|
|
const ObjectsContainer& layout,
|
|
gd::String objectName,
|
|
bool searchInGroups = true);
|
|
|
|
} // namespace gd
|
|
|
|
typedef gd::Layout Scene;
|
|
|
|
#endif // GDCORE_LAYOUT_H
|