editor.cpp

#include "editor.h"
#include "scene.h"
#include "obj_model.h"
#include "res_man.h"
#include "renderer.h"
#include "deferred_renderer.h"
#include "render_utils.h"
#include "engine/gameos.hpp"
#include "engine/utils/camera.h"
#include "engine/utils/my_types.h"
#include "utils/logging.h"
#include "utils/vec.h"
#include "utils/quaternion.h"
#include "utils/logging.h"
#include "utils/math_utils.h"
#include "utils/camera_utils.h"
#include "profiler/profiler.h"

#include <algorithm>
#include <vector>
#include <cassert>
#include <cfloat> // FLT_MAX


static StaticMesh* g_sphere_mesh = nullptr;
static StaticMesh* g_cube_mesh = nullptr;
static StaticMesh* g_torus_mesh = nullptr;

enum class GizmoMode {
	kMove,
	kRotate,
	kScale
};


class Gizmo {
    public:
    enum:u32 { 
		kMoveX = 0x01,
		kMoveY = 0x02,
		kMoveZ = 0x04,

		kRotateX = 0x8,
		kRotateY = 0x10,
		kRotateZ = 0x20,

		kScaleX = 0x40,
		kScaleY = 0x80,
		kScaleZ = 0x100,

        kMove = kMoveX|kMoveY|kMoveZ,
        kRotate = kRotateX|kRotateY|kRotateZ,
        kScale = kScaleX|kScaleY|kScaleZ,
        kAll = kMove|kRotate|kScale,
    };
    private:

	static const float kAxisLength;
	static const float kAxisWidth;
	static const float kRotSphereRadius;
	static const float kScaleCubesScale;
    static const float kScreenPercentage;

	GizmoMode mode_ = GizmoMode::kMove;
	vec3 pos_ = vec3(0,0,0);
	mat4 rot_ = mat4::identity();
    quaternion rot_q_ = quaternion::identity();
	bool bWorldSpace = false;
    u32 flags_ = kAll;

  public:
	// controlled object position
	void set_position(const vec3 &pos) { pos_ = pos; }
	vec3 get_position() const { return pos_; }
	// controlled object rotation
	void set_rotation(const quaternion& q) { rot_q_ = q; rot_ = quat_to_mat4(q); }
	const mat4& get_rotation() const { return rot_; }
	const quaternion& get_rotation_q() const { return rot_q_; }
	void set_world_space(bool ws) { bWorldSpace = ws; }
	bool get_world_space() { return bWorldSpace; }
	void set_mode(const GizmoMode mode) { mode_ = mode; }
    GizmoMode get_mode() const { return mode_; }
    void set_flags(u32 flags) { flags_ = flags; }
    u32 get_flags() { return flags_; }

    void update_mode(GizmoMode new_mode, bool bCanMove, bool bCanRotate, bool bCanScale) {
        if((new_mode == GizmoMode::kMove && bCanMove) ||
                (new_mode == GizmoMode::kRotate && bCanRotate) ||
                (new_mode == GizmoMode::kScale && bCanScale)) {
            mode_ = new_mode;
        } else if((mode_ == GizmoMode::kMove && bCanMove) ||
                (mode_ == GizmoMode::kRotate && bCanRotate) ||
                (mode_ == GizmoMode::kScale && bCanScale)) {
            // keep exising mode
        } else {
            // try find suitable and fallback to move otherwise
            assert(bCanMove || bCanRotate || bCanScale);
            mode_ = bCanMove ? GizmoMode::kMove : 
                bCanRotate ? GizmoMode::kRotate : 
                bCanScale ? GizmoMode::kScale : GizmoMode::kMove;
        }
    }


	float get_gizmo_scale(const struct RenderFrameContext* rfc) const {
		return get_scale(pos_, rfc->view_, rfc->proj_, rfc->fov_, rfc->b_is_perspective_, rfc->viewport_.z);
    }

	static float get_scale(const vec3& pos, const mat4& view, const mat4& proj, const float fov, bool b_is_perspective, float viewport_width) {
        if(b_is_perspective) {
            // get how many world units will be wisible horizontally at given pos_.z;
            const float view_z = (view * vec4(pos, 1.0f)).z;
            const float max_x_at_z = 2.0f * (1.0f/proj.elem[0][0]) * view_z / viewport_width;
            return max_x_at_z * kScreenPercentage;
        } else {
            const float max_x = 2.0f / proj.elem[0][0] / viewport_width;
            return max_x * kScreenPercentage;
        }
	}

	float get_rotation_sphere_radius(const camera* cam, float viewport_width) const {
		return kRotSphereRadius * get_scale(pos_, cam->get_view(), cam->get_projection(),
												  cam->get_fov(), cam->get_is_perspective(), viewport_width);
	}

	void draw(struct RenderFrameContext* rfc) {
		const vec3 pos = pos_;
		GizmoMode mode = mode_;
		const mat4 rot = bWorldSpace ? mat4::identity() : rot_;

		RenderMesh cube = tmp_rm(g_cube_mesh);
		const float scaler = get_scale(pos_, rfc->view_, rfc->proj_, rfc->fov_, rfc->b_is_perspective_, rfc->viewport_.z);
		const float al = kAxisLength;
		const float aw = kAxisWidth;

		const mat4 tr_x = mat4::translation(pos) * rot * mat4::translation(vec3(0.5f * al * scaler, 0.0f, 0.0f)) * 
						  mat4::scale(vec3(al, aw, aw) * scaler);
		const mat4 tr_y = mat4::translation(pos) * rot * mat4::translation(vec3(0.0f, 0.5f * al *scaler, 0.0f)) * 
						  mat4::scale(vec3(aw, al, aw) * scaler);
		const mat4 tr_z = mat4::translation(pos) * rot * mat4::translation(vec3(0.0f, 0.0f, 0.5f * al * scaler)) * 
						  mat4::scale(vec3(aw, aw, al) * scaler);

		uint32_t axis_x_id = GizmoMode::kMove == mode ? ReservedObjIds::kGizmoMoveX : 0;
		uint32_t axis_y_id = GizmoMode::kMove == mode ? ReservedObjIds::kGizmoMoveY : 0;
		uint32_t axis_z_id = GizmoMode::kMove == mode ? ReservedObjIds::kGizmoMoveZ : 0;
        if(flags_ & kMoveX)
            add_debug_mesh(rfc, &cube, tr_x, vec4(1.0f, 0.15f, 0.15f, 1.0f), axis_x_id);
        if(flags_ & kMoveY)
            add_debug_mesh(rfc, &cube, tr_y, vec4(0.15f, 1.0f, 0.15f, 1.0f), axis_y_id);
        if(flags_ & kMoveZ)
            add_debug_mesh(rfc, &cube, tr_z, vec4(0.15f, 0.15f, 1.0f, 1.0f), axis_z_id);

		if (GizmoMode::kScale == mode) {
			const float cl = aw*kScaleCubesScale;
			const mat4 scale_cube_scale = mat4::scale(vec3(cl, cl, cl) * scaler);
			const mat4 tr_sx =
				mat4::translation(pos) * rot * mat4::translation(vec3(1.0f * al * scaler, 0.0f, 0.0f)) * scale_cube_scale ;
			const mat4 tr_sy =
				mat4::translation(pos) * rot * mat4::translation(vec3(0.0f, 1.0f * al * scaler, 0.0f)) * scale_cube_scale ;
			const mat4 tr_sz =
				mat4::translation(pos) * rot * mat4::translation(vec3(0.0f, 0.0f, 1.0f * al * scaler)) * scale_cube_scale ;

            if(flags_ & kScaleX)
                add_debug_mesh(rfc, &cube, tr_sx, vec4(1.0f, 0.15f, 0.15f, 1.0f),
						   ReservedObjIds::kGizmoScaleX);
            if(flags_ & kScaleY)
                add_debug_mesh(rfc, &cube, tr_sy, vec4(0.15f, 1.0f, 0.15f, 1.0f),
						   ReservedObjIds::kGizmoScaleY);
            if(flags_ & kScaleZ)
                add_debug_mesh(rfc, &cube, tr_sz, vec4(0.15f, 0.15f, 1.0f, 1.0f),
						   ReservedObjIds::kGizmoScaleZ);

            const mat4 tr_sxyz = mat4::translation(pos) * scale_cube_scale;
            if((flags_ & (kScaleX|kScaleY|kScaleZ)) == (kScaleX|kScaleY|kScaleZ))
                add_debug_mesh(rfc, &cube, tr_sxyz, vec4(0.15f, 0.15f, 1.0f, 1.0f),
						   ReservedObjIds::kGizmoScaleXYZ);
		}

        const float sl = al*0.25f*scaler;
        const float st = 0.5f*al*scaler;
		const mat4 tr_xz = mat4::translation(pos) * rot * mat4::translation(vec3(st, 0.0f, st)) * mat4::scale(vec3(sl, sl*0.01f, sl));
		const mat4 tr_yx = mat4::translation(pos) * rot * mat4::translation(vec3(st, st, 0.0f)) * mat4::scale(vec3(sl, sl, sl*0.01f));
		const mat4 tr_yz = mat4::translation(pos) * rot * mat4::translation(vec3(0.0f, st, st)) * mat4::scale(vec3(sl*0.01f, sl, sl));

		if (GizmoMode::kRotate != mode) {
			uint32_t plane_xz_id = GizmoMode::kMove == mode ? ReservedObjIds::kGizmoMoveXZ
															: ReservedObjIds::kGizmoScaleXZ;
			uint32_t plane_yx_id = GizmoMode::kMove == mode ? ReservedObjIds::kGizmoMoveYX
															: ReservedObjIds::kGizmoScaleYX;
			uint32_t plane_yz_id = GizmoMode::kMove == mode ? ReservedObjIds::kGizmoMoveYZ
															: ReservedObjIds::kGizmoScaleYZ;
            if((GizmoMode::kMove == mode && (flags_ & (kMoveX|kMoveZ))==(kMoveX|kMoveZ)) || 
                (GizmoMode::kScale == mode && (flags_ & (kScaleX|kScaleZ))==(kScaleX|kScaleZ)))
                add_debug_mesh(rfc, &cube, tr_xz, vec4(1.0f, 0.0f, 1.0f, .25f), plane_xz_id);

            if((GizmoMode::kMove == mode && (flags_ & (kMoveX|kMoveY))==(kMoveX|kMoveY)) || 
                (GizmoMode::kScale == mode && (flags_ & (kScaleX|kScaleY))==(kScaleX|kScaleY)))
                add_debug_mesh(rfc, &cube, tr_yx, vec4(1.0f, 1.0f, 0.0f, .25f), plane_yx_id);

            if((GizmoMode::kMove == mode && (flags_ & (kMoveZ|kMoveY))==(kMoveZ|kMoveY)) || 
                (GizmoMode::kScale == mode && (flags_ & (kScaleZ|kScaleY))==(kScaleZ|kScaleY)))
                add_debug_mesh(rfc, &cube, tr_yz, vec4(0.0f, 1.0f, 1.0f, .25f), plane_yz_id);
		} else {
			RenderMesh torus = tmp_rm(g_torus_mesh);
			RenderMesh sphere = tmp_rm(g_sphere_mesh);
			const float sr = 2.0f*kRotSphereRadius; // because default sphere mesh geom is 0.5f radius

			const mat4 tr_rx = mat4::translation(pos) * rot * mat4::rotationY(90 * M_PI / 180.0f) *
							   mat4::scale(vec3(sr, sr, 0.01f) * scaler);
			const mat4 tr_ry = mat4::translation(pos) * rot * mat4::rotationX(90 * M_PI / 180.0f) *
							   mat4::scale(vec3(sr, sr, 0.01f) * scaler);
			const mat4 tr_rz = mat4::translation(pos) * rot * mat4::scale(vec3(sr, sr, 0.01f) * scaler);

			const mat4 tr_s = mat4::translation(pos) * mat4::scale(vec3(sr, sr, sr) * scaler);
            if((flags_ & (kRotateX|kRotateY|kRotateZ)) == (kRotateX|kRotateY|kRotateZ))
                add_debug_mesh(rfc, &sphere, tr_s, vec4(.5f, 0.5f, .5f, .4f),
						   ReservedObjIds::kGizmoRotateXYZ);

            if(flags_ & kRotateX)
                add_debug_mesh(rfc, &torus, tr_rx, vec4(1.0f, 0.f, 0.f, 1.0f),
						   ReservedObjIds::kGizmoRotateX);
            if(flags_ & kRotateY)
                add_debug_mesh(rfc, &torus, tr_ry, vec4(0.f, 1.0f, 0.f, 1.0f),
						   ReservedObjIds::kGizmoRotateY);
            if(flags_ & kRotateZ)
                add_debug_mesh(rfc, &torus, tr_rz, vec4(0.f, 0.f, 1.0f, 1.0f),
						   ReservedObjIds::kGizmoRotateZ);

		}
	}
};

const float Gizmo::kAxisLength = 2*1.0f;
const float Gizmo::kAxisWidth = 2*.05f;
const float Gizmo::kRotSphereRadius = 1.5f;
const float Gizmo::kScaleCubesScale = 2*1.2f;
const float Gizmo::kScreenPercentage = 75.0f;
Gizmo g_gizmo;

// TODO: move all variables in a single Editor state
static GameObject* g_sel_obj = nullptr;

struct TIWrapper {
    ITransformInterface* ti_ = nullptr;
    void* ud_ = nullptr;

    void Init(ITransformInterface* ti, void* ud) { ti_ = ti; ud_ = ud; }
    bool IsValid() const { return ti_; }

    void SetPosition(vec3 p) { assert(IsValid()); ti_->SetPosition(p, ud_); }
    vec3 GetPosition() const { assert(IsValid()); return ti_->GetPosition(ud_); }
    void SetRotation(quaternion q) { assert(IsValid()); ti_->SetRotation(q, ud_); }
    quaternion GetRotation() const { assert(IsValid()); return ti_->GetRotation(ud_); }
    void SetScale(vec3 s) { assert(IsValid()); ti_->SetScale(s, ud_); }
    vec3 GetScale() const { assert(IsValid()); return ti_->GetScale(ud_); }
    vec3 GetWorldSpaceScale() const { assert(IsValid()); return ti_->GetWorldSpaceScale(ud_); }
    void SetWorldSpaceScale(const vec3 ws) { assert(IsValid()); ti_->SetWorldSpaceScale(ws, ud_); }
    bool HasMove() const { return IsValid() ? ti_->HasMove() : true; }
    bool HasRotate() const { return IsValid() ? ti_->HasRotate() : true; }
    bool HasScale() const { return IsValid() ? ti_->HasScale() : true; }
};

//TODO: clear it on object destroy
static TIWrapper g_sel_tr;

static std::vector<UserEditorInterface> registered_editors;
static int g_active_user_editor = -1;

class EditorCameraController: public ICameraController {

    vec3 parallel_proj_origin = vec3(0);
    int use_parallel_projection = 0; // zero or projection index
                                     //
    fps_camera fps_cam;
    ortho_camera ortho_cam;

    camera cam;
public:
    PROPERTY_SUPPORT(EditorCameraController);
    PROPERTY_POLYMORPHIC_DRAW_IMPL(EditorCameraController);

    void SetPosition(const vec3& pos) {
        // set fps cam pos even if current camera is ortho
        fps_cam.set_pos(pos);
    }
    void SetXRotation(float rotX) {
        // set fps cam pos even if current camera is ortho
        fps_cam.rot_x = rotX;
    }

    virtual const camera& GetCamera() const override { return cam; }

    virtual camera& Update(float dt) override
    {
        ivec4 view_rect = editor_get_3dview_rect();

        const float view_x = view_rect.x;
        const float view_y = view_rect.y;
        const float view_w = view_rect.z;
        const float view_h = view_rect.w;

        static float fov = 90.0f;
        static float moveSpeedK = 10.0f;
        static float angularSpeedK = 0.05f * 3.1415f / 180.0f; // 0.25 degree per pixel
        static float zoomLevel = .05f;
        static bool b_was_warped = false;

        if (gos_GetKeyStatus(KEY_F2) == KEY_RELEASED) {
            if(!use_parallel_projection) {
                parallel_proj_origin = cam.get_pos();
                ortho_cam.set_pos(parallel_proj_origin);
            }
            use_parallel_projection = (use_parallel_projection + 1) % (ortho_camera::NUM_VIEWS + 1);
            ortho_cam.set_proj_idx(use_parallel_projection - 1);
            ortho_cam.set_pos(parallel_proj_origin);
        }

        int XDelta, YDelta, WheelDelta;
        float XPos, YPos;
        DWORD buttonsPressed;
        gos_GetMouseInfo(&XPos, &YPos, &XDelta, &YDelta, &WheelDelta, &buttonsPressed);
        if(b_was_warped) {
            XDelta = YDelta = 0;
            b_was_warped = false;
        }

        const bool RMB_down = (gos_GetKeyStatus(KEY_RMOUSE) == KEY_PRESSED) ||
            (gos_GetKeyStatus(KEY_RMOUSE) == KEY_HELD);

        if(use_parallel_projection) {

            if(WheelDelta)
                zoomLevel*= WheelDelta>0 ? 3.0f/4.0f : 4.0f/3.0f;

            float w = view_w*zoomLevel;
            float h = view_h*zoomLevel;
            cam.set_ortho_projection(-w / 2, w / 2, h / 2, -h / 2, -0.1, -1000.0f);

            if(RMB_down) {
                ortho_cam.dx -= XDelta*(w/view_w);
                ortho_cam.dy += YDelta*(w/view_h);
            }

            ortho_cam.update(dt);
            cam.set_view(ortho_cam.get_view());

        } else {
            cam.set_projection(fov, view_w, view_h, 0.1f, 1000.0f);
            if (/*!b_editor ||*/ RMB_down) {
                if (WheelDelta) {
                    moveSpeedK *= WheelDelta < 0 ? 3.0f / 4.0f : 4.0f / 3.0f;
                }
                fps_cam.dx += (gos_GetKeyStatus(KEY_D) || gos_GetKeyStatus(KEY_RIGHT)) ? dt * moveSpeedK : 0.0f;
                fps_cam.dx -= (gos_GetKeyStatus(KEY_A) || gos_GetKeyStatus(KEY_LEFT)) ? dt * moveSpeedK : 0.0f;
                fps_cam.dz += (gos_GetKeyStatus(KEY_W) || gos_GetKeyStatus(KEY_UP))   ? dt * moveSpeedK : 0.0f;
                fps_cam.dz -= (gos_GetKeyStatus(KEY_S) || gos_GetKeyStatus(KEY_DOWN))? dt * moveSpeedK : 0.0f;
                fps_cam.rot_x -= (float)XDelta * angularSpeedK;
                fps_cam.rot_y -= (float)YDelta * angularSpeedK;
            }
            fps_cam.update(dt);
            cam.set_view(fps_cam.get_view());
        }

        cam.set_ortho_plane(use_parallel_projection ? ortho_cam.get_view_type() : ePlanes::kNone);

        if(RMB_down) {
            bool b_full = false;
            int wrap_min_x = b_full ? 0 : view_x;
            int wrap_min_y = b_full ? 0 : view_y;
            int wrap_max_x = b_full ? Environment.screenWidth : view_x + view_w;
            int wrap_max_y = b_full ? Environment.screenHeight : view_y + view_h;

            int XInt = XPos*(Environment.screenWidth);
            int YInt = YPos*(Environment.screenHeight);
            int XWrapped = XInt< wrap_min_x + 1 ? wrap_max_x-4 : (XInt>wrap_max_x-3 ? wrap_min_x + 1 : XInt);
            int YWrapped = YInt< wrap_min_y + 1 ? wrap_max_y-4 : (YInt>wrap_max_y-3 ? wrap_min_y + 1 : YInt);

            if(XWrapped != XInt || YWrapped != YInt) {
                gos_SetMousePosition(XWrapped, YWrapped);
                b_was_warped = true;
            }
        }

        return cam;
    }
} * editorCamController = nullptr;

ICameraController* editor_get_cam_controller() { return editorCamController; }
void editor_cam_controller_set_transform(const vec3& pos, float rotX) {
    editorCamController->SetPosition(pos);
    editorCamController->SetXRotation(rotX);
}

//PROPERTY_LIST_DECLARE_EXTENAL(ICameraController)

PROPERTY_LIST_DECLARE_DERIVED(EditorCameraController, void)
PROPERTY_LIST_BEGIN_DERIVED(EditorCameraController, void)
    PROPERTY_CHILD_OBJECT(cam, "cam");
PROPERTY_LIST_END()

void initialize_editor()
{
    editorCamController = new EditorCameraController();
    editorCamController->SetPosition(vec3(0,15,-10));

	g_cube_mesh = res_man_load_mesh2("cube");
	g_sphere_mesh = res_man_load_mesh2("sphere");
	g_torus_mesh = res_man_load_mesh2("torus");
}

void initialize_render_editor()
{
    gos_AddRenderMaterial("imgui");
}

void finalize_editor()
{
	res_man_release_mesh2(g_cube_mesh );
	res_man_release_mesh2(g_sphere_mesh);
	res_man_release_mesh2(g_torus_mesh);
}

int editor_register_user_editor(UserEditorInterface ue_interface) {
    registered_editors.push_back(ue_interface);
    return (int)registered_editors.size()-1;
}
void editor_unregister_user_editor(int id) {
    assert(id>=0 && id < (int)registered_editors.size());
    registered_editors.erase(registered_editors.begin() + id);

}


// x,y = [-1,1] screen space range
GameObject* select_object_under_cursor(const camera *cam, float x, float y) {

	const mat4& inv_view = cam->get_inv_view();
    const vec3 ws_cursor_pos =
		get_cursor_pos(&inv_view, &cam->get_inv_projection(), x, y, 10.0f);

    const vec3 ws_cam_pos = (inv_view * vec4(0, 0, 0, 1)).xyz();
    const vec3 ws_dir = normalize(ws_cursor_pos - ws_cam_pos);
    using el_t = std::pair<float, GameObject *>;
    std::vector<el_t> int_obj;
    scene_get_intersected_objects(ws_cam_pos, ws_dir, int_obj);

	std::sort(int_obj.begin(), int_obj.end(),
			  [](const el_t &a, const el_t &b) -> bool { return a.first < b.first; });

    if (int_obj.empty())
        return nullptr;

    GameObject *closest_obj = int_obj[0].second;
    printf("int name: %s\n", closest_obj->GetName());
    for (auto &obj : int_obj) {
        printf("%.3f : %s\n", obj.first, obj.second->GetName());
    }
    return closest_obj;
}

std::vector<std::pair<uint32_t, std::pair<ITransformInterface*, void*>>> g_transformables;
int editor_add_gizmo(struct ITransformInterface* ti, void* userdata) {
    int id = g_transformables.size() + ReservedObjIds::kFirstEditorObjectId;
    g_transformables.push_back(std::make_pair(id, std::make_pair(ti, userdata)));
    return id;
}

// drag related variables
static bool drag_started = false;
static vec3 drag_start_mouse_world_pos;
static vec2 drag_start_mouse_proj_pos;
static vec3 drag_start_obj_pos;
static quaternion drag_start_obj_rot;
static vec3 drag_start_obj_scale;
static vec3 drag_start_obj_world_scale;

static vec3 drag_cur_mouse_world_pos;
static float drag_obj_view_dist;
static int drag_type;

static vec3 drag_rotation_gizmo_helper_pos;

static GizmoMode update_input_mode(const GizmoMode ed_mode, bool mouse_buttons_pressed) {

    if(!mouse_buttons_pressed) {
        if(gos_GetKeyStatus(KEY_Q) == KEY_PRESSED)
            return GizmoMode::kMove;
        if(gos_GetKeyStatus(KEY_W) == KEY_PRESSED)
            return GizmoMode::kRotate;
        if(gos_GetKeyStatus(KEY_E) == KEY_PRESSED)
            return GizmoMode::kScale;
    }

    return ed_mode;
}

#if defined(USE_IMGUI)
// TODO: add switch for a fullscreen when no UI is drawn and we just use our standard g_deferred_renderer.Present()
#include "imgui.h"

static ImVec2 DisplayPos;
static ImVec2 DisplaySize;
#endif
static ivec4 g3DViewRect;
static bool g3DViewFocused = false;
static bool g3DViewHovered = false;
ivec4 editor_get_3dview_rect() { return g3DViewRect; } // actually not really an editor function, but let it be here for now
bool editor_get_3dview_hovered() { return g3DViewHovered; }
ivec4 editor_calc_3dview(bool b_exclusive_3dview, intptr_t scene_colour) {

    SCOPED_GL_MARKER("Draw3dView");

    g3DViewFocused = true;
    g3DViewHovered = true;
    ivec4 rect = ivec4(0, 0, Environment.drawableWidth, Environment.drawableHeight);

#if defined(USE_IMGUI)

    ImGuiIO& io = ImGui::GetIO();
    if((ImGui::GetMainViewport()->Flags & ImGuiViewportFlags_IsMinimized) || io.DisplaySize.x == 0 || io.DisplaySize.y == 0) {
        return ivec4(0, 0, 1, 1);
    }

    if(!b_exclusive_3dview) {
        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);

        // Unfortunately, does not work for Docking branch
        // https://github.com/ocornut/imgui/issues/6295
        ImGui::SetNextWindowSizeConstraints(ImVec2(250, 250), ImVec2(FLT_MAX, FLT_MAX));

        ImGui::Begin("3DView", nullptr, ImGuiWindowFlags_NoTitleBar);

        if (ImGui::IsWindowHovered()) {
            ImGui::SetWindowFocus();
        }

        g3DViewFocused = ImGui::IsWindowFocused();
        g3DViewHovered = ImGui::IsWindowHovered();
        GameObject* go = nullptr/* get selected game object*/;
        ImGui::Text("Name: %s", go ? go->GetName() : "None");
        ImVec2 pos = ImGui::GetCursorScreenPos();
        ImVec2 csize = ImGui::GetContentRegionAvail();

        // this is not strictly thread safe as lambda is exeuted in a separate thread,
        // but DisplayPos/Size are not changing that often and even if they are
        // it is not of a big deal. but ImGui::DrawData is gone, so we cannot get these
        // from Imgui:::GetDrawData() TODO: Talk to Omar, maybe to pass draw_data to Callback as well.
        DisplaySize = io.DisplaySize;
        // ok, until we use multiple viewports
        DisplayPos = ImGui::GetMainViewport()->Pos;
        ImGui::GetWindowDrawList()->AddCallback([](const ImDrawList* parent_list, const ImDrawCmd* cmd) {
                HGOSRENDERMATERIAL imgui_mat = gos_getRenderMaterial("imgui");

				float L = DisplayPos.x;
				float R = DisplayPos.x + DisplaySize.x;
				float T = DisplayPos.y;
				float B = DisplayPos.y + DisplaySize.y;
				const float ortho_projection[4][4] =
				{
				{ 2.0f / (R - L),   0.0f,         0.0f,   0.0f },
				{ 0.0f,         2.0f / (T - B),   0.0f,   0.0f },
				{ 0.0f,         0.0f,        -1.0f,   0.0f },
				{ (R + L) / (L - R),  (T + B) / (B - T),  0.0f,   1.0f },
				};

                mat4 m;
                memcpy(&m.elem[0][0], &ortho_projection[0][0], sizeof(float)*16);
                // we pass matrices to OpenGL transposed (row-major order)
                // see glUniformMatrix "transpose = GL_TRUE" parameter
                // but this ortho_projection is in column-major (directly taken from ImGui code)
                // therefore we transpose it
                const float width = R - L;
                const float height = B - T;
                assert(width > 0.0f && height != 0.0f);
                m = transpose(m);
                assert(std::isfinite(m.elem[0][0]));
                assert(std::isfinite(m.elem[1][1]));
                assert(std::isfinite(m.elem[3][0]));
                assert(std::isfinite(m.elem[3][1]));
                
                gos_SetRenderMaterialParameterMat4(imgui_mat, "ProjMtx", (const float*)m);
                gos_ApplyRenderMaterial(imgui_mat);
        }, nullptr);

        //ImGui::Image((ImTextureID)(intptr_t)scene_colour, csize);
        ImGui::GetWindowDrawList()->AddImage(
                (ImTextureID)(intptr_t)scene_colour,
                pos, 
                ImVec2(pos.x + csize.x, pos.y + csize.y), 
                ImVec2(0, 1), ImVec2(1, 0)
                );

        ImGui::GetWindowDrawList()->AddCallback(ImDrawCallback_ResetRenderState, nullptr);

        ImGui::End();

        ImGui::PopStyleVar(3);

        // clamp min size here (note: when real imgui window is smaller image will be squashed,
        // but it is better than having issues when min size becomes 0 and we fail to recreate textures
        rect = ivec4(pos.x, pos.y, max(320.0f, csize.x), max(200.0f, csize.y));
    }
#endif
    g3DViewRect = rect;
    return rect;
}
void ui_draw_stuff() {
#if defined(USE_IMGUI)
    static float f = 0.0f;
    static int counter = 0;
    static bool show_demo_window = false;

    ImGui::Begin("Hello, world!");                          // Create a window called "Hello, world!" and append into it.

    ImGui::Text("This is some useful text.");               // Display some text (you can use a format strings too)

    ImGui::Checkbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
    ImGui::SliderFloat("float", &f, 0.0f, 1.0f);            // Edit 1 float using a slider from 0.0f to 1.0f

    if (ImGui::Button("Button"))                            // Buttons return true when clicked (most widgets return true when edited/activated)
        counter++;
    ImGui::SameLine();
    ImGui::Text("counter = %d", counter);

    //ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
    ImGui::End();

    ImGui::ShowDemoWindow(&show_demo_window);
#endif
}

void editor_set_selected_obj(class GameObject* go) {
    g_sel_obj = go;
    g_sel_tr.Init(g_sel_obj->GetTransformInterface(), nullptr);
}

class GameObject* editor_get_selected_obj() {
    return g_sel_obj;
}

void editor_update(camera *cam, const float dt) {

	int XDelta, YDelta, WheelDelta;
	float XPos, YPos;
	DWORD buttonsPressed;
	gos_GetMouseInfo(&XPos, &YPos, &XDelta, &YDelta, &WheelDelta, &buttonsPressed);

    extern ivec4 editor_get_3dview_rect();
    ivec4 view_rect = editor_get_3dview_rect();
    // mouse to 3d scene viewport
    const vec2 scaler = vec2(
            (float)Environment.drawableWidth / view_rect.z,
            (float)Environment.drawableHeight / view_rect.w);

    float lx = (XPos - view_rect.x / (float)Environment.drawableWidth) * scaler.x; 
    //float ly = (float)g3DViewRect.w/Environment.drawableHeight - (YPos - (float)g3DViewRect.y/Environment.drawableHeight);
    float ly = (YPos - view_rect.y / (float)Environment.drawableHeight) * scaler.y;

    lx = saturate(lx);
    ly = 1 - saturate(ly);

	const vec2 cur_mouse_proj_pos = 2 * vec2(lx, ly) - vec2(1);
	const float view_width = (float)view_rect.z;
	const float view_height = (float)view_rect.w;

	if (gos_GetKeyStatus(KEY_ESCAPE) == KEY_RELEASED) {
        if(g_active_user_editor == -1) {
    		gos_TerminateApplication();
        } else {
            g_active_user_editor = -1;
            log_info("Switched to main editor\n");
        }
    }

	if (gos_GetKeyStatus(KEY_1) == KEY_RELEASED)
		g_gizmo.set_world_space(!g_gizmo.get_world_space());
		
	GizmoMode gizmo_mode = update_input_mode(g_gizmo.get_mode(), !!buttonsPressed);
    g_gizmo.update_mode(gizmo_mode, g_sel_tr.HasMove(), g_sel_tr.HasRotate(), g_sel_tr.HasScale());

    u32 flags = Gizmo::kAll;
    if(cam->get_ortho_plane() == ePlanes::kXY) {
        flags &= ~(Gizmo::kMoveZ|Gizmo::kScaleZ);
        flags &= ~(Gizmo::kRotateX|Gizmo::kRotateY);
    }
    if(cam->get_ortho_plane() == ePlanes::kXZ) {
        flags &= ~(Gizmo::kMoveY|Gizmo::kScaleY);
        flags &= ~(Gizmo::kRotateX|Gizmo::kRotateZ);
    }
    if(cam->get_ortho_plane() == ePlanes::kZY) {
        flags &= ~(Gizmo::kMoveX|Gizmo::kScaleX);
        flags &= ~(Gizmo::kRotateZ|Gizmo::kRotateY);
    }
    g_gizmo.set_flags(flags);

	const uint32_t sel_id = scene_get_object_id_under_cursor();
	GameObject *go_under_cursor = nullptr;
	if (sel_id >= scene::kFirstGameObjectId) {
		go_under_cursor = scene_get_object_by_id(sel_id);
	}

	if (gos_GetKeyStatus(KEY_LMOUSE) == KEY_PRESSED) {
		if (go_under_cursor) {
			g_sel_obj = go_under_cursor;
            g_sel_tr.Init(g_sel_obj->GetTransformInterface(), nullptr);
			if (g_sel_tr.IsValid()) {
                g_gizmo.update_mode(g_gizmo.get_mode(), g_sel_tr.HasMove(), g_sel_tr.HasRotate(), g_sel_tr.HasScale());
				g_gizmo.set_position(g_sel_tr.GetPosition());
				g_gizmo.set_rotation(g_sel_tr.GetRotation());
			}
		}
		else if (sel_id >= ReservedObjIds::kGizmoFirst && sel_id < ReservedObjIds::kGizmoLast) {
			drag_type = sel_id;
			if (g_sel_tr.IsValid()) {
				drag_start_obj_pos = g_sel_tr.GetPosition();
				drag_start_obj_rot = g_sel_tr.GetRotation();
				drag_start_obj_scale = g_sel_tr.GetScale();
				drag_start_obj_world_scale = g_sel_tr.GetWorldSpaceScale();
				mat4 vm = cam->get_view();
				vec3 vp = (vm * vec4(drag_start_obj_pos, 1.0f)).getXYZ();
				drag_obj_view_dist = vp.z;
				drag_start_mouse_proj_pos = cur_mouse_proj_pos;
				drag_start_mouse_world_pos =
					screen2world(cam, cur_mouse_proj_pos, drag_obj_view_dist);

				drag_started = true;
			}
		}
        else if(sel_id >= ReservedObjIds::kFirstEditorObjectId && sel_id < ReservedObjIds::kFirstGameObjectId) {
            for(auto pair: g_transformables) {
                if(pair.first == sel_id) {
                    g_sel_obj = nullptr;
                    g_sel_tr.Init(pair.second.first, pair.second.second);
                    g_gizmo.update_mode(g_gizmo.get_mode(), g_sel_tr.HasMove(), g_sel_tr.HasRotate(), g_sel_tr.HasScale());
                    g_gizmo.set_position(g_sel_tr.GetPosition());
                    g_gizmo.set_rotation(g_sel_tr.GetRotation());
                    break;
                }
            }
        } else {
            g_sel_tr.Init(nullptr, nullptr);
        }
	}

    const bool lmouse_down = gos_GetKeyStatus(KEY_LMOUSE) == KEY_PRESSED || gos_GetKeyStatus(KEY_LMOUSE) == KEY_HELD;
	if (drag_started && lmouse_down && drag_start_mouse_proj_pos!=cur_mouse_proj_pos) {
		drag_cur_mouse_world_pos = screen2world(cam, cur_mouse_proj_pos, drag_obj_view_dist);

        const vec3 sel_obj_pos = g_sel_tr.GetPosition();
		g_gizmo.set_position(sel_obj_pos);
		vec3 ray_origin;
		vec3 ray_dir;
        if(cam->get_is_perspective()) {
		    ray_origin = (cam->get_inv_view() * vec4(0, 0, 0, 1)).xyz();
            ray_dir = normalize(drag_cur_mouse_world_pos - ray_origin);
        } else {
            ray_origin = (cam->get_inv_projection() * vec4(cur_mouse_proj_pos, 0, 1)).xyz();
		    ray_origin = (cam->get_inv_view() * vec4(ray_origin, 1)).xyz();
            ray_dir = cam->get_view().getForwardVec();
        }
		vec3 ray_dir_start = normalize(drag_start_mouse_world_pos - ray_origin);
		switch (drag_type) {
			case ReservedObjIds::kGizmoMoveX:
			case ReservedObjIds::kGizmoMoveY:
			case ReservedObjIds::kGizmoMoveZ:
			{
				const int axis_idx = drag_type - ReservedObjIds::kGizmoMoveX;
				static const vec3 axes[3] = {vec3(1.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f),
											 vec3(0.0f, 0.0f, 1.0f)};
				vec3 axis = axes[axis_idx];
                vec3 fwd = cam->get_view().getForwardVec();
				if(!g_gizmo.get_world_space())
					axis = quat_get_axis(g_gizmo.get_rotation_q(), axis_idx);
				vec3 pr_start = project_on_vector2(ray_dir, drag_start_mouse_world_pos, axis, fwd);
				vec3 pr_end = project_on_vector2(ray_dir, drag_cur_mouse_world_pos, axis, fwd);

				vec3 upd_pos = drag_start_obj_pos + (pr_end - pr_start);
				g_sel_tr.SetPosition(upd_pos);
				break;
			}
			case ReservedObjIds::kGizmoMoveXZ:
			case ReservedObjIds::kGizmoMoveYX:
			case ReservedObjIds::kGizmoMoveYZ:
			{
				const int plane_idx = drag_type - ReservedObjIds::kGizmoMoveXZ;
				vec3 cur_pos = sel_obj_pos; // maybe start pos?
				const vec4 planes[3] = {vec4(0.0f, 1.0f, 0.0f, cur_pos.y),
										vec4(0.0f, 0.0f, 1.0f, cur_pos.z),
										vec4(1.0f, 0.0f, 0.0f, cur_pos.x)};
				vec4 plane = planes[plane_idx];
				if (!g_gizmo.get_world_space()) {
					plane = transform_plane_around_point(g_gizmo.get_rotation(), plane, cur_pos);
				}

				vec3 start_pos = ray_plane_intersect(ray_dir_start, ray_origin, plane);
				vec3 offset = start_pos - drag_start_obj_pos;
				vec3 upd_pos = ray_plane_intersect(ray_dir, ray_origin, plane);
				drag_rotation_gizmo_helper_pos = upd_pos;

				g_sel_tr.SetPosition(upd_pos - offset);
				break;
			}
			case ReservedObjIds::kGizmoRotateX:
			case ReservedObjIds::kGizmoRotateY:
			case ReservedObjIds::kGizmoRotateZ:
			{
				vec3 cur_pos = sel_obj_pos;
				int plane_idx = drag_type - ReservedObjIds::kGizmoRotateX;
				const vec4 wplanes[3] = {vec4(1.0f, 0.0f, 0.0f, cur_pos.x),
										vec4(0.0f, 1.0f, 0.0f, cur_pos.y),
										vec4(0.0f, 0.0f, 1.0f, cur_pos.z)};

				const vec4 oplanes[3] = {make_plane(drag_start_obj_rot.axis0(), cur_pos),
				                        make_plane(drag_start_obj_rot.axis1(), cur_pos),
				                        make_plane(drag_start_obj_rot.axis2(), cur_pos)};

				const vec4 plane =
					g_gizmo.get_world_space() ? wplanes[plane_idx] : oplanes[plane_idx];

				vec3 start_pos = ray_plane_intersect(ray_dir_start, ray_origin, plane);
				vec3 upd_pos = ray_plane_intersect(ray_dir, ray_origin, plane);
				float r = g_gizmo.get_rotation_sphere_radius(cam, view_width);
				drag_rotation_gizmo_helper_pos = normalize(upd_pos - cur_pos) * r + cur_pos;
				// calculate angle between 2 vectors
				vec3 v0 = normalize(start_pos - drag_start_obj_pos);
				vec3 v1 = normalize(upd_pos - drag_start_obj_pos);
				float dp = clamp(dot(v0, v1), -1.0f, 1.0f);
				float angle = acosf(dp);
				
				vec3 perp = cross(v0, v1);
				vec3 rot_axis = plane.xyz();
				float k = dot(perp, rot_axis) < 0.0f ? -1.0f : 1.0f;

				quaternion add_rot = quaternion(rot_axis, angle * k);
				quaternion upd_rot = add_rot * drag_start_obj_rot;
				g_sel_tr.SetRotation(upd_rot);
				g_gizmo.set_rotation(upd_rot);

				break;
			}
			case ReservedObjIds::kGizmoRotateXYZ:
			{
				float r = g_gizmo.get_rotation_sphere_radius(cam, view_width);
				vec4 sphere = vec4(drag_start_obj_pos, r);

				vec3 start_pos = ray_sphere_intersect(ray_dir_start, ray_origin, sphere);
				vec3 upd_pos = ray_sphere_intersect(ray_dir, ray_origin, sphere);
				if (upd_pos.x == FLT_MAX) { // no intersection
					break;
				}

				vec3 v0 = normalize(start_pos - drag_start_obj_pos);
				vec3 v1 = normalize(upd_pos - drag_start_obj_pos);
				gosASSERT(v0 != v1);
				vec3 axis = normalize(cross(v0, v1));
				float angle = acosf(clamp(dot(v0, v1), -1.0f ,1.0f));

				quaternion add_rot = quaternion(axis, angle);
				quaternion upd_rot = add_rot * drag_start_obj_rot;
				g_sel_tr.SetRotation(upd_rot);
				g_gizmo.set_rotation(upd_rot);

				drag_rotation_gizmo_helper_pos = upd_pos;
				break;
			}
			case ReservedObjIds::kGizmoScaleX:
			case ReservedObjIds::kGizmoScaleY:
			case ReservedObjIds::kGizmoScaleZ:
			case ReservedObjIds::kGizmoScaleXZ:
			case ReservedObjIds::kGizmoScaleYX:
			case ReservedObjIds::kGizmoScaleYZ:
			case ReservedObjIds::kGizmoScaleXYZ:
			{
				const int axis_idx = drag_type - ReservedObjIds::kGizmoScaleX;
				const vec3 axes[7] = { vec3(1,0,0), vec3(0,1,0), vec3(0,0,1), vec3(1,0,1), vec3(1,1,0), vec3(0,1,1), vec3(1,1,1) };
				const vec2 screen_delta =
					proj2screen(cur_mouse_proj_pos, view_width, view_height) -
					proj2screen(drag_start_mouse_proj_pos, view_width, view_height);
				// TODO: use distance to the object as an additional multiplier for better UX?
				const float scale = screen_delta.x * 0.025f; 
				const vec3 scale_axis = scale * axes[axis_idx] + vec3(1,1,1);

				// for scaling in world space we would need to support skew, that means we will not have pure scale, rotate transform anymore
				// could be handled by adding 4th matrix Sw so the wole stack will be: T * Sw * R * Sl,
				// but I think it is a bit of an overkill, so no support for World Space scale at the moment
				if (g_gizmo.get_world_space()) {
					g_sel_tr.SetWorldSpaceScale(drag_start_obj_world_scale * scale_axis);
				}
				else {
					g_sel_tr.SetScale(drag_start_obj_scale * scale_axis);
				}
				break;
			}
		}

	}
	if (gos_GetKeyStatus(KEY_LMOUSE) == KEY_RELEASED) {
		drag_started = false;
		log_debug("drag stop\n");
	}

    for(auto i=0; i<(int)registered_editors.size(); ++i) {
        if(registered_editors[i].wants_activate()) {
            g_active_user_editor = i;
            log_info("Switched to editor: %s\n", registered_editors[i].name());
        }
    }

    if(g_active_user_editor != -1) {
        g_sel_obj = registered_editors[g_active_user_editor].update(cam, dt, g_sel_obj);
    }

    g_transformables.clear();
}


void editor_render_update(struct RenderFrameContext *rfc, bool b_editor_mode, bool b_exclusive_3dview)
{

    if(b_editor_mode) {
        if(g_sel_tr.IsValid()) {
            if(!drag_started) {
                // object may be updating its position
                g_gizmo.set_position(g_sel_tr.GetPosition());
                g_gizmo.set_rotation(g_sel_tr.GetRotation());
            } else {

                if ((uint32_t)drag_type >= ReservedObjIds::kGizmoMoveXZ &&
                        (uint32_t)drag_type <= ReservedObjIds ::kGizmoRotateXYZ) {
                    // a) only makes sense when we drag as its position is in absolute coord,
                    // and will not take into accout gizmo scaling
                    // b) when mouse if not moving will draw last known position, minor, fix it later
                    float s = g_gizmo.get_gizmo_scale(rfc);
                    const mat4 tr = mat4::translation(drag_rotation_gizmo_helper_pos) *
                        mat4::scale(vec3(s * 0.05f));
                    RenderMesh rm = tmp_rm(g_sphere_mesh);
                    add_debug_mesh(rfc, &rm, tr, vec4(1, 1, 1, 1));
                }
            }

            const vec3 gp = g_gizmo.get_position();
            const float s = g_gizmo.get_gizmo_scale(rfc);
            const quaternion& q = g_gizmo.get_world_space() ? quaternion::identity()
                : g_gizmo.get_rotation_q();
            rfc->rl_->addDebugLine(gp, gp + 2.5f*s*q.axis0(), vec4(1, 0, 0, 1));
            rfc->rl_->addDebugLine(gp, gp + 2.5f*s*q.axis1(), vec4(0, 1, 0, 1));
            rfc->rl_->addDebugLine(gp, gp + 2.5f*s*q.axis2(), vec4(0, 0, 1, 1));

            g_gizmo.draw(rfc);
        }

        if(g_sphere_mesh)
        {
            auto& light_list = scene_get_light_list();
            rfc->rl_->ReservePackets(light_list.size());

            RenderMesh rm = tmp_rm(g_sphere_mesh);
            // add lights to debug render pass
            for (auto &l : light_list) {
                vec4 c(l.color_.getXYZ(), 0.5f);
                add_debug_mesh_constant_size(rfc, &rm, c, l.transform_, 1.0f);
            }
        }

        if(g_active_user_editor != -1) {
            registered_editors[g_active_user_editor].render_update(rfc);
        }
    }

    if(!b_exclusive_3dview)
        ui_draw_stuff();
}