This file will be automatically generated from the .DTD-file later on.
We are currently rewriting the specifications to better suit games. Mutliple keyframes per object (same object with different movements). Support for quake-a-like levels is also being investigated. Please comment on it. 
Materials
  Material
   String              name
   Float               transparency
   Float	       mirror
   Bool                two-sided
   Color               ambient
   Color               diffuse
   Color               specular
   Texture
     Float               percentage
     Bool                mip-mapped
     TextureFile
       String              filename
     TextureInternal                     (not in the xml-version)
       String              filename
       Byte                data[]          (end where the chunk ends)
     TexturePak
     String             filename
     Int32              offset
     Int32              length
   Environment-mapping
     Texture
   Bump
     Texture
   Transparency
     Texture
An additional texture could be added (same UV-coordinates?). How (if) will we support sub-materials? Blowgoat:ship (material ship in blowgoat). 3ds-max style this is.
Should we have ambient, specular and such? 
Scene
  Ambient
    Color
    Colortrack
      Vectortrack
        Int32               keys {int32 frame, vector value, float easeTo, float easeFrom, float t, float c, float b}
  Fog
    Float              far
    Float              farDensity
    Color
    Color              background
    Float              near
    Color              nearDensity
  Object
    String             name
    String             parentObject
    Matrix             rotation
    Vector             pivot
    Vector             scale
    Dummy
    Geometry
    Sphere                             (radius and pivot is expressed in pivot/scale (force scale=r,r,r?))
      Bool               smoothed
      String             material
    Box                                (size and pivot is expressed in pivot/scale)
      Bool               smoothed
      String             material[6]
    Cone
    Spline
      This is currently being looked into.
      If we include it, it will be a spline in space with a radius per segment,
      and also TCB-values for each segment. It can be used for any worm-shaped object
      or to define a static 3d-path.
    Progressive-Mesh
      This is currently being looked into.
      If we include it, an ordinary "Mesh"-chunk will also be present.
    BSP-tree-nodebased
      Mesh                             (splitted version of mesh)
      BSP-Node
        BVolume
        Plane             plane
        Int32             plane-faces {int32 faceIndex}
          BSP-FrontNode
            BSP-Node
          BSP-BackNode
            BSP-Node
    Nurb
      More
    Mesh
      Vertexdata
        Int32             vertices {vector position}
        Multi-mesh
      Mappingindex
      Facedata
        Int32             faces {int32 vertices {vertexIndex}}
      Texturemapdata
        Materialdata
          Int32             materials {string materialname, int32 faces {int32 faceIndex}}
        MappingIndex
          Int32             faces {int32 vertices {mappingIndex}}
        Mappingcoordinates
          Int32             coordinates {float u, float v}
      Lightmapdata
        Materialdata              (perhaps not materialdata here, rather MaterialLightmap or Texture)
        Mappingcoordinates
        MappingIndex
      Tri-mesh
        Mappingindex
        Facedata
        Mappingindex
        Texturemapdata
        Lightmapdata
      Vertextrack
        Int32             animatedVertices {int32 vertexindex, vectortrack}
    Rotationtrack
      Quartaniontrack
        Int32             keys {int32 frame, quaterion value, float easeTo, float easeFrom, float t, float c, float b}
    Positiontrack
      Vectortrack
    Scaletrack
      Vectortrack
    Visibletrack
      Booltrack
        Int32             keys {int32 frame, bool value}         (it's on/off, so no need for value?)
    Bonestrack
      This is currently being looked into.
      The implementation will probably be lightwave 6.0 and 3ds-max compatible.
      Lightwave 5.x bones are also being investigated. They are far more simple. 
    Detail-track
      Floattrack
        Int32             keys {int32 frame, float value, float easeTo, float easeFrom, float t, float c, float b}
  Light
    String            lightname
    String            parentObject
    Distantlight
      Color             color
      Float             strength
      Vector            direction
    Omnilight
      Vector            position
      Color             color
      Float             strength
      Float             fallOff
    Spotlight
      Vector            position
      Vector            target
      String            parentTargetObject
      Color             color
      Float             strength
      Float             fov
      Float             roll
      Float             fallOff
    Directiontrack
      Vectortrack
    Fovtrack
      Vectortrack
    Rolltrack
      Floattrack
    Positiontrack
      Vectortrack
    Targettrack
      Vectortrack
    Colortrack
      Vectortrack
    Fallofftrack
      Floattrack
    Strengthtrack
      Floattrack
    Visibletrack           (Equal to strength=0)
      Booltrack
  Camera
    String            cameraname
    String            parentObject
    String            parentTargetObject
    Vector            position
    Vector            target
    Vector            upVector
    Float             aspectRatio
    Float             fov
    Float             roll
    Positiontrack
      Vectortrack
    Targettrack
      Vectortrack
    Fovtrack
      Floattrack
    Rolltrack
      Floattrack
 Viewport               (current camera)
   String           cameraname
   Viewporttrack
     Int32            keys {int32 frame, string cameraname}

Visibility
 Portals
  Rooms
   Int32 rooms	{string object}
   BSP-tree	// Alarge BSP-tree of all static objects in the room
  Doors
   Int32 portals	{string object, int32 roomIndex, int32 faces {int32 faceIndex}}
  Doors-BSP
   Doors
  Placement
   Int32 objects	{string object, int32 roomIndex}
 BSP-scene	// A large BSP-tree of all static objects in the scene… And more
  BSP-tree
This is merely a suggestion. Probably needs to be redone 95%. Perhaps 98%. Perhaps a room can be built out of polygons in a object rather than of a entire object. This is not supported here.