| |
March 7, 2004 |
Finally posted latest Demo
- Has the previously mentioned transition system.
- Updated the UML documents with the latest
class structure.
- Added animation controls to play the visualization at a variable speed and
easily fast forward to the point in the visualization you want to view.
What am I working on?
- Event animation system. Animations that fire on a DEVS event meeting some
required constraints/
- .ma file importing. ATLAS file importing.
- Model movement, and position editing facilities. Typing in the coordinates
is difficult. Cell model alignment ( useful for making roads, pipes, rooms,
etc, out of cell spaces )
- Maya model importing. I realize now this is almost a fourth year project
alone... hopefully I can find some code to use instead of redoing it.
- More flexible log file importing
|
December 6, 2004 |
Posted new Demo with enhanced functionality.
The demo is still rather limited, because the event transition system is not
functional. However, it is very close to being completed.
The transition system is composed of:
- Visual state transition rule system
- Each DEVS model has a set of visual states. { red cube, blue cube,
etc }
- Each DEVS model has a set of transition rules { (in red cube, 1.0
received on port "in", go to blue cube ), etc }
- Sorted by time event list
As the time is incremented, the events will be sent to the DEVS model states
to be processed. Any transition rules invoked by the event will cause the DEVS
model's to change visual state.
As the time is decremented, the visualization will be reset and rerun to the
point specified. Optimizations could include:
- Storing the DEVS model's visual state progression as the
visualization time is increased, so time can be reversed easily. This
could be optimized further by storing the model's visual state
progression only if when a transition rule is reversed there are
multiple valid previous states.
Cell DEVS model's have one transition rule set and one visual state set
for all cells, however the cell's have their own unique visual
representation with its own specific active state and location.
|
November 15, 2004 |
Progress:
- Finished log file parser
- Finished windowing toolkit development. Implemented windowing system
on top of GLUT
- Added Octary Partition Tree to organize visual information for
efficient rendering and object selection
- Posted Demo for a simple preview
I've decided to go with GLUT since it was simple to start building
something immediately. I've created a simple windowing system to use for
implementing a GUI to visualize the simulations.
I created a log file parser that creates a list of events loaded from a
log file. The DEVS models listed in the log file are created, and added to
the visualization as well. The parser still needs to be extended to handle
Cell-DEVS models as a special case of DEVS models.
The next step is to load data from .ma files to get the complete list
of DEVS models, and the starting state for the models.
After that the goal will be to associated a visual representation with
the state of a DEVS model, and allow the user to specify how the events
associated with that DEVS model will affect its visual representation. For
example, a Cell-DEVS model may have transparent boxes associated with its
cells, that change colour depending on their state.
Once simple examples of box and spheres are rendered correctly in the
visualization, and a method of manipulating visualizations with a GUI are
completed, a Maya model file loader will be created to allow assigning
more complicated visual representations to DEVS models.
Anticipated concerns:
- The simulation link will require a separate thread for interactive
simulations. The consumer/producer solution will likely be necessary.
This will require a cross-platform thread library.
|
October 20, 2004 |
Progress:
- Finished a simple UML design of the simulation viewer.
- Setup CD++ simulation environment on my workstations at home
- Successfully built/ran Life and ATM simulations
- Researched possible OpenGL cross platform windowing toolkits
- Started building parser for Simulation Log files.
UML Design Documents
The UML design documents will be updated as the project progresses.
They can be found here: UML Documents
Simulation Log Parser
The simulation log files appear to be in a standard format. If there is
any documentation describing this format it would be very useful to create
the parser. I will investigate further.
OpenGL Toolkit
Finding a suitable OpenGL cross platform toolkit is proving very
difficult. There is no exemplary solution to this problem that is open
sourced and free. I have narrowed it down to several choices which I think
are all valuable in some way:
GLUT:
The GLUT toolkit provides very basic windowing services to implement a
simulation viewer.
Pros:
- Widely implemented
- Simple to use
Cons:
- Only basic windowing functionality is provided
- Several inherit design limitations make building complex
applications difficult
NGL/NUI:
The NGL and NUI libraries provide extensive support for windowing,
widgets, mixed with OpenGL rendering. The library provides mechanism for a
variety of common tasks in 3D application programming. For example it
provides mechanisms to load 3D Studio Max model files.
Pros:
- Packed with functionality for quick application development
Cons:
- Currently has low performance when rendering windows
- Not as widely implemented as GLUT and therefore not as well tested
JOGL:
The JOGL library is an extension to Java that lets you use OpenGL
hardware accelerated rendering from a java program.
Pros:
- Allows mixing OpenGL rendering with the robust Java API
Cons:
- Relatively new API. Only support for hardware accelerated AWT
Panels.
|
October 2, 2004 |
Created page for simulation viewer project. |
|