jasonbcox / rocket Goto Github PK

Write unit tests to adequately test the Audio module without requiring user input. Please keep the actual audio output to an absolutely minimum to prevent random sounds during compiling. Keep in mind that unit tests are part of the build, so use discretion when writing unit tests that may take a long time to process.

Add joystick support along side the mouse and keyboard systems in Graphics::Input

After switching from GLFW 2.x to 3.0, holding down movement keys in the Graphics demo (main.cpp) only acts as expected for a short time (~1 second) and then stops. It likely has something to do with this: http://www.glfw.org/docs/3.0/moving.html#moving_repeat which is an expected change. Fix this so that holding down the keys results in expected behavior.

https://github.com/libuv/libuv

Consider using libuv for the following:

• Rocket::Network TCP/UDP
• Clock
• File System Access

Write Transform::positionWorld( vec3 position ). It's expected in version 1.0, but currently missing from the source.

1. Write the normal map shader
2. Implement a class that handles the normal shader in ShaderDefaults
3. Add a public function to the Mesh class that computes the tangents and bitangents for that mesh and stores them in private member variables (that are otherwise empty if the function is not called).

A useful tutorial for the implementation of normal mapping: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-13-normal-mapping/

Write unit tests for as many Graphics functions as possible that can be automated (ie. no user input needed). Also, keep in mind that unit tests are part of the build, so use discretion when writing unit tests that may take a long time to process.

Write functions for Transform that allow for rotation in world-space (space relative to the containing Scene)

The static libs need to be removed and replaced with the source code.
Move glew.h and associated headers and glfw.h to /GL/

Portions of the Graphics module are now stable enough to write documentation. Write documentation (for both users and developers) for the following:

• Universe
• Transform
• Mesh
• Object
• Texture
• Raster
• Sprite
• Scissor
• Shader

• Change floap from floating point to fixed point
• Add dynamic decimal precision/range. The integer and decimal representation can be traded. For example, more decimal precision reduces the integer range.
• roundToNearest()
• comparison operators: >, <, >=, <=

Migrate all existing documentation and begin adding new information, as the documentation is severely lacking. Doxygen was chosen as it is fairly standard and provides more features than Github Wiki. Note that many small changes will need to be made to the source files so that doxygen will pick up on the proper documentation/comments.

• Add Eigen to Rocket::Core
• Replace class members with Eigen equivalents
• Replace existing functionality with Eigen functions
• Implement any missing/incomplete functionality using Eigen

The set of character Sprites that are created when Object_BitmapText is constructed do not have their scene owners and/or mesh users properly set if Scene::addObject() isn't called immediately after initialization. As a result, they do not render at all unless enableTransparency() is called after Scene::addObject().

Debug has poor performance and design in general. Rebuild it so that it satisfies these requirements in a reasonable fashion:

• Debug Logger (must be able to print to terminal and files, with multiple debug levels)
• Assertion Handler to throw errors and kill the program while also displaying useful information
• Complex breakpoints (ex: A stateful breakpoint such that if local variable x results in the same value five times, then break) [2]
• Make a DebugTimer object that reports its time upon destruction

Some ideas for a completely revamped/awesome debug framework: (consider making a new ticket for these if you don't have enough time to implement them for version 1.0)

• Statistics on the number of calls of member functions [1]
• Statistics on uses of classes (which class has the slowest function calls, etc) [1]

[0] Consider this for hashtables used in this implementation: http://nguillemot.blogspot.com/2012/06/side-story-compile-time-string-hashing.html

[1.a] See http://www.stroustrup.com/wrapper.pdf for somewhat unintrusive wrapper classes
[1.b] An idea is to use a DebugTimer object that counts the timings of each call and then collects averages and other useful information. Include a function to reset all of these sorts of timers each frame.

[2.a] An idea for this is to output debug messages to cerr and then immediately raise( SIGTRAP ); to break. In GDB, do 'finish' to step out of the raise() call.
[2.b] Another idea is to write a script that generates a list of breakpoints that can be loaded into GDB using -x filename

1. Add README.md with information about ROCKET

2. Rename LICENSE.txt to LICENSE

Refer to this webpage for implementation : http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm See section "Quaternion Multiplication"

1. Write a shadow mapping shader. It still needs to be decided what type of shadow mapping will be used. Here is a useful tutorial for getting started: http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-16-shadow-mapping/ Read the entire article first (and more articles on the subject), before making any decisions or writing code.
2. Implement a class that handles the shadow shader in ShaderDefaults

Add a class that inherits Button to create elements that are draggable with the mouse.

Current plan for action:

1. Improve 3D model loaders. Choose one:
   • Use Assimp library for loading models
   • Create a new animation file format to be used in conjunction with .obj files
   • Find a new asset loading library
2. Add animation handling. Consider the following:
   • Skeletal animation shader. This seems like the best method. What are the downsides? Mostly they seem to be around decoupling the rendering from physics, which could be an issue in the future.
   • Compute animations CPU-side. Slow, but allows physics and other calculations on bone orientations directly.

Write a function called Scissor::centerViewpoint() that centers the camera in the viewing area of a Scissor.

ROCKET has yet to be compiled and tested on a Linux machine. Create a makefile that allows for easily compiling of each project. Collaborate to determine how to handle non-portable sections of code. Preferably, code segments should be written such that they compile on both Windows and Linux. If this can't be accomplished reasonably, separate similar segments with the preprocessor macros OS_WINDOWS and OS_LINUX.

All Input_Interactable's need to be placed in new files called Input_Interactable.h/.cpp. Create a new base class called Interactable. The functionality in Input_Interactable_Button will be split into Input_Interactable and a new class called Input_Button that inherits Interactable.

The new structure will be as follows:

Input_Interactable

• bool isHit (replaces Input_Interactable_Button's getStateSimple()

Input_Button : Interactable

• Input_ButtonState getState()

Input_Keyboard : Button

Input_Mouse : Button

Old Issue (used to be called "Change Graphics::Object_Newton to use interpolated curves instead of frame-by-frame updates"):
Object_Newton currently updates position, rotation, and velocities frame-by-frame which results in misalignments and other buggy behavior. Change this to use a curve that has a start and end position, along with information to define the curve (specs for this curve information TBA) including the time to travel along the curve (or speed, depending on the implementation). Given a delta for time, the position, rotation, and velocities should be easily determined and identical for every run of the application.

New, Better Issue:
Object_Newton is currently implemented using Euler's Method. Decide on replacing this with either Symplectic or Verlet Methods (or both). Additionally, allow for the option to use splines or other constraints to define the motion.

This ticket is currently a work in progress.

Add the correct UV coordinates for the cube primitive in MeshPrimitives.cpp

It would be nice to abstract away the GLFW window handler and GLEW init. Additionally, cleanup for both can be handled by wrapper classes tied to smart pointers. Create a single class called WindowContext that handles the creation of both of these and calls the init functions of both as necessary (only first instantiation). Make sure to look at Graphics/main.cpp and create wrapper functions for the GLFW processes in the main loop. GLFW doesn't need to be abstracted away in all of Rocket at this time, only at the main.cpp level.

Consider solving the broader error handling problem of trying to render any Mesh that doesn't exist in the Scene. At least, an error should be thrown when a Sprite is added and/or rendered in a Scene that doesn't contain the Sprite global mesh.

Mesh::load_OBJ isn't currently using Debug_ThrowError. Replace all current error methods with this one and add other error cases if any are blatantly missing.

Add a class that inherits Scene and uses glScissor to render 'subwindows' within the application. Adding text and objects is the same as a Scene, but they only render within some defined space of pixel coordinates.

In order to accomplish this, Scene::m_composites must be implemented.

Note: This ticket previously referenced scrollable subwindows, but that should be implemented by the user once scrolling bindings are available in the Input classes.

Implement RANSAC with the ability to utilize lambda functions so that heuristics can be applied to the generic RANSAC implementation. Please note that speed is of utmost importance for this implementation.

When parent is not NULL, it is automatically assumed to be a member of the scene. Include a check, and add the parent to the scene if necessary.

Find a way to fix this!

Note: Instead of the REAME, all changes should be in the Setup ROCKET Engine page of the docs.

1. Add a section for instructions on setting up the development environment
   • Libs to install through apt-get:
     • X11
     • OpenGL
     • GLEW
   • Libs to install manually:
     • GLFW
2. Add a section for media resources (for example, to run the Graphics demo) as media are not part of the repository

Calling AudioDevice::addSound() after AudioDevice::startStream() may cause a race condition where the audio callback ends up calling Sound::addToBuffer() on a NULL pointer. Determine why this is happening and fix it.

Check out PortAudio + libsndfile

Delete the test fonts images and data. Replace them with images generated via the FreeType library.

Move the entire project to be CMake focused. For now, all Visual Studio files will be removed (to be maintained later) and replace with CMakeLists that accomplish something similar while also adhering to the new changes in this ticket.

• Remove all Visual Studio files
• Move all unit tests into the same directory as the module name (ex: ZTest_Core unit tests go into Core)
• Move Graphics/main.cpp into unit test files and remove the old main.cpp
• Add CMakeLists.txt files in each module and the top-level directory to reflect all of these changes and properly construct builds
• Update GLFW to version 3.0.1 because it utilizes CMake. See the transition guide to help with converting from 2.x to 3.0: http://www.glfw.org/docs/3.0/moving.html
• Compile and test on a linux machine. Windows support will come at a later time when the project has stabilized.

Update ROCKET Engine to use C++11 instead of C++07/C++TR1

• Remove namespace containers for enums and change all enums to be strongly typed (enum class).
• Switch to initializer lists where appropriate
• Add 'override' and 'final' to classes and members
• Switch to range-based for loops where appropriate
• Revamp everything to use smart pointers as appropriate

Make sure to update the wiki to correctly reflect each of the changes above.

Make sure all PacketAccumulators are properly destroyed in Network's destructor.

A Button takes a Sprite to display and the position to display it at. The sprite's UV coordinates should be treated as sections for the button's animation. Add animation support to Sprite as well.

A ToggleButton inherits Button and should have toggle() that switches its value.

For Scene: Add two key-value maps with Mesh* keys and a set of Object* values (for opaque and transparent objects) so that each Scene keeps track of its own objects-mesh relationships.
For Mesh and Transform: Record the number of scene users. Only delete if the count reaches 0.
For Transform: only delete children in the destructor if that number reaches 0.

Fix this. Contact Jason if you need a working copy of a Windows formatted .obj file.

• toUpper()
• toLower()
• replace()
• trim()
• split() on arbitrary delimiter

Specific requirements for each TBA.

Standardized naming schemes are needed for namespaces, classes, enums, variables, and functions. Fix all naming scheme issues in ROCKET Engine. Before closing this ticket, create a wiki page that clearly defines this scheme, along with examples as necessary.

Implement according to the new naming scheme.