agudpp/megafauna

3D prehistoric virtualization of some places from Argentina. | Recorrido prehistorico 3D de algunas de las provincias de Argentina

megafauna's Issues

Add InputSystem module abstraction (to avoid using OIS directly)

This is not high priority but would be harder to remove the dependencies later.

Define how we will show the information of the animals

Will be text? image with hardcoded text? it will be a 3D object + information? etc..
We will show something when selection the animal (a camera / cellphone or some device?)

Be able to remove a Zone in runtime

We need to remove a trigger zone in runtime (for example for the triggers that will only be used once).
Add the associated UnitTest

HeightMapTest: Complete the unit test once we have the .mesh given from gustavo (the terrain)

The test we need to check are:
TEST(ParseMesh)
TEST(ImporterExporter)

Create interfaces to use for input of mouse and keyboard

Create the InpuMouse and InputKeyboard that will depend from OIS::Mouse and OIS::Keyboard right now...
Also the InputKeys helper class to handle easily the keypressed and keyreleased..

water effect: Check the SampleBrowser of Ogre, there are a good one sample.

We probably want to add a fish swimming in the river using that water

Culling system

We can use zone portal system (using a colored graph).
Check if we will be able to fly around all the world.

Finish LOD tool using xml or .ini file

effect for sunshine

the effect is lens flare
http://www.ogre3d.org/tikiwiki/Displaying+LensFlare
http://www.ogre3d.org/forums/viewtopic.php?f=11&t=65630

Remove AppTester capture for mouse and keyboard

If we are using input::InputHelper then is not necessary to capture the devices in the AppTester class since the InputHelper.update() is already doing that...

Improve InpuHelper system to avoid using the direct values

Probably we are allocating a big array (of bools = bits) without sense just to have a fast access for an specific value... but probably this could be improved...
Not really necessary right now

Add text table drawer (for debug)

The idea is be able to show a table with some information like for example, which are the keys used for an specific tool

Create a tool to show this running

Investigate units locomotion

How the animals will be moving into the world (using Pathfinding?) they will be free to move around every place? they will just move following a path?

[pathfinding]: TriGraph UnitTests

Implement unittests for this module and check for the main functionality.

[pathfinding]: Create navmesh main class to handle everything

We will centralize some functionality in this class:

• Be able to get a node of the TriGraph given a position Vector2.
• Be able to calculate a path (shortest path) from two positions / TriNodes.
• Be able to improve the path with funneling for example or any other algorithm.

We will need to create / use some kind of data structure to hold the nodes (space partition). Check kd-trees or try to invent the space partition structure already thought.

CustomAllocators: Create custom allocatos (or data strcutures) to use stack instead of heap

Check the custom allocators that use stack or create a new one.

[core/trigger_system] Add more unittests to the TriggerSystem module

Implement Zone classes and logic to draw and load them

Design zones classes.
Design how we will handle it (where we will put them).
We should be able to select / highlight / hide them.

At a first instance we only need to highlight them when the player is over it (so the signal we will receive in the ZoneClasses should be easy, when we enter we highlight it, when we go out then we turn it off again (probably with alpha instead of highlight it)).

Skeleton multiple instances performance

Check for performance if multiple meshes (9999 meshes) invisible and using the same skeleton are killing the performance (this test will check if the meshes are updated being invisible).
Do the same check attaching / detaching from the scene node

PrimitiveDrawer: Create a 3-axis structure (x,y,z).

The 3-axis should be pointing to x,y,z positive values, and the colors should be:
x = red,
y = green
z = blue

SelectionHelper: Finish this module

We need this module to be able to finish the trigger zone tool

MouseCursor: Change the ugly hardcoded values

This is a low priority issue since it will not affect anything else, just to be cleaner in the code :)

[core/trigger_system] We can sort the CellElements since they are static

This way we can increase the findings querys by zone.id.

Fix cameras design issues for the tools

Create a CameraHandler and create a good interface for the different cameras.

• Orbit camera.
• FreeFlight camera.
• Satellite camera.

Inherit all of them from Camera

Design classes of the path system

• Design how the paths will be (graphs or just linked node).
• Create the classes interface to support both.
• Create the Loader of paths from (.path) file.
• Create an importer / exporter tool to export .scene / .mesh or whatever and create a .path file.

HeightMap: Add importer from ogre mesh

We aren't using a height map directly since the level itself is made in Blender and is not modeled as a height map...
The importer should:

• Read a .mesh file and extract its vertices.
• Remove duplicated vertices
• Check that they are equidistant.
• Configure a HeightMap as result.

An idea of how to implement it:

• Get the number of vertices and get the AABB associated.
• Remove duplicated vertices.
• Pick one element of all the vertices and all the other vertices that have the same Y value and put all of them in a vector V (remove all this elements from the original vector).
• Sort(V) by X and check that all the elements have the same distance between them.
• Once V contains a valid set of elements, get the size of the vector, that should be always the same for the next iterations. Save the vector for further sorting (this represent a row).
• Iterate over the main vector removing elements and putting them into V and do the same process again.
• Once we have all the Vi (rows) sort the vectors (as if they were one element) by Y, and then we have the sorted matrix we need. V0 contain the first row, V1 the second and so on.

Check how to handle LOD

Check for the mesh and material stuff.
Check for the current Ogre implementations.
See if we will use an own implementation (this will let us separate from the RenderEngine).

[pathfinding]: Funnel / "Beautification" algorithm UnitTests

Implement some unit tests for this, probably graphical unit test will be the best...

[pathfinding]:Triangulated A* algorithm

Implement the A* algorithm to run over TriGraph.

Pathfinding

We will use constrained Delaunay triangulation as the "navmesh" as base of the pathfinding system.
We will basically need to do this:

• From a given .mesh, extract its triangles => and transform into a 2D graph (for this we will need to create a Graph structure (generic and be able to serialize directly into memory, using indices instead of pointers) ).
• Extract the silhouette of the graph (to apply Delauany) if we will use the external C++ library or if we will create a own implementation of the algorithm (n log n).
• Apply delaunay and use that triangulation as the base of the nav mesh.

After that we need to implement:

• The A* for triangulation.
• Check if we will use multiple levels for the graph.
• Create the "bitset" structure used with shorts and a counter (in the initialize() function) to avoid initialization (more memory but probably faster).
• Check what we will put in the nodes of the graphs (representing the edges of the triangulation).
• Check for the funnel algorithm and implementation to improve the last pathfind...

We will need to create also a tool to show this working...

Add the needed functionality to the camera for tools to math the reqs

• Configure the "Box Movement Zone" (restrict the movement to inside of that box).
• Avoid camera rotations (flag).
• Be able to point the camera down.

AnimPlayer should take a xml as input

We need to load meshes from an xml or .ini file

Add player's representation to move in the map

It could be the ninja or the ogre model or whatever.
We should be able to move it only in 2 dimensions at least.

PrimitiveDrawer

Add a primitive drawer to be able to create/add:
Planes (with colors), and also to be able to change them on runtime.
Lines.
PositionedText.
Boxes.
Spheres.

Finish PrimitiveDrawer::getFreshColour method

This method should return a new fresh color each time we call the function

PrimitiveDrawer material (color) is not supporting alpha right now, fix it

Check how to configure the material to be able to set the alpha passed in the "color" parameter.

[pathfinding]: Funnel algorithm or any "Beautification" algorithm to be more accurate

Check for the funnel implementation or implement any other Beautification algorithm.
Take into account the radius of the units if possible.

[core/trigger_system] Improve TriggerMatrix stuff

We can improve this just allocating everything contiguous in memory (custom allocator) or modifying the data structures (avoid std::vector). We can do this because we know the whole size before constructing anything.

Implement and test PathExporter

This class will read a .scene file and create the associated path file for it.
create this class and some unit tests using an already created .scene file.

Investigate how to put grass

defining areas and density of grass (putting randomly)

[core/space_partition] Add more tests for the MatrixPartition class

We are just checking basic stuff.

[pathfinding]: Create the TriGraph (for triangles)

This class should contain all the information of the triangle graph (nodes and links). It should detect non connected components and be able to save the information into a binary file (export/import).
Probably it will be a good idea to make some performance tests.

Investigate terrain

Check how we will do to use different chunks of terrain and avoid visual problems when we merge them into the scene.

SelectionHelper: Avoid using OIS (remove this dependencies)

Remove this if we use the input system wrapper (that is the correct way to do it)

Load floor representation

We need to load the floor representation

[pathfinding]:Triangulated A* UnitTests

do some tests / also create a graphic tool to verify this.

HeightMap: Support export / import HeightMaps structures into a file (as binary).

It should be simple since we only need to export a vector of floats and read a vector of floats right away.

Path_system: definicion / norma de como se crean en blender

Vamos a definir los paths con meshes usando la siguiente norma:
Cada path esta representado por un conjunto de meshes que siguen la siguiente logica:
Su pongamos que tenemos el "Path" con 4 nodos Nodo1, Nodo2, Nodo3, Nodo4 (donde de Nodo4 vamos directamente a Nodo1 => es ciclico) tenemos que generar 4 meshes (cajas o lo que sea como sigue):
tigre_1.mesh, tigre_2.mesh, tigre_3.mesh, tigre_4.mesh, donde tigre puede ser cualquier otra palabra (PERO IGUAL EN TODOS LOS MESHES QUE CONFORMAN EL PATH).
Basicamente lo que yo uso es solamente el .scene (NO ME IMPORTAN LOS MESHES), asique eso es lo que voy a usar, un .scene.