mirror of
https://github.com/4ian/GDevelop.git
synced 2025-10-15 10:19:04 +00:00
a51c223c9c
* Still to do:
* Properly handle effects (disable 3D effects) for layers
* Handle hot reloading properly
* Avoid duplicating the configuration of the custom object inside each object created from it. Instead, only store the modified values.
* Add a "Extract as a custom object ("prefab")" when selecting instances in a scene.
* Add a dialog to give choice between 2D or 3D object when creating one.
* Make sure "behavior shared data" are properly handled (physics, pathfinding...)
* Check if we need to give an expression to translate coordinates from the parent to the local custom object.
* Ensure a deleted custom object does not break the editor
Co-authored-by: Davy Hélard <davy.helard@gmail.com>
139 lines
3.7 KiB
C++
139 lines
3.7 KiB
C++
/*
|
|
* GDevelop Core
|
|
* Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
|
|
* reserved. This project is released under the MIT License.
|
|
*/
|
|
|
|
#include "LayersContainer.h"
|
|
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
#include "Layer.h"
|
|
#include "Layout.h"
|
|
|
|
using namespace std;
|
|
|
|
namespace gd {
|
|
|
|
gd::Layer LayersContainer::badLayer;
|
|
|
|
LayersContainer::LayersContainer() {
|
|
Reset();
|
|
}
|
|
|
|
void LayersContainer::Reset() {
|
|
layers.clear();
|
|
gd::Layer layer;
|
|
layer.SetCameraCount(1);
|
|
layers.push_back(layer);
|
|
}
|
|
|
|
gd::Layer& LayersContainer::GetLayer(const gd::String& name) {
|
|
std::vector<gd::Layer>::iterator layer =
|
|
find_if(layers.begin(), layers.end(), [&name](const gd::Layer& layer) {
|
|
return layer.GetName() == name;
|
|
});
|
|
|
|
if (layer != layers.end()) return *layer;
|
|
|
|
return badLayer;
|
|
}
|
|
|
|
const gd::Layer& LayersContainer::GetLayer(const gd::String& name) const {
|
|
std::vector<gd::Layer>::const_iterator layer =
|
|
find_if(layers.begin(), layers.end(), [&name](const gd::Layer& layer) {
|
|
return layer.GetName() == name;
|
|
});
|
|
|
|
if (layer != layers.end()) return *layer;
|
|
|
|
return badLayer;
|
|
}
|
|
|
|
gd::Layer& LayersContainer::GetLayer(std::size_t index) {
|
|
return layers[index];
|
|
}
|
|
|
|
const gd::Layer& LayersContainer::GetLayer(std::size_t index) const {
|
|
return layers[index];
|
|
}
|
|
|
|
std::size_t LayersContainer::GetLayersCount() const { return layers.size(); }
|
|
|
|
bool LayersContainer::HasLayerNamed(const gd::String& name) const {
|
|
return (
|
|
find_if(layers.begin(), layers.end(), [&name](const gd::Layer& layer) {
|
|
return layer.GetName() == name;
|
|
}) != layers.end());
|
|
}
|
|
std::size_t LayersContainer::GetLayerPosition(const gd::String& name) const {
|
|
for (std::size_t i = 0; i < layers.size(); ++i) {
|
|
if (layers[i].GetName() == name) return i;
|
|
}
|
|
return gd::String::npos;
|
|
}
|
|
|
|
void LayersContainer::InsertNewLayer(const gd::String& name,
|
|
std::size_t position) {
|
|
gd::Layer newLayer;
|
|
newLayer.SetName(name);
|
|
if (position < layers.size())
|
|
layers.insert(layers.begin() + position, newLayer);
|
|
else
|
|
layers.push_back(newLayer);
|
|
}
|
|
|
|
void LayersContainer::InsertLayer(const gd::Layer& layer,
|
|
std::size_t position) {
|
|
if (position < layers.size())
|
|
layers.insert(layers.begin() + position, layer);
|
|
else
|
|
layers.push_back(layer);
|
|
}
|
|
|
|
void LayersContainer::RemoveLayer(const gd::String& name) {
|
|
std::vector<gd::Layer>::iterator layer =
|
|
find_if(layers.begin(), layers.end(), [&name](const gd::Layer& layer) {
|
|
return layer.GetName() == name;
|
|
});
|
|
if (layer == layers.end()) return;
|
|
|
|
layers.erase(layer);
|
|
}
|
|
|
|
void LayersContainer::SwapLayers(std::size_t firstLayerIndex,
|
|
std::size_t secondLayerIndex) {
|
|
if (firstLayerIndex >= layers.size() || secondLayerIndex >= layers.size())
|
|
return;
|
|
|
|
std::iter_swap(layers.begin() + firstLayerIndex,
|
|
layers.begin() + secondLayerIndex);
|
|
}
|
|
|
|
void LayersContainer::MoveLayer(std::size_t oldIndex, std::size_t newIndex) {
|
|
if (oldIndex >= layers.size() || newIndex >= layers.size()) return;
|
|
|
|
auto layer = layers[oldIndex];
|
|
layers.erase(layers.begin() + oldIndex);
|
|
InsertLayer(layer, newIndex);
|
|
}
|
|
|
|
void LayersContainer::SerializeLayersTo(SerializerElement& element) const {
|
|
element.ConsiderAsArrayOf("layer");
|
|
for (std::size_t j = 0; j < GetLayersCount(); ++j)
|
|
GetLayer(j).SerializeTo(element.AddChild("layer"));
|
|
}
|
|
|
|
void LayersContainer::UnserializeLayersFrom(const SerializerElement& element) {
|
|
layers.clear();
|
|
element.ConsiderAsArrayOf("layer", "Layer");
|
|
for (std::size_t i = 0; i < element.GetChildrenCount(); ++i) {
|
|
gd::Layer layer;
|
|
layer.UnserializeFrom(element.GetChild(i));
|
|
layers.push_back(layer);
|
|
}
|
|
}
|
|
|
|
} // namespace gd
|