GameEngine/ModuleEditorCam.cpp at master · rodrigodpl/GameEngine · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include "Application.h"
#include "ModuleEditorCam.h"
#include "ComponentMesh.h"
#include "ComponentCamera.h"
#include "ComponentAABB.h"
#include "GameObject.h"
#include "RayHit.h"

#include "Bullet/include/btBulletDynamicsCommon.h"

#ifdef _DEBUG
#pragma comment (lib, "Bullet/libx86/BulletDynamics_debug.lib")
#pragma comment (lib, "Bullet/libx86/BulletCollision_debug.lib")
#pragma comment (lib, "Bullet/libx86/LinearMath_debug.lib")
#else
#pragma comment (lib, "Bullet/libx86/BulletDynamics.lib")
#pragma comment (lib, "Bullet/libx86/BulletCollision.lib")
#pragma comment (lib, "Bullet/libx86/LinearMath.lib")
#endif


ModuleEditorCam::ModuleEditorCam(Application* app, bool start_enabled) : Module(app, start_enabled)
{}

ModuleEditorCam::~ModuleEditorCam()
{}

bool ModuleEditorCam::Start() {

	cam = new ComponentCamera({ 0, 2, -5 });
	main_cam_obj = new GameObject("Main_Camera");

	main_cam_obj->components.push_back(cam);
	App->scene_intro->AddRootObject(main_cam_obj);

	return cam;
}


void ModuleEditorCam::Save(JSON_file& config)
{
	config.WriteString("editorcam.main_camera_obj_uid", main_cam_obj->uid.c_str());
}

void ModuleEditorCam::Load(JSON_file& config)
{
	main_cam_obj_uid = config.ReadString("editorcam.main_camera_obj_uid");
}

// -----------------------------------------------------------------
update_status ModuleEditorCam::Update(float dt)
{
	float dx = 0;  float dy = 0;  float dz = 0;

	// Look at (0,0,0)
	if (App->input->GetKey(SDL_SCANCODE_F))
		cam->LookAt({ 0,0,0 });

	if (App->input->GetMouseButton(SDL_BUTTON_LEFT) == KEY_REPEAT) {

		//mouse motion
		dx = -App->input->GetMouseXMotion();
		dy = -App->input->GetMouseYMotion();

		if (App->input->GetKey(SDL_SCANCODE_LCTRL) == KEY_REPEAT)      cam->LookAround(dx, dy);    // look around
		else if (App->input->GetKey(SDL_SCANCODE_LALT) == KEY_REPEAT)  cam->Orbit(dx, dy);	       // orbit around reference

		dx = dy = 0;
	}
	else if (App->input->GetMouseButton(SDL_BUTTON_LEFT) == KEY_DOWN)							   // mouse raycast
	{
		float x, y;
		App->input->GetMouseNormalized(x, y);
		Ray ray = cam->GetRayFromMousePos(x, y);
		if(GameObject* selected_obj = MouseRaycast(ray))
			App->scene_intro->selected_game_obj_uid = selected_obj->uid;
	}

	float speed = 3.0f * dt;

	if (App->input->GetKey(SDL_SCANCODE_LSHIFT) == KEY_REPEAT)
		speed = 6.0f * dt;

	// key motion
	if (App->input->GetKey(SDL_SCANCODE_W) == KEY_REPEAT) dz += speed;
	if (App->input->GetKey(SDL_SCANCODE_S) == KEY_REPEAT) dz -= speed;

	if (App->input->GetKey(SDL_SCANCODE_A) == KEY_REPEAT) dx += speed;
	if (App->input->GetKey(SDL_SCANCODE_D) == KEY_REPEAT) dx -= speed;

	if (App->input->GetKey(SDL_SCANCODE_J) == KEY_REPEAT) dy += speed;
	if (App->input->GetKey(SDL_SCANCODE_K) == KEY_REPEAT) dy -= speed;

	// Movement in camera axis
	cam->Move(dx, dy, dz);

	// Zoom in/out
	cam->Zoom(App->input->GetMouseZ());

	return UPDATE_CONTINUE;
}

bool sortNearestHit(const RayHit& a, const RayHit& b) { return a.hit_distance < b.hit_distance; }

GameObject* ModuleEditorCam::MouseRaycast(Ray ray) {

	std::list<RayHit> hits;
	std::vector<GameObject*>* game_objects = &App->scene_intro->all_game_objects;

	for (std::vector<GameObject*>::iterator it = game_objects->begin(); it != game_objects->end(); it++)
		(*it)->RayCastAgainstAABBs(ray, hits);

	if (hits.empty())
		return nullptr;
	else {
		std::list<RayHit> tri_hits;

		hits.sort(sortNearestHit);
		for (std::list<RayHit>::iterator it = hits.begin(); it != hits.end(); it++)
			(*it).object->RayCastAgainstMeshes(ray, tri_hits);

		if (tri_hits.empty())
			return nullptr;
		else {
			tri_hits.sort(sortNearestHit);
			return tri_hits.front().object;
		}
	}
}