LDLITE version 1.5Release Notes, LDLITE Version 1.6


What is LDLITE?
LDLITE is a program that displays 3D models. Its file format is a superset of 
the *.dat format used by the program LDRAW. A vast library of parts for 
LEGO-brand building bricks have been defined in *.dat format , and it is a 
popular format for exchanging descriptions of LEGO models. 
Version 1.6 is a functional, stable release for the MS Win95/98/NT platform, 
fully compatible with LDRAW. Source code for LDLITE is available under the GPL.
Paul Gyugyi, paul@gyugyi.com
Release date: March 7, 1999.
Disclaimer
LDLITE version 1.6, Copyright (C) 1999 Paul J. Gyugyi
LDLITE comes with ABSOLUTELY NO WARRANTY; for details see the file COPYING 
distributed with this program. This is free software, and you are welcome to 
redistribute it under certain conditions; for details see the file COPYING 
distributed with this program.
Download
The home page for LDLITE is http://www.gyugyi.com/l3g0/ldlite/. 
Click on these links for the MS Windows binaries:
http://www.gyugyi.com/l3g0/ldlite/ldlite_1_6_b.zip.
The GPL'd source (Microsoft Visual C++ 5.0) is available at:
http://www.gyugyi.com/l3g0/ldlite/ldlite_1_6_s.zip.
Platforms supported
  MS Win95/WinNT/Win98 (binary available, source code available) 
  Macintosh (in development) 
  MS WindowsCE (in development) 
  Linux/X11 (in development stage) 
  Windows 3.1 (in planning stage) 
Version 1.6 Release Notes
New features: 
  MPD support -- MPD are multi-part distribution files. An MPD file is like an 
  tar-style archive of many .dat files. Each file is preceeded by a "0 FILE 
  name.dat" line, and ends when another "0 FILE name.dat" line or EOF is 
  encountered. The first file in the archive is rendered, and usually does Type 
  1 references to the other files in the archive. Support for this feature is 
  new, so your bug reports are appreciated. 
  Option Dialog Box -- Jeremy Sproat has contributed a big improvement to the 
  Options dialog box (as well as several other improvements under-the-hood). You 
  can now change almost all command line parameters. Eventually this dialog will 
  include (and replace) the other menu options. 
  Faster rendering (up to 15% faster) -- algorithm improvements made up for the 
  overall performance hit of other new features. This included a limited form of 
  trivial rejection for hidden triangles. A lot more work could and should be 
  done in this area. 
  Wireframe mode -- Enabled by the menu option, or by the -FW command line 
  option. Draws the image in about half the time. A future version will have 
  some depth-fading, so closer lines will stand out better. 
  Interruptable -- The Windows message queue is checked every time the screen is 
  updated, so you can exit out of those long renders. You can also change the 
  Options menu option "Pause Between Steps" partway though a file, if you get 
  tired of clicking to continue. (note: it appears that the "Pause Between 
  Steps" option is backwards: a checkmark means "Don't pause between steps". 
  Sigh. I hate last-minute bugs). 
  Ergonomic -- a keyboard hit will work as well as a mouse click to advance to 
  the next step. 
  Better memory handling -- memory for file caching is allocated when a file is 
  loaded, rather than allocated at the start. This resulted in slightly lower 
  performance, but lower memory requirements for models with few required files. 

  Nicer display -- I moved the Step and Comment messages to the status bar at 
  the bottom, and do not change the title bar anymore. I changed some of the 
  color definitions. The names and colors match the LDAO color screen in the 
  "Make Catalog" function, if you convert names like "Dark Cyan" to "Dark-Cyan". 

  Source code -- I'm now using MS Visual DevStudio 6. I'm statically linking in 
  the MFC library to avoid DLL problems with older Windows versions. 
  Bugfixes -- LDRAWDIR environment variable no longer needs to be set. Fixed an 
  obscure memory access bug in dibkernel.cpp. LDLite changes to the directory of 
  a drag-n-dropped file. Dithered colors work correctly. Twirl mode works a 
  little better 
Commandline Options
The following are an exhaustive list of the commandline options supported by 
LDLITE. Command line options do not need to be specified in any particular 
order. Options consist of a dash, a single character, and sometimes an argument. 
Note that there must not be a space between the character and the argument. 
Currently all options are not case sensitive.
  -Afloat,float,float,float,float,float,float,float,float
  This specifies an initital scale/rotationmatrix, and is commonly used to set 
  the viewpoint for the model. 
  -Binteger
  This specifies the background color to use in the image. The decimal integer 
  can be any valid color number, although it is not affected by any color 
  redefinition statements. 
  -Cinteger
  This specifies the default drawing color to use (i.e. it defines what the 
  color value 16 initially maps into). The decimal integer can be any valid 
  color number, although it is not affected by any color redefinition 
  statements. 
  -FH
  This specifies that a higher-quality rendering is desired. It is used to 
  enable shaded rendering.
  -FS
  This specifies that a lower-quality faster rendering is desired. It is 
  currently ignored by LDLITE.  Ldglite uses it to turn off stud rendering.
  -FW
  This specifies the model should be rendered in Wire-Frame mode, which only 
  draws the lines in the model. 
  -G
  Debugging output is written to the status bar, and if "-l" is specified, to 
  the logging file. 
  -L
  Anything written to the status bar will be written to the file ldlite.log. If 
  a logging file already exists, it is deleted. 
  -Mcharacter
  This sets the LDRAW mode: -MC will set continuous mode, where the model will 
  be drawn without interruption. -MP (the default) will have LDLITE pause for a 
  mouse click at each "0 STEP" line. -MS will create a bitmap file each time it 
  encounters a "0 STEP" line and automatically exit when the model file has been 
  completely processed. 
  -Ofloat,float
  This will offset the origin of the image in the x and y directions. For 
  whatever reason, LDRAW sets the default origin to be 2/3 of the way down the 
  screen; LDLITE keeps this tradition. 
  -P
  LDLITE will operate in polling mode. After the model finishes rendering, 
  LDLITE will go out and check every second or so to see if the file has been 
  modified. If so, it reloads and redisplays the model. 
  -Rfilename
  LDLITE will convert the model file to LDRAW syntax, producing the file 
  "filename", and automatically exit. 
  -Sfloat
  Scales the model file by "float" before drawing. Curiously enough, negative 
  numbers work just fine. 
  -T
  Actives "twirl mode". After the model is done being drawn, this will change 
  the viewpoint by a 10 degree rotation about the y axis and redraw the model. 
  -Vinteger
  Sets the "video mode", or window size. -V0 sets 320x200, -V1 sets 640x200, -V2 
  sets 640x350, -V3 sets 640x480, -V4 sets 800x600, -V5 sets 1024x768, -V6 sets 
  1280x1024. No attempt is made to emulate the non-square aspect ratio of 
  -V[012]. The default, if no -V option is set, is to run full screen. Note: due 
  to window decorations like status bars and menus, the actual image size may 
  differ slightly from the listed values. 
  -Zfloat
  Sets the Z axis clipping threshold. Normally in zbuffer graphics, the horizon 
  is at the largest possible integer value, and the viewer is at the most 
  negative integer. If a new brick has a lower z value than what is on the 
  screen, it is drawn. (This test is done on a pixel-by-pixel basis). By setting 
  the -Z option, pixels with Z values lower than the specified number will not 
  draw on top of what is already there. This can be used to create a 
  cross-section image that slices off everything closer than the specified 
  value. 
Installation
  To have access to the building brick libraries, you should first install the 
  LDRAW program. I'd also recommend installing the LDRAW Add On (LDAO) program. 
  LDLITE does not actually need anything from those programs, but works well 
  with them. 
  Locate your "Base LDRAW directory", where you installed your LDRAW files. This 
  is usually named C:\LDRAW. If you didn't install LDRAW, just create a 
  directory somewhere. In this directory, create a subdirectory called LDLITE. 
  Place the files in this archive into the LDLITE directory. LDLITE will look 
  for files in the ..\MODELS, ..\P and ..\PARTS directories. (you could actually 
  put the LDLITE files in any directory and it would work OK). 
  Run the ldlite.exe file. If you have never installed LDAO, you will get a 
  dialog box asking you to set the base LDRAW directory. You should see a blank 
  window with a white background. Go to "File-Open" and click on "ldl-logo.dat", 
  which is distributed with this archive. You should see a grey rectangle. Click 
  on the image (with the left button), and LDLITE will draw the next step, which 
  will draw the letter L. You will see comments from the ldl-logo.dat file 
  appearing on the status bar in the second field. Continue clicking on the 
  image until all steps have been drawn and the title bar says "Finished" and 
  the letters spell LDLITE. The file "ldl-logo.dat" does not use any of the 
  LDRAW library *.dat files. 
  Start Ldlite, and chose "File/Open" to find "..\models\car.dat", a standard 
  file distributed with LDRAW. You should see the first step in the car.dat 
  file, a pair of axle plates and a plate. Click on the image (with the left 
  button), and LDLITE will draw the next step. Continue clicking on the image 
  (or quit the program by clicking on the close box) until all steps have been 
  drawn and the title bar says "Finished". Then click on the close box. If you 
  get an error message, the base path in your LDRAW.INI file may be incorrect. 
  Go to the "Options" menu and select "Set path for LDRAW parts", select the 
  LDRAW base directory and press OK. 
  Go to the "Options" menu and select "View". This will allow you to change the 
  zoom factor and view position for the model. If you have not installed LDAO, 
  the view position list box will not work. 
  You can use all the standard LDRAW command line options, either from a command 
  windows, the Start/Run dialog, or using a shell program, such as LdrawAddOn 
  (Highly recommended). 
  Ldlite will register itself as the default program for .dat files if no other 
  program is already configured that way. You can then double click on a .dat 
  file from the Explorer window and it will start ldlite. 
  Netscape can be configured to automatically run ldlite when it encounters .dat 
  files. After running LDLITE at least once, go to the Netscape menu item 
  Edit/Preferences/Navigator/Applications, select "ldlite Document", Edit, and 
  set the mime type to application/x-ldraw. Now if you download a .dat file from 
  a properly configured server, such as lugnet or the two dat links here: 
  wood4.dat, mudray.dat, you'll be given the option to download the file or view 
  it with ldlite. 
Credits
The entire LDRAW community is very helpful, and I've gotten a lot of advice and 
help. I'm especially glad to get code snippets in the mail. Much thanks to Steve 
Bliss, Lars Hassing, Leonardo Zide, Jeremy Sproat for making this a much better 
program than I could produce myself. Great thanks to Todd Lehman for setting up 
the LUGNET discussion group server to support LDLite and for listing the LDLITE 
home page as CLSotW. Of course none of this would have a purpose without James' 
LDRAW parts library and the continued work on pieces by other folks on the LCAD 
mailing list. 
Release Note History
Release notes, Version 1.5
Version 1.5 has two sets of new features. First, there are improvements to the 
LDRAW-compatible operation. Second, there are extensions to the language to make 
it a more general-purpose program. While many LDRAW users will find the new 
extensions to save them time and effort when writing models, LDLITE supports 
converting the new language extensions back into LDRAW syntax for maximum 
compatibility.
LDRAW Compatible Features:
The following new features in version 1.5 will enhance your LDRAWing experience:
1. Improved graphics quality. Edge lines are now accurately drawn, as I changed 
the zbuffer routines to use fixed-point numbers and no longer experience large 
rounding errors.
2. Memory leaks have been plugged. This improves operation in "polling mode" as 
part of the LDAO modeller.
3. Mildly faster rendering, especially when zoomed in on a small part of a 
model.
4. Configuration now shares the LDRAW.INI file with LDAO, rather than using the 
LDRAWDIR environement variable. If you have already installed LDAO, LDLITE will 
use that base directory setting; if not, you will get a nice dialog box to help 
you set the base directory. This should solve many of the 
installation/configuration problems people have been having.
5. Log files are now supported. Using the command line option "-l", and 
everything normally written to the status bar will be saved into a file named 
ldlite.log. By default, that includes all Type 0 comments, such as "~moved to" 
lines and reports of syntax errors or missing files. If you specify "-g" you 
will get a more extensive debugging output.
6. The zoom/scale and viewpoint can be set from a menu item dialog box. The 
viewpoint is a list of names taken from the LDRAW.INI file. These are the same 
ones used by LDAO.
7. A new option "-Zfloat" allows you to create cutaway views. It effectively 
cuts off anything closer than a given value "float". All pixels with a final 
transformed z value less than "float" will not be drawn. This only allows you to 
shear off in a plane parallel to your computer screen. Cutaway views on 
orthographic projections like you normally see in books will have to wait for a 
later release. To see what it would look like if you were the driver of CAR.DAT, 
try this:
  ldlite -MC -S6 -O0,200 -V3 -a1,0,0,0,1,0,0,0,-1 -Z0 car.dat 
8. I've added an eye-candy "twirling mode". If you specify "-t" as a parameter, 
then after the program is finished drawing the model it will set the view to be 
10 degrees further around the y axis, redraw, and repeat. You should use this in 
conjunction with "-MC" or it will keep pausing for a mouse click. To exit, move 
the mouse (which will have an hourglass cursor) over the close box and click The 
program will exit when it finishes drawing the model. I would not advise using 
"-t" in conjunction with "-l", or "-p". For example, you can use the following 
command in a command window to check out how the Technic engine block part looks 
from all angles:
ldlite -V3 -S2 -MC -t 2850.dat
LDLITE Extensions:
LDLITE 1.5 supports a number of extensions to the LDRAW syntax. The commands are 
implemented as Type-0 META commands. These should be considered "beta versions", 
since I want to reserve the flexibility to change these to match more closely 
what is used by other LDRAW-related tools. Your comments and suggestions are 
welcome. The file "wood3.dat" distributed with the program demonstrates most of 
the new extensions.
1. Naming things. You can define alphanumeric names to represent colors, points 
and matricies.The names follow the same scoping rules you find in programming 
languages; think of .dat files as subroutines. The name must be defined before 
it is used in a file. The name then can be used or redefined throughout the rest 
of that file, including inside Type-1-included files. The name definition 
evaporates (leaves scope) at the end of the file. Names are local to files, 
meaning they apply to that file and all files it includes, but do not remain 
defined when returning to a higher level file. This means you cannot define a 
bunch of names in a file you call from your main model file and then use them 
later in the main model file. In other words, putting the line "1 16 0 0 0 1 0 0 
0 1 0 0 0 1 default_colors.dat" at the start of your model will not work; the 
color names you defined in default_colors.dat will be gone by the time the 
second line of the model is parsed. On the other hand, you can be assured that 
including a part with a Type 1 line will never screw up the names you have 
defined. A future version of LDLITE will support a default.dat file which will 
be loaded at the beginning of the program and used to define names which will be 
valid at all times.
The following commands can be used to name things:
  0 COLORNAME color_name integer_index
  example: 0 COLORNAME black 0 
  0 POINT point_name float_x float_y float_z
  example: 0 POINT wing_offset 1.0 0.707 0.5 
  0 MATRIX matrix_name a b c d e f g h i
  example: 0 MATRIX m_rotate90y 0 0 -1 0 1 0 1 0 0 
An example of use the names in a file:
  1 black wing_offset m_rotate90y 3933.dat 
The following color names are pre-defined by LDLITE. The ones marked "unused" 
should probably be given names.
  black 0 
  blue 1 
  green 2 
  teal 3 
  red 4 
  dk_pink 5 
  brown 6 
  grey 7 
  dk_grey 8 
  lt_blue 9 
  lt_green 10 
  cyan 11 
  lt_red 12 
  pink 13 
  yellow 14 
  white 15 
  main_color 16 
  pastel_green 17 
  lt_yellow 18 
  tan19 
  lt_purple 20 
  glow_in_the_dark 21 
  purple 22 
  purple_blue 23 
  edge_color 24 
  orange 25 
  unused 26 
  unused 27 
  unused 28 
  unused 29 
  unused 30 
  unused 31 
  unused 32 
  trans_dk_blue 33 
  trans_green 34 
  unused 35 
  trans_red 36 
  unused 37 
  unused 38 
  trans_grey 39 
  unused 40 
  trans_lt_blue 41 
  trans_green_yellow 42 
  unused 43 
  unused 44 
  unused 45 
  trans-yellow 46 
  clear 47 
  unused 48 
  unused 49 
  unused 50 
  unused 51 
  unused 52 
  unused 53 
  unused 54 
  unused 55 
  unused 56 
  trans-orange 57 
  unused 58 
  unused 59 
  unused 60 
  unused 61 
  unused 62 
  unused 63 
2. Redefining color palette values. LDRAW defined two types of colors. Colors 
from 0 to 31 were solid colors (except 16 and 24), colors 32 to 63 were 
transparent, and numbers from 256 to 511 were dithered combinations of two 
colors from 0 to 15. 
LDLITE allows colors from 0 to 255 (except 16 and 24) to be (re)defined to be 
solid or dithered combinations of 24-bit colors. Color redefinitions follow the 
same scoping rules as the names in the previous section. I'd like to reserve the 
entries 0 to 127 for standardized, official brick colors. Colors 128 to 255 are 
fair game for you to use in your own files.
The syntax of the COLOR statement is:
  0 COLOR index name edge_color r g b alpha d_r d_g d_b d_alpha
  note: you can spell it COLOUR and it will still work. 
  index is the decimal value specifying the palette index, 0 to 255 excluding 16 
  and 24. 
  name is an alphanumeric name you can use to refer to the color. This is 
  redundant with the COLORNAME command, but is included for convenience. 
  edge_color is the decimal value specifying the color to use for edge (#24) 
  colors. 
  r g b alpha are the red, green, blue and alpha components of the first 
  dithered color. They are numbers from 0 (black) to 255 (pure color). The alpha 
  value should be 255 for the first color. Note: You can use hex numbers, such 
  as 0x00 and 0xff if you wish. 
  d_r d_g d_b d_alpha are the red, green, blue and alpha values of the second 
  dithered color. If you want a solid color, set these to be the same as the r g 
  b alpha values. If you want a transparent color, set d_alpha to 0 and the 
  second dithered color will not be drawn, creating the classic LDRAW 
  transparent effect. 
 
3. Direct colors LDLITE defines the color values from 0x4000000 to 0x7ffffff. 
These represent two 12-bit colors which are dithered together, and cannot be 
redefined. They are intended to be used in converting meshes from other 3D 
formats. While you can use decimal numbers, the hex representation makes the 
structure clear. The edge color for all direct colors is pure black.
The first (leftmost, most significant) hex digit defines whether the color will 
be transparent. "4" is an opaque color. "5" or "6" create transparent colors. 
"7" will create an invisible color which will not be drawn at all. You can 
interpret the two least significant bits of this digit as inverted alpha values.
The second, third and fourth digits are the red, green and blue intensities of 
the first dithered color. These digits are ignored for colors in the ranges 
0x5000000 to 0x5ffffff and 0x7000000 to 0x7ffffff.
The fifth, sixth and seventh digits are the red, green and blue intensities of 
the second dithered color. For pure colors, set these to the same as the second, 
third and fourth digits. These digits are ignored for colors in the range 
0x6000000 to 0x7ffffff.
4. Nested transforms I find transform matricies to be obscure and tedious. Being 
able to give them names (see above) helped a little. This takes things one step 
further and provides the kind of nested transforms one commonly finds in 
raytracing programs. You can surround a set of lines with one of these nested 
transform commands, and the surrounded lines will all be affected.
The nested transform commands are:
  0 TRANSLATE x y z
  surrounded lines
  0 TRANSLATE end
  This command shifts all surrounded lines in the x, y, and z directions 
  0 ROTATE angle_degrees axis_x axis_y axis_z
  surrounded lines
  0 ROTATE END
  This command rotates all surrounded lines around the line through the origin 
  and the point (axis_x, axis_y, axis_z). 
  0 SCALE scale_factor
  surrounded lines
  0 SCALE END
  This scales all surrounded lines by the scale factor. 
  0 TRANSFORM x y z a b c d e f g h i
  surrounded lines
  0 TRANSFORM END
  This command accomplishes the same sort of thing as putting the lines in a 
  subfile and using a Type-1 line to include them. x, y, and z specify 
  translation values, and a,b,c,d,e,f,g,h,i specify the scale/rotation matrix. 
5. Converting to LDRAW syntax. To maintain backwards compatibility as much as 
possible, LDLITE can be used to convert a file to LDRAW *.dat syntax. While 
COLOR commands are simply ignored, and direct colors will cause LDRAW to choke, 
all other commands (names, nested transforms) can be converted successfully. The 
syntax for converting a file with extended syntax (e.g. named "extended.dat") to 
one using just LDRAW syntax (e.g. named "oldstyle.dat") is:
  ldlite -roldstyle.dat extended.dat 
When run in this mode, LDLITE will pop up a window, do the conversion, and exit. 
Nothing will be drawn, and in the future I'll try and improve how it works, 
since it is a little unnerving to have a full screen window appear and vanish 
right away. Note: the conversion process may produce floating point numbers in 
exponential format, such as 2.3e-008. Both LDRAW and LDLITE seem to work 
correctly with these numbers, but I havn't tested other tools.
Release Notes, Version 1.2
  Version 1.2 is an "internal release", not distributed on the web page. 
  Routines in the code (currently disabled) will produce a limited type of POV 
  code (just triangles and cylinders). 
  Version 1.2 was the branch point for the Linux command-line version. 
Release Notes, Version 1.1
  Fixed bug where the LDAO "Main Color" option was not being used. "-Cnumber" 
  will now set the default color for the model. 
  Fixed bug where ldlite was not searching all directories to find a 
  command-line specifed filename. 
  Ldlite now zooms to full screen if started without a -V option. 
  If you specify a "-p" on the command line, ldlite will go into a polling mode, 
  where it will watch the timestamp on the current .dat file and re-render it if 
  the file is updated. When I develop models, I start up two ldlite programs, 
  one looking at the model from the above view, and one looking at oblique view, 
  both with the -p on -MC (continuous) option set. Whenever I make a change in 
  the editor and save the .dat file, both view windows automatically update 
  themselves. Changing the Options menu to "Show only full models being drawn" 
  works well with this. I've never tested polling without specifying a .dat file 
  on the command line. Currently, ldlite will eventually crash due to the memory 
  leak bug below. 
Release Notes, Version 1.0
  Complete LDRAW command line compatibility. This was the criterium for 
  numbering the release 1.0, so I jumped straight to that from version 0.3. 
  Greatly improved parsing speed thanks to a caching lex/yacc parser, which only 
  requires files from the P and PARTS directories to be opened once. Caching 
  sped up performance by a factor of two. Expect this to improve even more in 
  future releases, as Lars Hassing has recently contributed a scanf-style parser 
  that works 2-4 times faster. 
  Parsing is now very robust to errors in the source files, including the 
  problematic case of the last line of a file not ending in a carriage return. 
  Improved graphics code from Lars rearranged the bitmap storage into a more 
  windows-compatible format, eliminating the need for SetPixel(). This increased 
  performance by a factor of 4. 
  Added menu commands for changing Ldlite-specific options. These settings are 
  stored in the registry and used next time ldlite is run. 
  I added options for how the screen is updated. The screen is only updated at 
  each STEP or after certain Type 1 lines. You can choose to have the screen 
  updated after each primitive is drawn, after each part is drawn, or after each 
  model is drawn, which is based on which directory the Type-1-included file is 
  found in. 
  I added a shading option, which darkens surfaces which are not perpendicular 
  to the direction of viewing. There are no shadows cast, but this does help 
  bring out the curvature of objects. 
  I added support for bitmap creation when there are more than 100 steps, which 
  is not handled by LDRAW. Similar to the way LDRAW works, the name of the dat 
  file is truncated and digits are appended, with less of the dat file name 
  being used as the number increases. 
  Fixed up a few color settings. Made grey a bit lighter. 
  Lex and Yacc source files are included in this release. After running ldlite.l 
  through flex, you will need to make two changes. First, make sure the line 
  "#include <stdlib.h>" appears in the lex.yy.c at the top, right below 
  "#include <stdio.h>". When I run flex, it surrounds that line with some #if 
  statements that do not work with VC++. If stdlib.h does not get included, the 
  aotf() conversion routine will not have the right prototype, and all the 
  numbers will be parsed as random, garbage values. Second, change the line 
  "#define YY_DECL int yylex YY_PROTO(( void ))" to "#define YY_DECL int 
  my_yylex YY_PROTO(( void ))". This makes the program call the faster, caching 
  version which in turn calls the standard yylex() only when needed. If you 
  forget to do this, you'll get link errors about the multiply defined function 
  yylex(). 
  The ability to save to bitmap is provided by routines from the source files 
  dibkernel.cpp and dibkernel.h, written by , René Dencker Eriksen 
  (http://www.imada.ou.dk/~edr) and Hans-Martin Brændmose Jensen 
  (http://www.mip.ou.dk/~hansm). Since I have not yet gotten their permission to 
  redistribute their code, you'll have to grab the files, which are freely 
  available at http://www.mip.ou.dk/~hansm. 
Release Notes, Version 0.3
  The screen drawing routines much faster now. Many thanks to Leonardo Zide for 
  contributing the routing to render to an off-screen bitmap, and thereby 
  inspiring me to add an invalidate-rectangle style algorithm to speed up 
  rendering. I'm happy to say LDLITE seems to be rendering images in 2/3 the 
  time of LDRAW! 
  The colors are much more accurate, thanks to information provided by Steve 
  Bliss. Included with that are Pantone colors for the bricks that Todd Lehman 
  put together. LDLITE looks a little more realistic and has a little less 
  contrast than LDRAW. I'm not sure if that is good or bad, but it looks pretty 
  good anyways. Dithering and transparent colors are supported. 
  The software is more Windows-friendly. You can exit without going through all 
  the steps in a model. You can move the window around and print at any step. 
  Line type 0 Comment strings are displayed in the status bar. 
Release Notes, Version 0.2
  The screen drawing routines are insanely slow, because I wrote them that way. 
  Expect this to improve, or grab the source and make it better. Perhaps doing 
  the SetPixels on a bitmap in memory and then copying it to the screen would be 
  faster. The zdraw rendering routines are as fast as they need to be. 
  There is no command line support for viewing positions, etc. I don't plan on 
  doing this myself, so it would be a good place to grab the code and add to it. 

  Printing is somewhat limited. I've found that using the printer setup to 
  change the DPI of my Deskjet from 300 to 150 or 75 resulted in a larger image 
  on the sheet of paper. 
  Clear and dithered colors are not correctly implemented yet, but are somewhat 
  close. 
  Support for STEP commands it limited. When drawing files with mulitple steps, 
  LDLITE ignores everything else except left button clicks in the window. I mean 
  everything -- no redrawing the window border, no resizing, no exiting. As soon 
  as the final step is drawn, LDLITE will process all the other mouse clicks you 
  have done. The next release will fix this behaviour, which involves making the 
  code more windows specific by using a background thread. 
  Comment strings are ignored. Any line starting with a zero that is not in the 
  exact format of "0 STEP" will be ignored. 
  If .dat files do not end in a newline character, the last line will not be 
  draw correctly. There are only about 3 or 4 .dat files in the LDRAW 
  distribution with this problem. I'll compile a list for the next release. 
  LDLITE uses a lot of file I/O, opening and closing common files like stud.dat 
  hundreds of times for a typical model. This I/O makes up the majority of the 
  processing time. Finding a way to cache the binary token stream of common 
  files would speed things up a lot. 
 
