
TAGL History
============

TAGL-2.2
--------
      

        o Textures !!! ( and EnvironmentMapping support in Rotate)

        o Better command line argument support for Rotate.

        o Compatibility with toolkits (now, a GraphicPort can be
	  embedded into a DrawingArea). An X GraphicPort can be
	  binded to any user defined window.

        o Compatibility with DEC Alpha running OSF/1
	  (Alpha's longs are 64 bits wide !!).

        o CopyBuffer256() member function of GraphicPorts. 
          Convert a 8bpp buffer into local display depth.
	  Copy into GraphicPort mem.

	o ScaleBuffer256()
	  Convert and resize a 8bpp buffer, copy into GraphicPort mem.

	o Arrow keys, return, escape recognized by GraphicPort.

        o LinG library (Frame buffer library, functions can be used by
          C programs).

        o Venus rewritten with LinG (Now it can run at any display depth).

	o Preliminary font code.

	o XPolygonEngine : uses X functions for drawing. This allows to
          run quickly across a network programs that do not need
          ZBuffer and Gouraud shading. (With XPolygonEngine, it runs
	  just like VOGL).

        o GeometryManager class:
          High level interface to TAGL (GL-like function calls).

	o More portable, does compile with commercial CC compilers.

	o Graphic micro-kernel : with the help of dynamic linking, 
	  drivers can be linked at run time with the use of dld 
	  (and ELF later on). They can be statically linked also.
	  (if neither ELF nor dld exists in your system ...)

        o Rendering contexts : Each graphic port can save the current
          rendering context and restore it. This allows to have several
          TAGL windows in the same process. 

        o A nice LaTeX programmers guide, and a few sample programs. 
	
TAGL-2.1
--------
	o Bug fix in polygon filling routine
	  It's this damn bug that causes most tagl20 bus errors ! :-)

	o Bug fix in XGraphicPort when creating std X images.
	  Thanks to Patrick van Logchem (v912152@si.hhs.nl)
          who has found and corrected this bug.
	  (It's the other damn bug that causes most of remaining tagl20
           bus errors ! :-) )
	
	o replace 'long' by 'short' for ZBuffer.
	  (in gdefs.h, typedef ZCoord unsigned short).
	  divides ZBuffer mem size by 2 - In fact, does not change precision.

	o 32bpp PolygonEngine (X people should now be able to run tagl in
          16Mcolor mode).
          565 mode (most 64K X servers use these weights).

	o gcompat_20.h for backward compatibility with tagl20.

	o class renaming (to avoid collision with user types).
          Vertex           -> GVertex
          VertexPool       -> GVertexPool
	  VertexAttributes -> GVertexAttributes
	  Polygon          -> GPolygon

	o virtual constructor are now static members of GraphicPort
	  and PolygonEngine (cleaner code).

	o Cntl() virtual function for GraphicComponents.
	  XGraphicPort::Cntl(XGraphicPort::RESIZE, 0) disables window
          resize.
	  Dynamic allocation of OpCodes.
	  (static int XGraphicPort::RESIZE = GraphicComponent::UniqueOpCode()).

	  XGraphicPort::XSTDPROP = Set X standard properties.
          SVGAGraphicPort::WAITVBL = wait screen refresh.

	  See include files for more details.

	o Vincent Lepetit has written a new 'venus' demo.
               + faster code
               + better rendering
               + resizable window !!!

	o generic polygon engine
          (allows anybody to write quickly his own polygon engine)

	o better R_mask, G_mask, B_mask determination in SVGA.
          (this part of the code has been inspired by 'libgr.c')

	o Fixed a warning in XGraphicPort

        o Clear(r,g,b), Clear(Colorindex), ZClear(), ZClear(ZCoord) 
          (GraphicPort member functions).

	o Adapt source tree for DOS port.
          Shorter file names (8.3 max - f*ck MS-DOS, f*ck, f*ck; f*ck !).
          .C   -> .cc   ( gcc C++ files must have .cc extension under DOS ).
          _i.h -> .ih   ( 2 more characters available for basename ! ).

	o DOS Port. Compiles under djgpp (gcc for DOS).
          Support VESA modes.
          (preliminary release).
          I don't like DOS very much (well, I hate this sh*t !!!), but
          it allows to distribute binaries of demos or games compiled
          with Tagl, and according to me, with the use of go32 (djgpp's
          DOS extender), you are not under DOS anymore ( full flat 32 bit
          addressing model, memory protection, virtual memory ....).

	o Specular lighting supported by 'Rotate'
	  X29 renders much much better in RGB mode !!

	o Gamma correction.

  ... It's time I put this on the net !!
    

TAGL-2.0
--------

- language: C++.
- object oriented.
- virtual constructor technology (see README).
- everything rewritten in C++.
- Support for 8bpp, 15bpp and 24bpp displays.
- Support for X11.
- Support for SVGAlib (use GSVGAMODE environement variable to
  set video mode).
- Colormap and RGB modes
  ( Colormap mode is emulated on RGB displays, and vice-versa !)
- Display determination at run time (the same
  program can run at any bpp depth, under X11 and SVGAlib, without recompile).
- XFree3.1 15bpp mode is supported. 
  Should work for 24bpp mode also (Not tested).
  -> No, did not work for X under 24bpp (because Xfree uses in fact 32bpp) (fixed in TAGL2.1)
- RGB dithering in 8bpp mode.
- polygon filling, Gouraud shading, dithering, ZBuffer.  
- line drawing.
- SetPixel().
- More "system friendly" with the use of the new "WaitEvent()" function
  of GraphicPorts (decreases system load when idle).
- example programs :

	rotate: Loads ".ipcol" off color files.
                Lighting and color blending in color mode.
                + a converter to load ".obj" files.
                Gouraud shading, ZBuffer.
                Wireframe mode.

	vtga:   A simple viewer for uncompressed TGA files.
                (very usefull for pov).

	END (E is Not Doom): This is obviously not Doom :-).
                A simple Wolfenstein-like engine, but walls
	        can be arbitrary positionned, and they are
                smoothed by gouraud. It uses ray-casting,
                next release will use a faster algorithm ...

	Venus: Author: Vincent Lepetit
	       A mars-like demo, with a lot of nice features.
	      

	C++ versions of "testgl" and "marsclone" are still
        under work ...

- ports :

	They consist of little modules that interface existing
        programs to TAGL. It adds multitechnology support.

        wt(what is that): This is much more close to Doom than END !
	It will work in 8bpp and 16bpp modes, under SVGA and X11.
	Looks great in 16bpp mode ! 
	
	povray: The +d option will open a window under X, or set
                video mode under SVGAlib. It's nice with a 16bpp
                X server :-). Under a 8bpp server, it will use
                TAGL dithering functions.


	tagl1.1: The old release can be interfaced with the new
	         GraphicPort class (Not really interesting, but
                 it helped me testing the GraphicPort ...).
	         The old version still only works in 8bpp mode.



TAGL-1.1 (not released)
-----------------------

- language: C.
- a few bug fixes.
- window resizing.
- detect remote displays and use standard X calls 
  rather than XShm if Xshm cannot initialize.



TAGL-1.0
--------

- language: C
- X11 with XSharedMemory extension.
- flat and gouraud shading, with and without ZBuffer
- 8bpp driver
- no window resize ( window size specified at compile time)
- Fuchs grape priority algorithm.
- example programs :
     testgl -> rotate some Fuchs grapes,
               demonstrates ZBuffer abilities.
     rotate -> rotate objects in off format.
     mars   -> something that wants to look like
               the mars demo - under work ...
