lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
Browse Source

Move portal.h to legacy directory; I don’t know what to do with it.

wip/core-clipp
Sam Hocevar 4 years ago
parent
ec5f308bd3
commit
e7984246c3
2 changed files with 393 additions and 4 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -4
      TODO.md
  2. +392
    -0
      legacy/lol/algorithm/portal.h

+ 1
- 4
TODO.md View File

@@ -10,9 +10,9 @@
## headers we could clean up and keep

src/lol/algorithm/aabb_tree.h
src/lol/algorithm/portal.h
src/lol/base/assert.h (could be useful)
src/lol/base/avl_tree.h
src/lol/base/string.h (string utilities)
src/lol/image/pixel.h (but is it useful?)
src/lol/math/arraynd.h (but do we really want to keep it?)
src/lol/math/geometry.h
@@ -40,13 +40,10 @@
src/lol/net/http.h
src/lol/public.h
src/lol/sys/file.h
src/lol/sys/getopt.h
src/lol/sys/init.h


## headers to remove one day

src/lol/algorithm/sort.h (there’s plenty of stuff in libc++)
src/lol/base/enum.h (can’t see the point)
src/lol/base/tuple.h (use std::tuple)


+ 392
- 0
legacy/lol/algorithm/portal.h View File

@@ -0,0 +1,392 @@
//
// Lol Engine
//
// Copyright © 2010—2020 Sam Hocevar <sam@hocevar.net>
// © 2013—2015 Benjamin “Touky” Huet <huet.benjamin@gmail.com>
//
// Lol Engine is free software. It comes without any warranty, to
// the extent permitted by applicable law. You can redistribute it
// and/or modify it under the terms of the Do What the Fuck You Want
// to Public License, Version 2, as published by the WTFPL Task Force.
// See http://www.wtfpl.net/ for more details.
//

#pragma once

#include <lol/base/array.h>
#include <lol/math/vector.h> // vec_t
#include <lol/math/transform.h> // mat_t
#include <lol/debug/lines.h>
#include <lol/image/color.h>

#include <cfloat> /* for FLT_MAX */

namespace lol
{

//------ PORTAL SYSTEM --------
template <typename TE> class PortalRoom;
template <typename TE> class PortalDoor;
template <typename TE> class PortalSet;

//--
namespace Debug {
template <typename TE, typename TV = void>
void Draw(PortalDoor<TE>& port, vec4 color)
{
vec3 points[4]; port.GetPoints(points);

// Draw normal
vec3 p = port.m_center + port.m_up * port.m_size.y * .5f;
Debug::DrawLine(p, p + port.m_normal, color::red);
Debug::DrawLine(p, p + port.m_up, color::green);
// Draw door
for (int l = 0; l < 4; l++)
Debug::DrawLine(points[l], points[(l + 1) % 4], color);
Debug::DrawLine(points[0], points[2], color);
Debug::DrawLine(points[1], points[3], color);
}
}

//PortalDoor base class
template <typename TE>
class PortalDoor
{
friend class PortalSet<TE>;
friend class PortalRoom<TE>;
friend void Debug::Draw<TE,void>(PortalDoor<TE>& port, vec4 color);

private:
void Init()
{
m_center = vec3::zero;
m_normal = vec3::zero;
m_up = vec3::zero;
m_size = vec2::zero;

m_view = mat4::identity;
m_proj = mat4::identity;

m_rooms[0] = nullptr;
m_rooms[1] = nullptr;
}

public:
//Normal portal
PortalDoor(vec3 center, vec3 normal, vec3 up, vec2 size)
{
Init();

m_center = center;
m_normal = normal;
m_up = up;
m_size = size;
}
//Camera portal
PortalDoor(mat4 view, mat4 proj)
{
Init();

m_view = view;
m_proj = proj;
}
//D.Tor
~PortalDoor()
{
ConnectRooms(nullptr, nullptr);
}

//Connect door to room
void ConnectRooms(class PortalRoom<TE>* front_room, class PortalRoom<TE>* back_room)
{
for (int i = 0; i < 2; i++)
if (m_rooms[i] != nullptr)
*m_rooms[i] >> this;

m_rooms[0] = back_room;
m_rooms[1] = front_room;

for (int i = 0; i < 2; i++)
if (m_rooms[i] != nullptr)
*m_rooms[i] << this;
}

//--
void DisconnectRoom(class PortalRoom<TE>* room)
{
for (int i = 0; i < 2; i++)
if (m_rooms[i] != nullptr && m_rooms[i] == room)
m_rooms[i] = nullptr;
}

//--
PortalRoom<TE>* GetRoom(bool front) { return m_rooms[(int)front]; }
PortalRoom<TE>* GetRoom(PortalRoom<TE>* room) { return (m_rooms[0] == room) ? m_rooms[1] : m_rooms[0]; }

//Get Four portal point
void GetPoints(vec3 *points) const
{
vec3 right = cross(m_normal, m_up);
points[0] = m_center + right * m_size.x * .5f + m_up * m_size.y;
points[1] = m_center + right * m_size.x * .5f;
points[2] = m_center + right * m_size.x * -.5f;
points[3] = m_center + right * m_size.x * -.5f + m_up * m_size.y;
}
//Builds the portal view proj.
//Returns false if portal is out of the view or points are on each others.
bool BuildViewProj(mat4 view, mat4 proj)
{
mat4 cam_mx = proj * view;
mat4 inv_proj_mx = inverse(proj);

// First: Check normal dot
if (lol::fabs(dot(mat3(inverse(view)) * vec3(0.f, 0.f, 1.f), m_normal)) < .00001f)
return false;

// Second: convert to screen coordinates
vec3 port_2d[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
vec3 door_points[4];
vec4 proj_p[4];

GetPoints(door_points);

for (int i = 0; i < 4; i++)
{
//W to S calculations
proj_p[i] = cam_mx * vec4(door_points[i], 1.f);
proj_p[i] /= proj_p[i].w;

//Clamp points within screen
port_2d[0] = lol::min(proj_p[i].xyz, port_2d[0]);
port_2d[1] = lol::max(proj_p[i].xyz, port_2d[1]);
port_2d[0] = vec3(lol::clamp(port_2d[0].xy, vec2(-1.f), vec2(1.f)), port_2d[0].z);
port_2d[1] = vec3(lol::clamp(port_2d[1].xy, vec2(-1.f), vec2(1.f)), port_2d[1].z);
}

//Quit if door not within the screen
for (int i = 0; i < 3; i++)
if (port_2d[0][i] == port_2d[1][i])
return false;

//Third: Convert back to view
ivec2 j[4] = { ivec2(0), ivec2(0, 1), ivec2(1), ivec2(1, 0) };
vec3 frust[2] = { vec3(FLT_MAX), vec3(-FLT_MAX) };
for (int i = 0; i < 5; i++)
{
int k = i % 4;
//world calculations
proj_p[k] = inv_proj_mx * vec4(port_2d[j[k].x].x, port_2d[j[k].y].y, (i<4)?(port_2d[0].z):(1.f), 1.f);
proj_p[k] /= proj_p[k].w;
proj_p[k].z = lol::fabs(proj_p[k].z);

for (int h = 0; h < 3; h++)
{
if (i < 4 || h > 1)
{
frust[0][h] = lol::min(frust[0][h], proj_p[k][h]);
frust[1][h] = lol::max(frust[1][h], proj_p[k][h]);
}
}
}

//Fourth: Create frustum
m_proj = mat4::frustum(frust[0].x, frust[1].x, frust[0].y, frust[1].y, frust[0].z, frust[1].z);
m_view = view;

return true;
}

//View proj getter (doesn't check matrix validity)
mat4 GetViewProj() { return m_proj * m_view; }

//--
bool TestCollide(const vec3& point)
{
return TestPointVsFrustum(point, GetViewProj());
}

//--
bool TestCollide(const PortalDoor& door)
{
vec3 door_points[4];
vec3 res_points[4];
ivec3 pos_test = ivec3::zero;
bool is_in = false;

//Get points and test them on frustum
door.GetPoints(door_points);
for (int i = 0; i < 4; i++)
{
is_in = is_in || TestPointVsFrustum(door_points[i], GetViewProj(), &res_points[i]);

if (is_in)
return true;

//Add points on test stuff
pos_test += ivec3(lol::clamp(res_points[i], vec3(-1.1f), vec3(1.1f)));
}

return false;

//Check if at least one point is not on the same side as the others
for (int i = 0; i < 3; i++)
if (lol::fabs(pos_test[i]) == 4)
return false;

return true;
}

private:
mat4 m_view;
mat4 m_proj;
vec3 m_center;
vec3 m_normal;
vec3 m_up;
vec2 m_size;
PortalRoom<TE>* m_rooms[2]; //0: Back, 1: Front
};

//--
template <typename TE>
class PortalRoom
{
friend class PortalSet<TE>;
friend class PortalDoor<TE>;

public:
PortalRoom(TE* element = nullptr)
{
m_element = element;
}
~PortalRoom()
{
for (auto door : m_doors)
door->DisconnectRoom(this);
m_doors.clear();
}

PortalRoom& operator<<(class PortalDoor<TE>* door)
{
m_doors.push_unique(door);
return *this;
}
PortalRoom& operator>>(class PortalDoor<TE>* door)
{
m_doors.remove_swap_item(door);
return *this;
}

int GetDoorCount() { return m_doors.count(); }
PortalDoor<TE>* GetDoor(int i) { return m_doors[i]; }

private:
//Portals associated with this room.
array<PortalDoor<TE>*> m_doors;
TE* m_element;
};

//--
template <typename TE>
class PortalSet
{
public:
~PortalSet()
{
for (auto door : m_doors)
delete door;
for (auto room : m_rooms)
delete room;
m_doors.clear();
m_rooms.clear();
}

//Visible room getter
void GetVisibleRooms(PortalDoor<TE>* see_through, PortalRoom<TE>* start_room, array<PortalRoom<TE>*>& visible_rooms)
{
array<PortalDoor<TE>*> ignore_doors;
GetVisibleRooms(see_through, start_room, visible_rooms, ignore_doors);
#if LOL_BUILD_DEBUG
for (auto room : visible_rooms)
{
vec4 tmp = vec4::zero;
for (auto port : room->m_doors)
{
Debug::Draw(*port, color::cyan);
tmp += vec4(port->m_center, 1.f);
}
tmp /= tmp.w;
Debug::DrawBox(tmp.xyz - vec3(1.f), tmp.xyz + vec3(1.f), color::yellow);
}
for (auto port : ignore_doors)
{
Debug::Draw(*port, color::magenta);
Debug::DrawViewProj(port->m_view, port->m_proj, color::magenta);
}
#endif //LOL_BUILD_DEBUG
}
private:
void GetVisibleRooms(PortalDoor<TE>* see_through, PortalRoom<TE>* start_room, array<PortalRoom<TE>*>& visible_rooms, array<PortalDoor<TE>*>& ignore_doors)
{
for (auto door : start_room->m_doors)
{
if (door == see_through || ignore_doors.Find(door) != INDEX_NONE)
continue;

if (see_through->TestCollide(*door))
{
PortalRoom<TE>* other_room = door->GetRoom(start_room);
if (visible_rooms.Find(other_room) != INDEX_NONE)
continue;

ignore_doors.push_unique(door);
visible_rooms.push_unique(other_room);
door->BuildViewProj(see_through->m_view, see_through->m_proj);
GetVisibleRooms(door, other_room, visible_rooms, ignore_doors);
}
}
}
public:

//Operator
PortalSet<TE>& operator<<(class PortalRoom<TE>* room)
{
m_rooms.push_unique(room);
for (auto door : room->m_doors)
m_doors.push_unique(door);
return *this;
}
//--
PortalSet<TE>& operator>>(class PortalRoom<TE>* room)
{
for (auto door : room->m_doors)
*this >> door;
m_rooms.remove_item(room);
return *this;
}
//--
PortalSet<TE>& operator<<(class PortalDoor<TE>* door)
{
m_doors.push_unique(door);
return *this;
}
//--
PortalSet<TE>& operator>>(class PortalDoor<TE>* door)
{
m_doors.remove_item(door);
return *this;
}

//--
int GetDoorCount() { return m_doors.count(); }
PortalDoor<TE>* GetDoor(int i) { return m_doors[i]; }
int GetRoomCount() { return m_rooms.count(); }
PortalRoom<TE>* GetRoom(int i) { return m_rooms[i]; }

private:
//Portals associated with this room.
array<PortalRoom<TE>*> m_rooms;
array<PortalDoor<TE>*> m_doors;
};

} /* namespace lol */


Write Preview
Loading…
Cancel
Save