TODO

Windstille ToDo
===============

This is a list of tasks and issues that might be worth to implement or
fix. This list is however not an authorative list of things that must
be done, its a collection of random things that pop up during
development, therefore not everything in here might be well thought
out or worth to implement. Use your brain before implementing anything
on this list and always think about how useful a new feature would be
in the context of the whole game or if a potential performance
enhanchment, actually enhanchmes anything at all.

Testing
=======

* write testcases (can be manual) for the SceneGraph

* how to implemented stencil in the editor?

* create some better graphics for stencil testing

Timeline
========

* turn play button into a toggle button

* animation export:
 
  - exported animation doesn't need layers, but layers could still be
    useful for later editing

  - might not need a navgraph

  - needs all objects

  - what happens with the animation before the start and after the
    end? does it persist or disappear?

  - exported animation must be almost complete SectorModels

  - recursive animation is needed, i.e. animation that contains other
    animations

  - exported animation basically is a full SectorModel, there is no
    easy way around that

  - could share a SectorModel shared_ptr between two tabs, thus
    editing animation in one, previewing in another, would need a way
    to handle change events

* need a way to edit keyframes instead of just inserting new ones

* implement load of timeline

* using UI manager doesn't work when toolbar is on the Notepad

* add ability to scale selections

* add ability to set FPS

* some timelines, such as Vector2f stuff could be visualized by graphics in the scene

* add snappping to frame borders (i.e. no float, but just well defined int positions)

* make snapping optional, add a button for it

* add scrolling (middle button and scrollbars)

* add overlap-avoidance

Animation Subsystem
===================

* animation objects bundle the pointers to objects along with
  curves that describe changes to those objects

* curves can manipulate all kinds of properties of an object, such as:

  - rotation
  - position
  - color
  - ...

* curves can also used to start or stop an object, for example a curve
  for a movie-object might have actions such as:

  - start
  - stop
  - reset
  - set_pos()

  That can be placed on a curve

* there is no global timeline, timelines are local to an animation object

* animation objects can be recursive, i.e. an animation object might
  start other animation objects

* there are two core types of animation objects:

  - prefab animations that are saved to their own files and only
    linked into the scene, they provide their own objects

  - plain animations that are part of the main scene, they can
    manipulate any object in the scene

* two animation objects can access the same objects for animation, but
  not at the same time as that would cause glitching (i.e. you might
  have a door-open.anim and a door-close.anim)

* ignore tweens for now and implement the basics first

* implement load/save for timeline

* make timeline proper part of Document and SectorModel

High Priority
=============

* add a GenericObjectModel to the editor that just stores all the
  information in the FileReader and writes it out again, use it for
  all objects whose type isn't known by the editor

  * implement a way to clone a FileReader, keep it and pass it to FileWriter
  
  * simply implement a way to serialize a FileReader to string and
    write that out with FileWriter

* enhance the ObjectSelector to allow different object types (particle
  systems, highlight, light, etc)

* implement objects properties in a generic fashion:

  GenericDialogBox::add_int(const std::string& name, const boost::function<void (int)>& callback);
  GenericDialogBox::add_enum(const std::string& name, const boost::function<void (int)>& callback);
  GenericDialogBox::add_string(const std::string& name, const boost::function<void (int)>& callback);

  * apply changes instantly
  * use the Undo/Redo system

Overview
========

* add a way to force render path (i.e. which Compositor to use)

* do demo sector with burning barrels, snow and steam, to get the
  feeling of cold, could extend the trainstation to that

* Doll can get stuck in infinitive rolls (Sprite3D::switched_actions()
  doesn't trigger properly or is missed)

* use SceneGraph in objects that already use VertexArray (Swarm)

* use SceneGraph in the editor 

* add z/layer ordering to NavGraph

* add trigger to NavGraph

* build a more complete scenario

* tweak graphics (lightmaps are to big, stuff doesn't tile properly, etc.)

* implement jumping: 

  * calculate an arc from the current pos to the next ledge or landing spot

  * let character travel that arc

* implement a grid display in the game engine

* implement debugging information that shows the screen and world
  coordinates of the mouse position in the game and in the editor

Animation
=========

* Walk animation should be speed up by 1.25, so its half of run speed

  Real World Numbers:
  -------------------
  * walk:     5 km/h
  * jogging: 10 km/h
  * run:     20 km/h (1500m run)
  * run:     30 km/h (100m sprint)

* current run animation, jump width, etc. should be meassured in a test level

Pathname/PhysFS
===============

* Sound stuff still uses PhysFS, should be switched to std::ifstream

SceneGraph/Compositor
=====================

* could make use of occlusion query, to hide highlight sources when
  they are covered:

  * http://www.opengl.org/registry/specs/ARB/occlusion_query.txt
  * http://developer.download.nvidia.com/SDK/9.5/Samples/DEMOS/OpenGL/occlusion_query.zip

  Have to figure if this would work with alpha textures:

  * void glAlphaFunc(GLenum func, GLclampf ref);

* add support for multipass rendering with shader scripts (to simulate
  glass and things like that)

* play around with post-processing effects:

  * bloom

  * vignetting

  * motion blur

  * film grain

  * lense flare

SceneGraph
==========

* Drawable::update(float delta): Do we need it? What exactly should it
  do? Or should we do it via GameObject::update(float delta) { m_drawable->update(delta); }?

* change the editor to use the SceneGraph instead of the SceneContext API

* new levelformat use a different coordinate system then the old one
  (128px = 1meter instead of 64px), figure out which to use before
  doing the final conversion

* might have some advantage to place stuff in a QuadTree, when you
  have a complex level

* SceneGraph could be used to promte certain states to children such
  as: color, alpha, visibility (would be mainly useful for the editor
  to hide layers or highlight them)

  * requires Nodes with state

  * requires a pointer to the parent (boost::weak_ref)

  * parent nodes should be a different type 'GroupNode' or something
    like that

  * draw() { set_color(color * parent->get_color()); }

  * all nodes have a parent (the SceneGraph becomes one or gets a root
    node)

* SceneGraph could be used to promote rotation and scaling to children
  (i.e. ModelviewMatrixDrawable)

Navigation Graph
================

* add raycasting

* NavigationGraph needs hooks into scripting, so that things can be
  triggered when a character passes over a specific trigger node or
  things like that.

* NavigationGraph Edge Types:

  * ground    - usual stuff, you run on it
  * wall      - vertical stuff
  * ladder    - stuff you can climb (maybe different version for climbing: left, right, front)
  * stairs    - 45 degree, must follow special step spacing
  * smallwall - boxen and stuff you can jump over or climb on

Display
=======

* image-grid in Sprite seems broken

* SurfaceManager::load_grid() bypasses TexturePacker, doesn't do
  border pixel duplication

* maybe add special support for opaque textures, i.e. Textures with
  1-bit alpha, which could be used to bucket sort drawing requests and
  reduce texture switches (in case those ever start posing a problem)

* figure out how to enable mipmapping into the tile and surface packer
  (no longer needed as both tile and surface packer are considered obsolete)

* Display::aspect_size is ugly, turning it into a Display::set_size()
  wouldn't help much, should be part of some GraphicContext object
  that is passed around to Drawable::render()

* OpenGLState class is really slow (rewrite it to not use std::map, also remove the impl allocation)

* Display::push/pop_cliprect() doesn't handle different aspect-ratios properly

* implement aspect-ration switching at runtime (menu entry is there,
  just no code) and change default screen ration to that seen in the
  artwork pictures (FIXME: full resolution switch would be more useful
  then just aspect-ratio switch)

* make lightmap resolution independent (done, but an artifact remains
  when the resolution isn't dividable by LIGHTMAP_DIV):

  1680x1050 -> 1050 / 4 -> 262.5 -> 262 * 4 -> 1048

  two pixel missing at the bottom

Porting
=======

* Microsoft compiler don't have stdint.h, need to write a replacement header

Logging
=======

* implement logging and make it useful

  * log when a file is loaded (Surface, Font, Level, etc.)
 
  * log when a sector is changed

  * include a timestemp in the log

* Editor Logging:

  * print Gtk events

Particle System
===============

* add collision detection or bounding boxes to particle systems so
  that smoke doesn't escape through walls

* ParticleSystem could be hooked up to scripting

* particle system doesn't take delta into proper account, breaks when
  doing set_game_speed(0.1) (might be issue with game_speed, not the ParticleSystem)

* add a alpha ease-in to the particle system to make better fire system

* add a switch to turn of blending in the SurfaceDrawer (i.e.
  currently stuff fades out, but for some things that isn't a good
  idea)

* add arial particles for effects like snow

* maybe do snow as fullscreen effect by just shifting the UV
  coordinates (wouldn't work for smoke/fog)

* the particle system doesn't init correctly, causes particles to be
  in the wrong spot on startup


Scripting
=========

* http://udn.epicgames.com/Three/UnrealScriptReference.html
* http://www.modwiki.net/wiki/Scripting
* http://developer.valvesoftware.com/wiki/Scripted_sequence
* http://developer.valvesoftware.com/wiki/Faceposer

* add a way to bind keys to script functions for use in debugging

  bind("F9", "toggle_this")
  bind("F9", function() { /* do stuff */ })

* maybe: introduce some cleaner seperation between scripts that are
  allowed to suspend and those that aren't

  - name them differently
  - name their trigger/hooks differently
  - remove suspendable functions from roottable
  - put suspendable functions into a different namespace
  - ...

* add function that clears all scripts and rereads them from file (for
  debugging)

* add check that looks into a scripts root table to see if init()
  and/or run() is present

* add ability to wait on custom event and add ability to fire of a
  custom event:

    wait_for("bob arrives at bar");
    ...
    fire("bob arrives at bar");

  also add abilty for callbacks:

    register_callback("bob arrives at bar", function(){
       // do stuff
    });

  In which VM shall this be executed? In a new one? Wouldn't that be
  the same as:

    spawn_function(function(){
       // needed so that the callback can be called multiple times 
       while(true) { 
         wait_for("bob arrives at bar");
         // do stuff
       }
    });

  Also an ability to create unique events could be useful (not clear
  for exactly what, so implementation can wait):

    shared.event_id <- wait_for_unique_event()
    ...
    fire(shared.event_id);

* think about if scripts spawned in a sector should be parented to the
  sectors init script or to the root_vm, the later one is currently
  the case, the first one however would make it easier to share
  variables between scripts, on the other shared variable should often
  be available across sectors, so a better sharing mechanism is likely needed

  -> scripts could share state via a 'state' table defined in windstille.nut

* add option to SquirrelThread to be removed after its done or removed
  when a specific function is called (useful for spawning functions)

* reentering a sector twice barfs because:

  std::exception: Squirrel error: sectors/apartment/init.nut:
  SquirrelThread: couldn't call 'run' (sectors/apartment/flicker.nut:
  ScriptManager::run_script(): Script must be idle to be 'run()')

* ScriptableObject is a bad name, since all objects should be
  scriptable in one form or another

* miniswig does not support __suspend with a return value, should be
  fixed, since Squirrel can handle it. Trouble is that the return
  value is created by the sq_wakeupvm() call, not by the
  sq_suspendvm() one, so its not actually in the wrapper code, but in
  the normal C++ code

  Return value has problem, works in same cases, but returns NULL for
  barrobot.nut in apartment.wst

* Currently we wakeup on conditions that are broadcasted to all
  scripts, in some situation it might make more sense to attach the
  script directly to the object that sends the signal

* some functions in data/scripts/windstille.nut require '::' before
  them so that they can be found, not quite clear why or exactly when
  this happens, seems to happen only in classes, not in normal
  function, in theory at least they should get resolved by delegation
  from the current environment to the roottable, but that doesn't
  happen

* objects are currently all exported to squirrel, while we should
  probally use id-tags and accessor functions instead:

  bob = get_object("barkeeper")
  bob.say()

* player can launch PDA or inventory when in a dialog, this will break
  the script

* currently the ScriptManager is global, meaning scripts are never
  cleaned up on Sector changes, this needs to be fixed

* figure out proper 'namespaces' for the scripting, i.e. gfx_ or
  video_ for all display related stuff and so on, so that
  tab-completion works better and things become more readable

* conversations really should be data with hooks for scripts, not pure
  scripts (FIXME: not clear if there is enough benefit and flexibilty
  to try that)

Input Handling
==============

* pressing left and right at the same time and then releasing one of
  them causes the input to get stuck in the wrong direction

* input in Navigation Graph test uses deadzone, but shouldn't

* remove secondary controller, instead accept multiple --controller
  options and store the files in a list

* analog trigger handling is a little problematic, since the axis is
  neutral at -32768, not at 0.

* src/input/controller.hpp should keep not only the current state, but
  also the last state, this would allow proper detection of button
  presses and axis movements over a threshold

* Input deadzone is problematic when trying to get angle of a stick,
  deadzone needs to act different there then when X/Y are handled
  seperatly. Temporary workaround is to move deadzone out of the input
  code into the app code, which is problematic as well. Alternatives
  might be more high-level ways to access the stick:

  void get_stick_state(X_AXIS, Y_AXIS, &angle, &length);
  bool stick_is_centered(X_AXIS, Y_AXIS);
  float get_axis_state(X_AXIS, bool ignore_deadzone = false);

* change of input context is troublesome: when the user selects a
  dialog and confirms it, the character starts to walk into the
  direction that the player indicated, because the stick still points
  in that direction after OK_BUTTON is pressed.

  Possible solution: wait till the controller is in neutral position
  before sending events to the next Screen

* reconfigure the controls to behave like Tomb Raider (Xbox360 pad:
  A:jump, B:duck, X:run, Y:interact), move PDA elsewhere

* implement proper dead-zone in input handling

* allow to load multiple controller config files at once

* add zoom via xbox360 analog trigger buttons

* mouse support for menu

Sound Handling
==============

* split music, voice and sound fx into seperate context or allow to
  change their volume independently by other means

Miscellaneous
=============

* should filenames in the config file be absolute or relative to something?

* View class could be done away, as it doesn't have any clear purpose

* replace lisp::Writer with custom FileWriter (used in config)

* add (maybe) a LispWriter::start_section(name, bool compact) to create:

  (object (name "aeu") (...))

  instead of

  (object
    (name "aeu")
    (...))

* make FileReader work more like lisp::Writer, i.e. less
  const/functional, keeping the current cursor position. Main issue
  with the current FileReader is the way sections are handled, which
  isn't pretty

* add way to TextArea to layout text with a fixed indent after a
  linebreak (for use in the PDA):

  Bob: "Hi, how are you, yada yada yada yada yada yada
        yada yada yada yada yada yada yada yada yada yada
        yada yada yada"

* cleanup the parenting code

* set dynamic maximum size for auto resizing Menus depending on
  resolution

* animation must be less strongly coupled to movement

* add way to skip through SpeechManager Speech lines (B-button)

* raycasting in laserpointer is broken, doesn't work if angle is 0
  (maybe not worth to fix since it will be replaced with
  NavigationMesh) [obsolete]

* get rid of global game_time variable

* maybe create an additional layer in SceneContext for drawing things
  like Speech and other worldspace GUI elements to it

* implement proper word wrap in SpeechManager and also add code to
  'unstuck' speech bubbles when they go over the window border.

  Also SpeechManager should act in worldspace, not screenspace or
  something clever inbetween.

* cleanup TextArea/text_area.cpp, having scrolling and running text
  together doesn't make all that much sense, also functions are too
  large

  Scrollbar is to far on the left, outside of the actual Rect, need to
  shrink horizontal width if text needs a scrollbar

* scrap inventory and redesign it

* join Player and Character somewhat or derive one from the other, so
  that one can have scripted people running and jumping around (see Doll)

* add support for empty sectors (sectors without a player character,
  for use in intro.wst and similar cutscenes)

* HUD elements are whole screens, should be something simpler, also a
  seperation between HUD (energybar, speech, etc.) and Overlays
  (inventory, PDA, etc.) might be good

* do not save command line options given on the command line by
  default or add a --vanilla option or so

  or
   
  rewrite Config class and properly seperate config from command line
  and config done via option menu, i.e. command line settings
  shouldn't be persistent unless told so

* Specify the capabilites that the different subsystems need to have

OpenGL
======

Test for:

GL_ARB_texture_non_power_of_two:                               MISSING 
GL_ARB_texture_rectangle:                                      OK 

* OpenGL 2.0 supports non-power-of-two textures with mipmaps, that
  should be used instead of the texture packer [mostly done, except
  for backward compability stuff]

* mipmapping needs to be enabled

* check for features before using them:

glewInit();
if (glewIsSupported("GL_VERSION_2_0"))
printf("Ready for OpenGL 2.0\n");
else {
printf("OpenGL 2.0 not supported\n");
exit(1);
}

* Check if http://developer.nvidia.com/object/np2_mipmapping.html can
  be used to improve visual quality or if GLU is already using that

Profiling
=========

* figure out why running the game engine is extremely slow in
  valgrind, while pause menu is fast

* gprof results:

 16.90      0.60     0.60    47535     0.00     0.00  TileMap::draw(SceneContext&)
 15.21      1.14     0.54 37910690     0.00     0.00  VertexArrayDrawingRequest::texcoord(float, float)
 14.37      1.65     0.51 37974070     0.00     0.00  VertexArrayDrawingRequest::vertex(float, float, float)
 11.55      2.06     0.41    79225     0.00     0.00  Sprite3D::draw(Vector2f const&, Matrix const&) const
  3.94      2.20     0.14  1133610     0.00     0.00  OpenGLState::activate()

Bugs
====

* drawing in the editor is broken after loading a level, only gets
  fixed when toggling Light layer, (bug in OpenGLState maybe?)

* quickly tapping forward-back-hold down forward makes your character
  play the walking animation without actually moving anywhere
   
* Pressing left (or right), jump and and run at the same time throws an
  exception that causes the game to exit:

  std::exception: No marker with name 'RightFoot' defined in action 'Stand'

  in general the game shouldn't crash when stuff isn't found, but
  instead fallback to placeholders and give a warning message on the console

* miniswig causes bison++ to crash

3D Things
==========

* bone animation

* change the game to a righthand coordinate system

Level Design
============

* create a test sector that as open sky, currently most test levels
  are indoor

* implement light switches in apartment

  Currently the light switch-off sequence is done in the use script,
  this however makes it blocking, it would be nice if the switch-off
  sequence could be handled in a seperate script, but that would
  require a way to apport that script, since else a switch-on could
  collide with a switch-off script

  possible solution:

  function init() {
    lamp_sequence = spawn_script_norun("lamp_sequence.nut");
  }

  function init() {
      ...
      lamp_sequence.call("switch_on");
      ...
      lamp_sequence.call("switch_off");
      ...
  }

  The lamp_sequence.nut script would take control over the process and
  buffer call's when it is busy, once no longer busy it would pick the
  next task from the stack. Different scripts could use different
  stack behaviour, i.e. in the lamp_sequence() it would be useful to
  have a task-stack of size 1 and discard everything else.

  In addition to spawning a script, it would be good if there would be
  a way to spawn an object or a function, since that way the logic can
  be kept in one file.

  spawn_function(function() {
     obj <- FoobarObject();
     obj.run();
  })

* implement a door with two segments that slide sideways when the door
  opens, think about how that can be implemented properly in scripting
  (two parallel events that have to be waited for)

  -> a solution in scripting isn't a good idea here, this is something
     that would be much better solved by a 2D animation system
  

Random Things
=============

* add a music player that allows to play all music files of Windstille

* UTF8 support is missing in:
  
  - BabyXML
  - TTFFont
  - Console

* Add more markup to TextArea: (not really needed with LucasArts-like dialog)
    <font color="#ffbbcc"></font>: Use arbitary color
    <b></b>: make text properly bold
    <i></i>: make text properly italic 

* create a mission that is playable

* add line numbers to error messages from lisp

* rotation in 3d model viewer feels a little weird, could maybe be
  improved somehow

* using a non-square pixel aspect ratio leads to ugly fonts, fonts
  could be rendered with that aspect ratio in mind so that they are
  'pixel-perfect', instead of scaled by OpenGL. This requires:

  - a UI that is reasonably flexible to handle changes in font size
  - some code that scales/unscales the Font before drawing it

* update random number generator:
  http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/index.html

Graphics
========

* do not make light sprites larger then 256, maybe even smaller is ok
  (large light is a waste of space, as you don't see much pixelation
  in gradients)

* do *NOT* use power of two textures, use multiple of 64/128 instead
  (128 is easy to snap, power of two doesn't help, since textures are
  packed and get a 1px border added)

* generate .png's automatically from .xcf's via scons

* figure out a way how to properly organize graphics/decal

* Model lower-poly version of Jane and stuff

* aspect-ratio/resolution options:

  - let the user select a resolution from all the ones that are available from X11 (see Pingus for code)
  - have "aspect-ratio: auto" (calc from resolution) and 5:4, 4:3, 16:9, 16:10 overrides

* remodel titlescreen as 3D model

* setting glLineWidth() leads to some interesting artefacts on the
  menus which might be a cool effect

Console
=======

* add Ctrl-a, Ctrl-k shortcuts to console

* save command history of the console between runs

* console doesn't adopt to screen size (make it not fullscreen
  covering)

* create a UTF32 string class for use in console, basically
  basic_string<uint32_t> and a convert function to UTF-8 should be
  enough

* implement more advanced tab-completion for console

* print and println behave different on console (?)

Editor
======

* mark the zero-spot in the editor (i.e. thicker lines for zero)

* 'delete layer' should set the layer selection to something valid

* add a toggleable safe-area overlay that shows how much fits on a screen

* SceneGraph needs to be updated while drag&drop is in progress

* delete/remove/erase naming is a bit mixed up in a few places

* being able to directly mark Edges still feels wonky, need to rethink the thing again

* copy&paste works only very limited with edges, i.e. copying from one
  sector to another causes crazy stuff to happen as the nodes it links
  to are on another sector

* draw NavGraph lines thicker (i.e. glLineWidth())

* color code them by layer (how to figure out the color?)

* add special drawing for different edge types (i.e. draw stairs for stair type edges)

* snapping for navgraph is limited to moving the object, should also
  work when creating the nodes in the first place

* horizontal/vertical navgraph edges are near impossible to select
  (bounding box is just 1px height)

* objects can't snap to NavGraphNode's as they are not part of the
  normal layer structure, would also need inverse point-snapping to
  work properly, as they shouldn't snap to the bounding_box of the node

* implement a stop-watch HUD element

* it takes 25sec to run through every corner of the worker.wst map (75 meter + stairs in size)

* add auto-visible button similar to auto-lock button

#0  0x081115a7 in Vector2f::operator+ (this=0x0, other=@0xbff04558) at src/math/vector2f.hpp:56
#1  0x0816e342 in Selection::on_move_update (this=0x92043b8, offset=@0xbff04558) at src/editor/selection.cpp:130
#2  0x0816c80f in SelectTool::mouse_up (this=0x8999dd0, event=0x8f878a0, wst=@0x8f8e5a0) at src/editor/select_tool.cpp:205
#3  0x08174a22 in WindstilleWidget::mouse_up (this=0x8f8e5a0, ev=0x8f878a0) at src/editor/windstille_widget.cpp:372
#4  0x08177788 in sigc::bound_mem_functor1<bool, WindstilleWidget, _GdkEventButton*>::operator() (this=0x902fc34, _A_a1=@0xbff04664) at /usr/include/sigc++-2.0/sigc++/functors/mem_fun.h:1851
#5  0x081772bf in sigc::adaptor_functor<sigc::bound_mem_functor1<bool, WindstilleWidget, _GdkEventButton*> >::operator()<_GdkEventButton* const&> (this=0x902fc30, _A_arg1=@0xbff04664)

* add a NextLayer, PrevLayer keyboard shortcuts

* add AutoVisible button to Layer dialog

* make the game runnable from within the editor (reusing image cache and other stuff)

* Fix screenshot support (very crashy/buggy on different screensizes and stuff (padding error?))

* unify delete/remove/erase naming a bit

  * STL convention: erase for iterators, remove for value, delete isn't used

* figure out a way to rename image files without breaking the levels
  (use uuid? md5sums? alias files?)

* new boost1.37 seems to be missing boost_signals, instead it has
  boost_signals-mt, do we want to get funcky with configure checks or
  ignore and stay boost1.35 or so?

* add special blocker objects, i.e. black boxes that have a
  configurable fadeout

* add support for collision shapes, to mark lights or other objects as
  shootable/interactable

* a type of NavGraphNode that only sits on the graph without the
  ability to deform it could be very useful to represent doors and
  such

* a trapezoid deformation for quads could be useful for lights

* add glLineWidth() to OpenGL state and use it in NavGraph drawing/highlighting

* make NavGraph insert tool automatically split edge when new nodes is
  on edge

* add keyboard shortcuts to flatten (set same x or y value for all)
  current NodeSelection

* NavgraphTool (see Construo):
 
  - in Construo insertion and selection are two different tool

  Insert Tool:
  ============
  click on empty space: insert_node, start_edge
  click on node: start_edge
  right click on edge: delete_edge
  right click on node: delete_node, delete_connected_edges

  needed modifier (shift, ctrl, alt):

   - horizontal/vertical/45 degree
   - continue-line, allowing the insertion of a multiple control point
     line in a single step

  Select Tool:
  ============
   click on node: nothing 
   click on empty space: selection rect
   click on selection: drag
 
   right click&drag rotates
  
* replace PointerHandle in NavigationGraph with boost::shared_ptr
  and/or boost::weak_ptr, tricky, since it easily leads to recuriseve
  links

* turn the Selection into a kind-of ControlPoint, this would allow to
  keep the move/offset logic out of the ObjectModel

* share SoftwareSurface via Manager class, generalize Manager classes
  -> template

* add binlocate support

* add an icon to the editor

* remove the empty default sector when loading another level and the
  default sector hasn't been modified

* add a way to adjust the ambient lighting (button to change color) 

* maybe make Layers not be hardwired into the level struture, but add
  them as independed meta-data:
 
  (layers
    (layer (objects 1))
    (layer (objects 2 3)))

  (objects
    (decal (id 1) ...)
    (decal (id 2) ...)
    (decal (id 3) ...)
    ...)

* add shift-toggle to rotation to 90/180/270 degree, etc., pass
  GdkEvent modifier mask to control point

* things are getting messy, we have: 

   - hflip, vflip (works on UV)
   - scale
   - angle
  
  This all could be replaced with a translation matrix:

   + would make things more general

   - flipping via uv is trivial and doesn't lead to any trouble with
     float instability/snapping, could be easily extended to
     90/180/270 rotations (see Pingus source)

   - rotation and scale can't easily be reset or edited separately
     with matrix

   - float instability might lead to gaps between objects

* (id ...) is a string'ified pointer, while this work, this causes the
  levels to be different after each and every load/save cycle, which
  leads to ugly huge diff in SVN, should be something more constant

* add rectangle overlay that indicates the visible area of the game (i.e. one screen in current zoom size

* bounding rect doesn't rotate, controls don't rotate

* ControlPoint bounding rect scales, which it shouldn't, ControlPoint
  offset does to (scale and rotate handles get close together when
  zooming out)

* reduce icon padding in the ObjectSelector

* implement Blender-like grab-handles, that toggle between
  scale/rotation/etc., but also allow limit of move along the x- or
  y-axis only

* figure out how to properly draw controls in the Workspace (resize,
  rotation, vertices of a quad),

* make use of Statusbar
  - display mouse coordinates in WorldCo
  - display what Ctrl/Shift do for the current tool

* add more ways to snapping objects:

  - snap to snap-points
  - snap to integer positions (done, but should be optional, won't work with scale/rotate)
  - snap to grid (IMPORTANT)

* reevaluate the current parent/child implementation, since its very
  tricky currently to move a parent without affecting the child, which
  might be useful in some situation (i.e. hold Ctrl pressed to move
  only the parent, not the children). Other issues:

  - flipping doesn't work for parented objects when parent is in the
    selection

  - parents could be handled like normal objects, but with the
    SelectTool traversing all children and marking them before the
    move begings, Ctrl could be used to toggle this behaviour (sounds
    a little weird, we also don't have a way to iterate children from
    a parent)

  - having classic groups of objects, where clicking one object moves
    all in the group could be useful (like when each object is parent
    to each other object in the group), wouldn't allow an easy way to
    edit objects in the Group, which however might be a good thing

  - current parenthandling makes things like flipping much more complicated

* raise/lower of multiple objects at once is a bit wonky, when objects
  reach the bottom/top they will change their relative order in the
  selection (not a big deal with layers)

* set cursor in LayerManager when loading a level, as not setting it
  leads to crash and trouble

* QuadTree could be useful when levels get larger

* New Layer System:

  - there might be a need for special layers, such as a background
    layer or a color gradient layer, that doesn't contain objects, but
    is meaningful by itself

* add button and keyboard shortcut to mark/unmark all layers in the layermask

* add a way to move object to a different layer

* background pattern goes away when Color pattern is disabled, since
  its draw to the Colormap

* use last object in selection as parent instead of first? might be more natural

* use the right button for something

  - zoom tool: zoom out
  - select tool: context menu
    - delete object
    - duplicate object
    - parent object
    - move to different layer

* highlight content of rect selection while the rect gets dragged

* highlight map is problematic, since objects don't cover highlights
  (i.e. train infront of a highlight in the background), maybe
  rendering a stencil mask might help, other alternative would be
  occulsion querys, but they only work for Geforce3 and Up. Have to
  wait and see how much of a problem that is in practice, ray-casting
  would be doable as well, but won't work well with 3d sprites or
  scaling

* add Blender like EmptyObjectModel

* spacenav support for scrolling?

* do a continous zoom while the zoom-button is pressed (timeout callback)

* ObjectProperty Dialog:

  Dialogs must be generic and usable by all Objects, supported type
  requirements:

  - Vector2f
  - std::string
  - Layer
  - Color
  - int
  - float
  - bool
  - enum

* add keyboard shortcut important stuff:

  - color, light, highlight toggle (1,2,3 are currently used up for the object selector)
  - next/previous layer: Ctrl-PageUp/Down

* add second toolbar, first one is getting a little crowded

* lightmap objects are hard to see (not that big an issue with the new
  layer system)

* decal color needs to be adjustable

* make duplicated objects insert near those from which they where
  cloned (maybe have "Paste" and "Paste On Top")

* think about Undo/Redo

  * CommandGroupCommand  [done]

  * NodeAddCommand       [done]
  * NodeRemoveCommand    [done]
  * EdgeAddCommand       [done]
  * EdgeRemoveCommand    [done]
  * NodeSetPosCommand    [done via ObjectSetPosCommand]

  * UndoCopy
  * UndoPaste

  * ObjectAddCommand      [done]
  * ObjectRemoveCommand   [done]
  * ObjectReorderCommand (raise/lower)

  * ObjectSetAngleCommand [done]
  * ObjectSetScaleCommand [done]
  * ObjectSetPosCommand   [done]
  * ObjectSetParent       [done]
  * ObjectSetHFlip        [done]
  * ObjectSetVFlip        [done]

  * LayerAddCommand     [done, except proper order]
  * LayerRemovedCommand [done, except proper order]
  * LayerReorderCommand 

  * FunctorCommand(boost::functor<void ()>& undo,
                   boost::functor<void ()>& redo); [done]

* implement non-Surface based objects:

   - seperate Surface stuff, turn it into a scaleable/rotatable decal quad
   - simple path
   - Sprite
   - Sprite3d / Character

* ObjectSelector/IconView allows drag&drop even when nothing is
  selected, leading to a Grumbel dummy image drag&drop without effect

* implement dialog to change level properties:

  - name
  - ambient color (Gtk::ColorSelection)
  - level size (?)

* Sandbox Pro&Contra:

  + very fast getting in and out of the game
  + edit game while it is running
  + no obscure version incompatibilty between editor and game objects
  + game editability can be reused in scripts

  - game and editor engine gets more complex

* Sandbox Implementation (similar to Feuerkraft):

  - add introspection to objects via PropertySets (see Feuerkraft),
    allows animation as well as easy editing and serialization
  - add a draw_editor() or a draw(bool editor)
  - some stuff for modifier handles

* make Windstille flexible enough so that it can work in non-SDL
  settings, more exactly it should be embeddable into a GtkWidget (or
  shall the editor be completly seperate?)

* Editor Toolbar:

  - Visualize parent/child relationship (little arrows)
  - Object Properties

* Object List

  - plain image
  - prefabs
  - enemies
  - active objects (doors, switches, etc.)

Build System
============

* write a script that builds cross compile environment with mingw on Ubuntu

Code Cleanup
============

* seperate and document components better:

  - collision engine
  - BabyXML
  - Sprite2D
  - Sprite3D
  - Dialog/Conversation

* Screens might fit better into app/ then screen/

* find a astyle/bcpp/whatever configuration that matches the current
  coding style, maybe a little script that uses Emacs would do

Sound Effects
=============

* sound of a large power switch being toggled to start a generator

* sound of a metalic locker being opened

* sound of a lightswitch being toggled

Obsolete
========

* maybe have different RGB and RGBA Textures in the TexturePacker to
  save a bit of space


http://orange.blender.org/blog/the-amazing-incredible-monkey-brush#more-49
Hypatia

# EOF #