LoweBowe/LumixEngine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

cleanup

Browse source
This commit is contained in:
Mikulas Florek 2016-06-08 16:36:00 +02:00
parent 6092bdf28e
commit f56959fbcd
4 changed files with 102 additions and 155 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

99
src/renderer/editor/insert_mesh_command.cpp
View file

@ -1,99 +0,0 @@
#include "insert_mesh_command.h"
#include "editor/world_editor.h"
#include "engine/crc32.h"
#include "engine/iplugin.h"
#include "engine/json_serializer.h"
#include "engine/universe/universe.h"
#include "renderer/render_scene.h"
namespace Lumix
{
InsertMeshCommand::InsertMeshCommand(WorldEditor& editor)
: m_editor(editor)
{
}
InsertMeshCommand::InsertMeshCommand(WorldEditor& editor, const Vec3& position, const Path& mesh_path)
: m_mesh_path(mesh_path)
, m_position(position)
, m_editor(editor)
{
}
void InsertMeshCommand::serialize(JsonSerializer& serializer)
{
serializer.serialize("path", m_mesh_path.c_str());
serializer.beginArray("pos");
serializer.serializeArrayItem(m_position.x);
serializer.serializeArrayItem(m_position.y);
serializer.serializeArrayItem(m_position.z);
serializer.endArray();
}
void InsertMeshCommand::deserialize(JsonSerializer& serializer)
{
char path[MAX_PATH_LENGTH];
serializer.deserialize("path", path, sizeof(path), "");
m_mesh_path = path;
serializer.deserializeArrayBegin("pos");
serializer.deserializeArrayItem(m_position.x, 0);
serializer.deserializeArrayItem(m_position.y, 0);
serializer.deserializeArrayItem(m_position.z, 0);
serializer.deserializeArrayEnd();
}
bool InsertMeshCommand::execute()
{
static const uint32 RENDERABLE_HASH = crc32("renderable");
Universe* universe = m_editor.getUniverse();
m_entity = universe->createEntity(Vec3(0, 0, 0), Quat(0, 0, 0, 1));
universe->setPosition(m_entity, m_position);
const Array<IScene*>& scenes = m_editor.getScenes();
ComponentIndex cmp = -1;
IScene* scene = nullptr;
for (int i = 0; i < scenes.size(); ++i)
{
cmp = scenes[i]->createComponent(RENDERABLE_HASH, m_entity);
if (cmp >= 0)
{
scene = scenes[i];
break;
}
}
if (cmp >= 0) static_cast<RenderScene*>(scene)->setRenderablePath(cmp, m_mesh_path);
return true;
}
void InsertMeshCommand::undo()
{
const WorldEditor::ComponentList& cmps = m_editor.getComponents(m_entity);
for (int i = 0; i < cmps.size(); ++i)
{
cmps[i].scene->destroyComponent(cmps[i].index, cmps[i].type);
}
m_editor.getUniverse()->destroyEntity(m_entity);
m_entity = INVALID_ENTITY;
}
uint32 InsertMeshCommand::getType()
{
static const uint32 TYPE = crc32("insert_mesh");
return TYPE;
}
bool InsertMeshCommand::merge(IEditorCommand&) { return false; }
} // namespace Lumix

35
src/renderer/editor/insert_mesh_command.h
View file

@ -1,35 +0,0 @@
#pragma once
#include "editor/ieditor_command.h"
#include "engine/path.h"
#include "engine/vec.h"
namespace Lumix
{
class WorldEditor;
struct InsertMeshCommand : public IEditorCommand
{
Vec3 m_position;
Path m_mesh_path;
Entity m_entity;
WorldEditor& m_editor;
explicit InsertMeshCommand(WorldEditor& editor);
InsertMeshCommand(WorldEditor& editor, const Vec3& position, const Path& mesh_path);
void serialize(JsonSerializer& serializer) override;
void deserialize(JsonSerializer& serializer) override;
bool execute() override;
void undo() override;
uint32 getType() override;
bool merge(IEditorCommand&) override;
};
} // namespace Lumix

19
src/renderer/editor/plugins.cpp
View file

@ -24,7 +24,6 @@
#include "game_view.h"
#include "editor/render_interface.h"
#include "import_asset_dialog.h"
#include "insert_mesh_command.h"
#include "renderer/frame_buffer.h"
#include "renderer/material.h"
#include "renderer/model.h"
@ -310,7 +309,6 @@ struct ModelPlugin : public AssetBrowser::IPlugin
m_mesh = INVALID_COMPONENT;
m_pipeline = nullptr;
m_universe = nullptr;
m_app.getWorldEditor()->registerEditorCommandCreator("insert_mesh", createInsertMeshCommand);
createPreviewUniverse();
}
@ -330,21 +328,6 @@ struct ModelPlugin : public AssetBrowser::IPlugin
}
static IEditorCommand* createInsertMeshCommand(WorldEditor& editor)
{
return LUMIX_NEW(editor.getAllocator(), InsertMeshCommand)(editor);
}
static void insertInScene(WorldEditor& editor, Model* model)
{
auto* command =
LUMIX_NEW(editor.getAllocator(), InsertMeshCommand)(editor, editor.getCameraRaycastHit(), model->getPath());
editor.executeCommand(command);
}
void createPreviewUniverse()
{
auto& engine = m_app.getWorldEditor()->getEngine();
@ -456,8 +439,6 @@ struct ModelPlugin : public AssetBrowser::IPlugin
auto* model = static_cast<Model*>(resource);
if (ImGui::Button("Insert in scene")) insertInScene(*m_app.getWorldEditor(), model);
ImGui::LabelText("Bone count", "%d", model->getBoneCount());
if (model->getBoneCount() > 0 && ImGui::CollapsingHeader("Bones"))
{

104
src/renderer/editor/scene_view.cpp
View file

@ -1,5 +1,6 @@
#include "scene_view.h"
#include "editor/gizmo.h"
#include "editor/ieditor_command.h"
#include "editor/log_ui.h"
#include "editor/platform_interface.h"
#include "editor/settings.h"
@ -7,6 +8,7 @@
#include "engine/crc32.h"
#include "engine/engine.h"
#include "engine/input_system.h"
#include "engine/json_serializer.h"
#include "engine/path.h"
#include "engine/profiler.h"
#include "engine/resource_manager.h"
@ -17,7 +19,6 @@
#include "engine/universe/component.h"
#include "engine/universe/universe.h"
#include "imgui/imgui.h"
#include "insert_mesh_command.h"
#include "renderer/frame_buffer.h"
#include "renderer/model.h"
#include "renderer/pipeline.h"
@ -29,6 +30,104 @@
static const Lumix::uint32 RENDERABLE_HASH = Lumix::crc32("renderable");
struct InsertMeshCommand : public Lumix::IEditorCommand
{
Lumix::Vec3 m_position;
Lumix::Path m_mesh_path;
Lumix::Entity m_entity;
Lumix::WorldEditor& m_editor;
InsertMeshCommand(Lumix::WorldEditor& editor)
: m_editor(editor)
{
}
InsertMeshCommand(Lumix::WorldEditor& editor, const Lumix::Vec3& position, const Lumix::Path& mesh_path)
: m_mesh_path(mesh_path)
, m_position(position)
, m_editor(editor)
{
}
void serialize(Lumix::JsonSerializer& serializer)
{
serializer.serialize("path", m_mesh_path.c_str());
serializer.beginArray("pos");
serializer.serializeArrayItem(m_position.x);
serializer.serializeArrayItem(m_position.y);
serializer.serializeArrayItem(m_position.z);
serializer.endArray();
}
void deserialize(Lumix::JsonSerializer& serializer)
{
char path[Lumix::MAX_PATH_LENGTH];
serializer.deserialize("path", path, sizeof(path), "");
m_mesh_path = path;
serializer.deserializeArrayBegin("pos");
serializer.deserializeArrayItem(m_position.x, 0);
serializer.deserializeArrayItem(m_position.y, 0);
serializer.deserializeArrayItem(m_position.z, 0);
serializer.deserializeArrayEnd();
}
bool execute()
{
auto* universe = m_editor.getUniverse();
m_entity = universe->createEntity({ 0, 0, 0 }, { 0, 0, 0, 1 });
universe->setPosition(m_entity, m_position);
const auto& scenes = m_editor.getScenes();
Lumix::ComponentIndex cmp = -1;
Lumix::IScene* scene = nullptr;
for (int i = 0; i < scenes.size(); ++i)
{
cmp = scenes[i]->createComponent(RENDERABLE_HASH, m_entity);
if (cmp >= 0)
{
scene = scenes[i];
break;
}
}
if (cmp >= 0) static_cast<Lumix::RenderScene*>(scene)->setRenderablePath(cmp, m_mesh_path);
return true;
}
void undo()
{
const auto& cmps = m_editor.getComponents(m_entity);
for (int i = 0; i < cmps.size(); ++i)
{
cmps[i].scene->destroyComponent(cmps[i].index, cmps[i].type);
}
m_editor.getUniverse()->destroyEntity(m_entity);
m_entity = Lumix::INVALID_ENTITY;
}
Lumix::uint32 getType()
{
static const Lumix::uint32 TYPE = Lumix::crc32("insert_mesh");
return TYPE;
}
bool merge(Lumix::IEditorCommand&) { return false; }
};
static Lumix::IEditorCommand* createInsertMeshCommand(Lumix::WorldEditor& editor)
{
return LUMIX_NEW(editor.getAllocator(), InsertMeshCommand)(editor);
}
SceneView::SceneView(StudioApp& app)
: m_app(app)
{
@ -39,6 +138,7 @@ SceneView::SceneView(StudioApp& app)
m_show_stats = false;
m_log_ui = nullptr;
m_is_opengl = false;
m_app.getWorldEditor()->registerEditorCommandCreator("insert_mesh", createInsertMeshCommand);
}
@ -206,7 +306,7 @@ void SceneView::handleDrop(float x, float y)
{
if (Lumix::PathUtils::hasExtension(path, "msh"))
{
auto* command = LUMIX_NEW(m_editor->getAllocator(), Lumix::InsertMeshCommand)(
auto* command = LUMIX_NEW(m_editor->getAllocator(), InsertMeshCommand)(
*m_editor, hit.m_origin + hit.m_t * hit.m_dir, Lumix::Path(path));
m_editor->executeCommand(command);