eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-19 12:19:18 +02:00
Code Issues 121 Wiki Activity

Add brush mode in editor mode

Browse Source
This commit is contained in:
Hirek
2026-01-03 18:02:15 +01:00
parent 1cafe15917
commit f9c95e2de0
10 changed files with 2319 additions and 2099 deletions
Download Patch File Download Diff File Expand all files Collapse all files

672
editormode.cpp
View File

@@ -21,238 +21,322 @@ http://mozilla.org/MPL/2.0/.
#include "renderer.h"
#include "AnimModel.h"
bool
editor_mode::editormode_input::init() {
bool editor_mode::editormode_input::init()
{
return (
mouse.init()
&& keyboard.init() );
return (mouse.init() && keyboard.init());
}
void
editor_mode::editormode_input::poll() {
void editor_mode::editormode_input::poll()
{
keyboard.poll();
keyboard.poll();
}
editor_mode::editor_mode() {
editor_mode::editor_mode()
{
m_userinterface = std::make_shared<editor_ui>();
m_userinterface = std::make_shared<editor_ui>();
}
// initializes internal data structures of the mode. returns: true on success, false otherwise
bool
editor_mode::init() {
bool editor_mode::init()
{
Camera.Init( { 0, 15, 0 }, { glm::radians( -30.0 ), glm::radians( 180.0 ), 0 }, nullptr );
Camera.Init({0, 15, 0}, {glm::radians(-30.0), glm::radians(180.0), 0}, nullptr);
return m_input.init();
return m_input.init();
}
// mode-specific update of simulation data. returns: false on error, true otherwise
bool
editor_mode::update() {
bool editor_mode::update()
{
Timer::UpdateTimers( true );
Timer::UpdateTimers(true);
simulation::State.update_clocks();
simulation::Environment.update();
simulation::State.update_clocks();
simulation::Environment.update();
// render time routines follow:
auto const deltarealtime = Timer::GetDeltaRenderTime(); // nie uwzględnia pauzowania ani mnożenia czasu
// render time routines follow:
auto const deltarealtime = Timer::GetDeltaRenderTime(); // nie uwzględnia pauzowania ani mnożenia czasu
// fixed step render time routines:
fTime50Hz += deltarealtime; // w pauzie też trzeba zliczać czas, bo przy dużym FPS będzie problem z odczytem ramek
while( fTime50Hz >= 1.0 / 50.0 ) {
// fixed step render time routines:
fTime50Hz += deltarealtime; // w pauzie też trzeba zliczać czas, bo przy dużym FPS będzie problem z odczytem ramek
while (fTime50Hz >= 1.0 / 50.0)
{
#ifdef _WIN32
Console::Update(); // to i tak trzeba wywoływać
Console::Update(); // to i tak trzeba wywoływać
#endif
m_userinterface->update();
// decelerate camera
Camera.Velocity *= 0.65;
if( std::abs( Camera.Velocity.x ) < 0.01 ) { Camera.Velocity.x = 0.0; }
if( std::abs( Camera.Velocity.y ) < 0.01 ) { Camera.Velocity.y = 0.0; }
if( std::abs( Camera.Velocity.z ) < 0.01 ) { Camera.Velocity.z = 0.0; }
m_userinterface->update();
if (mouseHold)
{
auto const mode = static_cast<editor_ui *>(m_userinterface.get())->mode();
auto const rotation_mode = static_cast<editor_ui *>(m_userinterface.get())->rot_mode();
auto const fixed_rotation_value = static_cast<editor_ui *>(m_userinterface.get())->rot_val();
int Action = GLFW_REPEAT;
int Button = GLFW_MOUSE_BUTTON_LEFT;
{
GfxRenderer->Pick_Node_Callback(
[this, mode, rotation_mode, fixed_rotation_value, Action, Button](scene::basic_node *node)
{
editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get());
fTime50Hz -= 1.0 / 50.0;
}
if (mode == nodebank_panel::BRUSH)
{
const std::string *src = ui->get_active_node_template();
// std::string name = "editor_" + std::to_string(LocalRandom(0.0, 100000.0));
std::string name = "editor_" + generate_uuid_v4();
// variable step render time routines:
update_camera( deltarealtime );
if (!src)
return;
simulation::Region->update_sounds();
audio::renderer.update( Global.iPause ? 0.0 : deltarealtime );
glm::vec3 newPos = GfxRenderer->Mouse_Position();
float distance = glm::distance(newPos, oldPos);
if (distance < ui->getSpacing())
return;
TAnimModel *cloned = simulation::State.create_model(*src, name, Camera.Pos + newPos);
oldPos = newPos;
if (!cloned)
return;
GfxRenderer->Update( deltarealtime );
// if (!m_dragging)
// return;
simulation::is_ready = true;
m_node = cloned;
return true;
if (rotation_mode == functions_panel::RANDOM)
{
auto const rotation{glm::vec3{0, LocalRandom(0.0, 360.0), 0}};
m_editor.rotate(m_node, rotation, 1);
}
else if (rotation_mode == functions_panel::FIXED)
{
auto const rotation{glm::vec3{0, fixed_rotation_value, 0}};
m_editor.rotate(m_node, rotation, 0);
}
// Application.set_cursor( GLFW_CURSOR_DISABLED );
ui->set_node(m_node);
}
});
}
}
// decelerate camera
Camera.Velocity *= 0.65;
if (std::abs(Camera.Velocity.x) < 0.01)
{
Camera.Velocity.x = 0.0;
}
if (std::abs(Camera.Velocity.y) < 0.01)
{
Camera.Velocity.y = 0.0;
}
if (std::abs(Camera.Velocity.z) < 0.01)
{
Camera.Velocity.z = 0.0;
}
fTime50Hz -= 1.0 / 50.0;
}
// variable step render time routines:
update_camera(deltarealtime);
simulation::Region->update_sounds();
audio::renderer.update(Global.iPause ? 0.0 : deltarealtime);
GfxRenderer->Update(deltarealtime);
simulation::is_ready = true;
return true;
}
void
editor_mode::update_camera( double const Deltatime ) {
void editor_mode::update_camera(double const Deltatime)
{
// uwzględnienie ruchu wywołanego klawiszami
Camera.Update();
// reset window state, it'll be set again if applicable in a check below
Global.CabWindowOpen = false;
// all done, update camera position to the new value
Global.pCamera = Camera;
// uwzględnienie ruchu wywołanego klawiszami
Camera.Update();
// reset window state, it'll be set again if applicable in a check below
Global.CabWindowOpen = false;
// all done, update camera position to the new value
Global.pCamera = Camera;
}
// maintenance method, called when the mode is activated
void
editor_mode::enter() {
void editor_mode::enter()
{
m_statebackup = { Global.pCamera, FreeFlyModeFlag, Global.ControlPicking };
m_statebackup = {Global.pCamera, FreeFlyModeFlag, Global.ControlPicking};
Camera = Global.pCamera;
// NOTE: camera placement is effectively a copy of drivermode DistantView( true )
// TBD, TODO: refactor into a common vehicle method?
if( false == FreeFlyModeFlag ) {
Camera = Global.pCamera;
// NOTE: camera placement is effectively a copy of drivermode DistantView( true )
// TBD, TODO: refactor into a common vehicle method?
if (false == FreeFlyModeFlag)
{
auto const *vehicle { Camera.m_owner };
auto const cab {
( vehicle->MoverParameters->CabOccupied == 0 ?
1 :
vehicle->MoverParameters->CabOccupied ) };
auto const left { vehicle->VectorLeft() * cab };
Camera.Pos =
Math3D::vector3( Camera.Pos.x, vehicle->GetPosition().y, Camera.Pos.z )
+ left * vehicle->GetWidth()
+ Math3D::vector3( 1.25 * left.x, 1.6, 1.25 * left.z );
Camera.m_owner = nullptr;
Camera.LookAt = vehicle->GetPosition();
Camera.RaLook(); // jednorazowe przestawienie kamery
FreeFlyModeFlag = true;
}
Global.ControlPicking = true;
EditorModeFlag = true;
auto const *vehicle{Camera.m_owner};
auto const cab{(vehicle->MoverParameters->CabOccupied == 0 ? 1 : vehicle->MoverParameters->CabOccupied)};
auto const left{vehicle->VectorLeft() * cab};
Camera.Pos = Math3D::vector3(Camera.Pos.x, vehicle->GetPosition().y, Camera.Pos.z) + left * vehicle->GetWidth() + Math3D::vector3(1.25 * left.x, 1.6, 1.25 * left.z);
Camera.m_owner = nullptr;
Camera.LookAt = vehicle->GetPosition();
Camera.RaLook(); // jednorazowe przestawienie kamery
FreeFlyModeFlag = true;
}
Global.ControlPicking = true;
EditorModeFlag = true;
Application.set_cursor( GLFW_CURSOR_NORMAL );
Application.set_cursor(GLFW_CURSOR_NORMAL);
}
// maintenance method, called when the mode is deactivated
void
editor_mode::exit() {
void editor_mode::exit()
{
EditorModeFlag = false;
Global.ControlPicking = m_statebackup.picking;
FreeFlyModeFlag = m_statebackup.freefly;
Global.pCamera = m_statebackup.camera;
EditorModeFlag = false;
Global.ControlPicking = m_statebackup.picking;
FreeFlyModeFlag = m_statebackup.freefly;
Global.pCamera = m_statebackup.camera;
Application.set_cursor(
( Global.ControlPicking ?
GLFW_CURSOR_NORMAL :
GLFW_CURSOR_DISABLED ) );
Application.set_cursor((Global.ControlPicking ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_DISABLED));
if( false == Global.ControlPicking ) {
Application.set_cursor_pos( 0, 0 );
}
if (false == Global.ControlPicking)
{
Application.set_cursor_pos(0, 0);
}
}
void
editor_mode::on_key( int const Key, int const Scancode, int const Action, int const Mods ) {
void editor_mode::on_key(int const Key, int const Scancode, int const Action, int const Mods)
{
#ifndef __unix__
Global.shiftState = (Mods & GLFW_MOD_SHIFT) ? true : false;
Global.ctrlState = (Mods & GLFW_MOD_CONTROL) ? true : false;
Global.altState = (Mods & GLFW_MOD_ALT) ? true : false;
#endif
bool anyModifier = Mods & (GLFW_MOD_SHIFT | GLFW_MOD_CONTROL | GLFW_MOD_ALT);
bool anyModifier = Mods & (GLFW_MOD_SHIFT | GLFW_MOD_CONTROL | GLFW_MOD_ALT);
// give the ui first shot at the input processing...
if( !anyModifier && true == m_userinterface->on_key( Key, Action ) ) { return; }
// ...if the input is left untouched, pass it on
if( true == m_input.keyboard.key( Key, Action ) ) { return; }
// give the ui first shot at the input processing...
if (!anyModifier && true == m_userinterface->on_key(Key, Action))
{
return;
}
// ...if the input is left untouched, pass it on
if (true == m_input.keyboard.key(Key, Action))
{
return;
}
if( Action == GLFW_RELEASE ) { return; }
if (Action == GLFW_RELEASE)
{
return;
}
// legacy hardcoded keyboard commands
// TODO: replace with current command system, move to input object(s)
switch( Key ) {
// legacy hardcoded keyboard commands
// TODO: replace with current command system, move to input object(s)
switch (Key)
{
case GLFW_KEY_F11: {
if( Action != GLFW_PRESS ) { break; }
// mode switch
// TODO: unsaved changes warning
if( ( false == Global.ctrlState )
&& ( false == Global.shiftState ) ) {
Application.pop_mode();
}
// scenery export
if( Global.ctrlState
&& Global.shiftState ) {
simulation::State.export_as_text( Global.SceneryFile );
}
break;
}
case GLFW_KEY_F12: {
// quick debug mode toggle
if( Global.ctrlState
&& Global.shiftState ) {
DebugModeFlag = !DebugModeFlag;
}
break;
}
// TODO: ensure delete method can play nice with history stack
case GLFW_KEY_DELETE: {
TAnimModel *model = dynamic_cast<TAnimModel*>(m_node);
if (!model)
break;
m_node = nullptr;
m_dragging = false;
//Application.set_cursor( GLFW_CURSOR_NORMAL );
static_cast<editor_ui*>( m_userinterface.get() )->set_node(nullptr);
simulation::State.delete_model(model);
case GLFW_KEY_F11:
{
if (Action != GLFW_PRESS)
{
break;
}
}
// mode switch
// TODO: unsaved changes warning
if ((false == Global.ctrlState) && (false == Global.shiftState))
{
Application.pop_mode();
}
// scenery export
if (Global.ctrlState && Global.shiftState)
{
simulation::State.export_as_text(Global.SceneryFile);
}
break;
}
default: {
break;
}
}
case GLFW_KEY_F12:
{
// quick debug mode toggle
if (Global.ctrlState && Global.shiftState)
{
DebugModeFlag = !DebugModeFlag;
}
break;
}
// TODO: ensure delete method can play nice with history stack
case GLFW_KEY_DELETE:
{
TAnimModel *model = dynamic_cast<TAnimModel *>(m_node);
if (!model)
break;
m_node = nullptr;
m_dragging = false;
// Application.set_cursor( GLFW_CURSOR_NORMAL );
static_cast<editor_ui *>(m_userinterface.get())->set_node(nullptr);
simulation::State.delete_model(model);
break;
}
default:
{
break;
}
}
}
void
editor_mode::on_cursor_pos( double const Horizontal, double const Vertical ) {
void editor_mode::on_cursor_pos(double const Horizontal, double const Vertical)
{
auto const mousemove { glm::dvec2{ Horizontal, Vertical } - m_input.mouse.position() };
m_input.mouse.position( Horizontal, Vertical );
auto const mousemove{glm::dvec2{Horizontal, Vertical} - m_input.mouse.position()};
m_input.mouse.position(Horizontal, Vertical);
if( m_input.mouse.button( GLFW_MOUSE_BUTTON_LEFT ) == GLFW_RELEASE ) { return; }
if( m_node == nullptr ) { return; }
if (m_input.mouse.button(GLFW_MOUSE_BUTTON_LEFT) == GLFW_RELEASE)
{
return;
}
if (m_node == nullptr)
{
return;
}
if( m_takesnapshot ) {
// take a snapshot of selected node(s)
// TODO: implement this
m_takesnapshot = false;
}
if (m_takesnapshot)
{
// take a snapshot of selected node(s)
// TODO: implement this
m_takesnapshot = false;
}
if( mode_translation() ) {
// move selected node
if( mode_translation_vertical() ) {
auto const translation { mousemove.y * -0.01f };
m_editor.translate( m_node, translation );
}
else {
auto const mouseworldposition { Camera.Pos + GfxRenderer->Mouse_Position() };
m_editor.translate( m_node, mouseworldposition, mode_snap() );
}
}
if (mode_translation())
{
// move selected node
if (mode_translation_vertical())
{
auto const translation{mousemove.y * -0.01f};
m_editor.translate(m_node, translation);
}
else
{
auto const mouseworldposition{Camera.Pos + GfxRenderer->Mouse_Position()};
m_editor.translate(m_node, mouseworldposition, mode_snap());
}
}
else if (mode_rotationY())
{
// rotate selected node
// auto const rotation{glm::vec3{mousemove.y, mousemove.x, 0} * 0.25f};
auto const rotation{glm::vec3{0, mousemove.x, 0} * 0.25f};
auto const quantization{(mode_snap() ? 5.f : // TODO: put quantization value in a variable
0.f)};
0.f)};
m_editor.rotate(m_node, rotation, quantization);
}
else if (mode_rotationZ())
@@ -262,7 +346,7 @@ editor_mode::on_cursor_pos( double const Horizontal, double const Vertical ) {
// auto const rotation{glm::vec3{mousemove.y, mousemove.x, 0} * 0.25f};
auto const rotation{glm::vec3{0, 0, mousemove.x} * 0.25f};
auto const quantization{(mode_snap() ? 5.f : // TODO: put quantization value in a variable
0.f)};
0.f)};
m_editor.rotate(m_node, rotation, quantization);
}
else if (mode_rotationX())
@@ -271,7 +355,7 @@ editor_mode::on_cursor_pos( double const Horizontal, double const Vertical ) {
// auto const rotation{glm::vec3{mousemove.y, mousemove.x, 0} * 0.25f};
auto const rotation{glm::vec3{mousemove.y, 0, 0} * 0.25f};
auto const quantization{(mode_snap() ? 5.f : // TODO: put quantization value in a variable
0.f)};
0.f)};
m_editor.rotate(m_node, rotation, quantization);
}
}
@@ -307,161 +391,171 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
m_input.mouse.button( Button, Action );
}
*/
void
editor_mode::on_mouse_button( int const Button, int const Action, int const Mods ) {
void editor_mode::on_mouse_button(int const Button, int const Action, int const Mods)
{
// give the ui first shot at the input processing...
if( true == m_userinterface->on_mouse_button( Button, Action ) ) { return; }
// give the ui first shot at the input processing...
if( Button == GLFW_MOUSE_BUTTON_LEFT ) {
if( Action == GLFW_PRESS ) {
// left button press
auto const mode = static_cast<editor_ui*>( m_userinterface.get() )->mode();
auto const rotation_mode = static_cast<editor_ui*>( m_userinterface.get() )->rot_mode();
auto const fixed_rotation_value =
static_cast<editor_ui *>(m_userinterface.get())->rot_val();
m_node = nullptr;
GfxRenderer->Pick_Node_Callback([this, mode, rotation_mode, fixed_rotation_value,
Action, Button](scene::basic_node *node) {
editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get());
if (mode == nodebank_panel::MODIFY) {
if (!m_dragging)
return;
m_node = node;
//if( m_node )
//Application.set_cursor( GLFW_CURSOR_DISABLED );
//else
//m_dragging = false;
ui->set_node(m_node);
}
else if (mode == nodebank_panel::COPY) {
if (node && typeid(*node) == typeid(TAnimModel)) {
std::string as_text;
node->export_as_text(as_text);
ui->add_node_template(as_text);
}
m_dragging = false;
}
else if (mode == nodebank_panel::ADD) {
const std::string *src = ui->get_active_node_template();
std::string name = "editor_" + std::to_string(LocalRandom(0.0, 100000.0));
if (!src)
return;
TAnimModel *cloned = simulation::State.create_model(*src, name, Camera.Pos + GfxRenderer->Mouse_Position());
if (!cloned)
return;
if (!m_dragging)
return;
m_node = cloned;
if (rotation_mode == functions_panel::RANDOM)
{
auto const rotation{glm::vec3{0, LocalRandom(0.0, 360.0), 0}};
m_editor.rotate(m_node, rotation, 1);
}
else if (rotation_mode == functions_panel::FIXED)
{
auto const rotation{glm::vec3{0, fixed_rotation_value, 0}};
m_editor.rotate(m_node, rotation, 0);
}
//Application.set_cursor( GLFW_CURSOR_DISABLED );
ui->set_node( m_node );
}
});
m_dragging = true;
}
else {
// left button release
//if( m_node )
//Application.set_cursor( GLFW_CURSOR_NORMAL );
m_dragging = false;
// prime history stack for another snapshot
m_takesnapshot = true;
}
}
if (Button == GLFW_MOUSE_BUTTON_RIGHT)
if (Button == GLFW_MOUSE_BUTTON_LEFT)
{
auto const mode = static_cast<editor_ui *>(m_userinterface.get())->mode();
auto const rotation_mode = static_cast<editor_ui *>(m_userinterface.get())->rot_mode();
auto const fixed_rotation_value = static_cast<editor_ui *>(m_userinterface.get())->rot_val();
/*if (Action == GLFW_PRESS)
if (true == m_userinterface->on_mouse_button(Button, Action))
{
return;
}
if (Action == GLFW_PRESS)
{
// left button press
auto const mode = static_cast<editor_ui *>(m_userinterface.get())->mode();
mouseHold = true;
m_node = nullptr;
GfxRenderer->Pick_Node_Callback([this, mode](scene::basic_node *node) {
editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get());
GfxRenderer->Pick_Node_Callback(
[this, mode, rotation_mode, fixed_rotation_value, Action, Button](scene::basic_node *node)
{
editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get());
if (mode == nodebank_panel::MODIFY)
{
if (!m_dragging)
return;
if (mode == nodebank_panel::MODIFY)
{
if (!m_dragging)
return;
m_node = node;
// if( m_node )
// Application.set_cursor( GLFW_CURSOR_DISABLED );
// else
// m_dragging = false;
ui->set_node(m_node);
}
else if (mode == nodebank_panel::COPY)
{
if (node && typeid(*node) == typeid(TAnimModel))
{
std::string as_text;
node->export_as_text(as_text);
m_node = node;
if (m_node)
Application.set_cursor(GLFW_CURSOR_DISABLED);
else
m_dragging = false;
ui->set_node(m_node);
}
});
ui->add_node_template(as_text);
}
m_dragging = false;
}
else if (mode == nodebank_panel::ADD)
{
const std::string *src = ui->get_active_node_template();
std::string name = "editor_" + generate_uuid_v4();
if (!src)
return;
TAnimModel *cloned = simulation::State.create_model(*src, name, Camera.Pos + GfxRenderer->Mouse_Position());
if (!cloned)
return;
if (!m_dragging)
return;
m_node = cloned;
if (rotation_mode == functions_panel::RANDOM)
{
auto const rotation{glm::vec3{0, LocalRandom(0.0, 360.0), 0}};
m_editor.rotate(m_node, rotation, 1);
}
else if (rotation_mode == functions_panel::FIXED)
{
auto const rotation{glm::vec3{0, fixed_rotation_value, 0}};
m_editor.rotate(m_node, rotation, 0);
}
// Application.set_cursor( GLFW_CURSOR_DISABLED );
ui->set_node(m_node);
}
});
m_dragging = true;
}
else
{
if (Action == GLFW_RELEASE)
mouseHold = false;
// left button release
if (m_node)
Application.set_cursor(GLFW_CURSOR_NORMAL);
// if( m_node )
// Application.set_cursor( GLFW_CURSOR_NORMAL );
m_dragging = false;
// prime history stack for another snapshot
m_takesnapshot = true;
}
}
if (Button == GLFW_MOUSE_BUTTON_RIGHT)
{
/*if (Action == GLFW_PRESS)
{
// left button press
auto const mode = static_cast<editor_ui *>(m_userinterface.get())->mode();
m_node = nullptr;
GfxRenderer->Pick_Node_Callback([this, mode](scene::basic_node *node) {
editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get());
if (mode == nodebank_panel::MODIFY)
{
if (!m_dragging)
return;
m_node = node;
if (m_node)
Application.set_cursor(GLFW_CURSOR_DISABLED);
else
m_dragging = false;
ui->set_node(m_node);
}
});
m_dragging = true;
}
else
{
// left button release
if (m_node)
Application.set_cursor(GLFW_CURSOR_NORMAL);
m_dragging = false;
// prime history stack for another snapshot
m_takesnapshot = true;
}*/
}
m_input.mouse.button( Button, Action );
m_input.mouse.button(Button, Action);
}
void
editor_mode::on_event_poll() {
void editor_mode::on_event_poll()
{
m_input.poll();
m_input.poll();
}
bool
editor_mode::is_command_processor() const {
bool editor_mode::is_command_processor() const
{
return false;
return false;
}
bool
editor_mode::mode_translation() const {
bool editor_mode::mode_translation() const
{
return ( false == Global.altState );
return (false == Global.altState);
}
bool
editor_mode::mode_translation_vertical() const {
bool editor_mode::mode_translation_vertical() const
{
return ( true == Global.shiftState );
return (true == Global.shiftState);
}
bool editor_mode::mode_rotationY() const
@@ -480,8 +574,8 @@ bool editor_mode::mode_rotationZ() const
return ((true == Global.altState) && (true == Global.ctrlState) && (true == Global.shiftState));
}
bool
editor_mode::mode_snap() const {
bool editor_mode::mode_snap() const
{
return ((false == Global.altState) && (true == Global.ctrlState) && (false == Global.shiftState));
return ((false == Global.altState) && (true == Global.ctrlState) && (false == Global.shiftState));
}