Revision History

Just a minor update to fix a long standing bug in ZenNode.

• Fix the BLOCKMAP code to determine if the resulting data structure is valid and refuse to update the BLOCKMAP if it is not.
• Change the REJECT code to use an internally generated BLOCKMAP instead of the one found in the .wad file.

Another minor version update! Support for a number of RMB options has been added to the REJECT builder as well as a complete rewrite of the graph parsing logic. The RMB options supported include: BAND, BLIND, DISTANCE, EXCLUDE, INCLUDE, INVERT, LENGTH, and SAFE.

• Changed default options for building the BSP (don't require unique sub-sectors).
• Fixed BSP code to properly create unique subsectors when requested.
• Added support for basic RMB options.
• Rewrote graph code in the REJECT builder to reduce the number of calculations required.
• Change code to use mkstemp instead of tmpnam and tempnam.
• Update code to compile & run properly on an AMD 64-bit CPU.
• Changed .WAD and level handling routines to properly handle little-endian & big-endian architectures correctly.
• Fixed 2 bugs that could cause small levels to crash the NODES builder.
• Removed debug code from ZenMain that accidentally made it into v1.1.0.
• Updated bspinfo to provide a better FOM measurement.
• Added bspdiff utility to provide extra information about a map.
• Added wadinfo utility to provide extra information about a map.
• Minor updates to the documentation.
• Added Mac OS X support.
• Added extra DEBUG and DIAGNOSTIC checks to Debug version of the BSP builder.

ZenNode's got a minor version update! There are finally enough changes since v1.0 to warrant the change (it probably should have been bumped back around v1.0.6/v1.0.7 but hey...).

ZenNode has switched to using floating point math in the BSP builder. This means ZenNode is slower than it has been (sorry), but it also means that it is more accurate. This change was necessary to avoid problems with newer OpenGL ports of DOOM that use floating point internally. If integer based routines can be found that retain the accuracy required, ZenNode will definitely use them again (faster is better), but until then, this is it.

• Switched to floating point code in the BSP builder to work around problems with DOOM's limitation of integer coordinates.
• Added code to verify that the float-integer conversion did not create an invalid SSECTOR.
• Cleaned up several parts of the BSP routines to make things simpler.
• Changed code in the BSP builder to handle exhausting the VERTEX, NODES, and SSECTOR pools - ZenNode can now handle larger levels.
• Changed .WAD handling code to support maps using FraggleScript correctly.
• Fixed minor memory access bug in .WAD handling code.
• Fixed cursor positioning problem under Linux

Bug fix release - Fixed bug that corrupted wad files.

• Fixed a cut-n-paste bug that resulted in a 4-byte corruption immediately after the wad header.

More changes to the REJECT builder. The simple distance based pruning done in v1.0.6 has been replaced with a slightly more sophisticated mechanism using graph theory and articulation points (see README.html for details). The result is that most levels now rebuild much faster than before. On a sample set of almost 400 levels, the average time to rebuild the REJECT structure has decreased by a factor of 3! There is a price to pay however. As with the distance check in v1.0.6, irregular sectors can cause the optimizations to build an incorrect REJECT structure. In the sample set that I tested, 28 levels were affected by this problem. If your level has special effects that might trip up the new REJECT builder, or if you just want to be sure you have a 100% accurate REJECT, you can now turn off all the optimizations ZenNode uses (with the new -rc- and -rg- options).

• Added graph-based optimizations to the REJECT builder.
• Added -rg switch to enable/disable the new graph-based optimizations.
• Changed the -rc switch to disable child sector-based optimizations.
• Fixed a problem where a LMP with a name similar to a valid level name would crash ZenNode.
• Fixed a bug that prevented ZenNode from rebuilding the BSP if the existing BSP structures were invalid.
• Minor change to compare to limit comparisons to levels common to both files.
• Changed compare to produce a more compact output.

Miscellaneous changes in the BSP builder - now up to 45% faster than v1.0.5!

Added a new feature to the REJECT builder. Before building the REJECT map, ZenNode now creates a list of distances between every sector pair. It uses this list to prune the number of lines that have to be checked. If there is no walkable path between two sectors, they are marked as hidden up front, before the lines are checked. For maps that have more than one contiguous area (i.e. areas that can only be reached through a teleporter) this can speed up REJECT building considerably (on one particularly large map, I've seen a 500% speed increase!). The downside to this is that some special effects can confuse the REJECT builder. Special effects like 'Deep Water' will throw off the distance calculations, since the 'deep' sector(s) will appear to be isolated from all other sectors, and hence marked as hidden from everyone. If you have levels that use this effect, you should turn off this option (-rc-) for these levels.

• Changed code to simplify the creation of aliases (speed improvement).
• Changed WhichSide to use LINEDEF rather than SECTOR based decisions (speed improvement).
• Changed DivideSeg and WhichSide to use 64-bit math to avoid a potential overflow problem.
• Fixed REJECT builder to ignore 0-length LINEDEFs.
• Added new feature the the REJECT builder to calculate the distance between two sectors.
• Re-organized the documentation files.
• Added extra documentation to README.html.

Bug fix release - More changes to the BSP builder (v1.0.3 didn't quite do it) to finally fix the known bugs.

• Change makefile to use '-mcpu=' rather than '-march=' to allow code to run correctly on an i386.
• Added new logic to correctly detect lines that have already been split in _WhichSide.
• Fixed overflow problems in _WhichSide and DivideSeg.
• Changed ComputeStaticVariable to use the original LINEDEF's start/end vertices for calculations.
• Changed the metric function to allow finer control with ZEN_Xx variables.
• Changed default values for ZEN_Xx variables.
• Fixed logic in REJECT builder that detects special effects.
• Updated .html files to use CSS style sheets and be HTML 4.01 compliant.

Bug fix release - Fixed bugs in the list/wad/level code to handle levels that are missing lumps that are generated by ZenNode.

• Fixed bugs in the list/wad/level code to handle levels that are missing lumps that are generated by ZenNode.

Bug fix release - Changed code in BSP builder to fix a long-standing bug that could occasionally result in an invalid BSP tree to be built.

• Fixed bugs in _WhichSide and DivideSeg that caused SEGS to be split incorrectly, or placed on the wrong side of the partition.
• Changed timer function used in Win32 to get better timing information.

Bug fix release - Fixed a bugs introduced in v1.0.1 that stopped changes from being written to disk. Also added feature to stop special effects in the REJECT structure from being destroyed by accident.

• Fixed the code that detected whether or not a level was changed before writing changes to disk.
• Added code to look for special effects in the existing REJECT resource before modifying it.

Bug fix release - Fixed several bugs related to handling larger and invalid levels.

• Increased several internal limits to allow larger levels to be processed.
• Modified level sanity check to ignore unused SIDEDEFs.
• Fixed a bug in the REJECT builder that would cause ZenNode to lock up if it encountered an invalid level.
• Fixed a bug in the REJECT builder that resulted in an invalid REJECT structure.
• Moved conole I/O code to it's own file.
• No longer packs vertices when building the REJECT resource.
• Handle levels that are incomplete (not all lumps present in the .wad file).

All of the source code is now included.

The code to build the REJECT structure has been modified and cleaned up and should run ~36% faster than before.

Added support for Linux.

• Added support for Linux
• Cleaned up REJECT builder code and inlined a few routines.
• Added code to REJECT builder to use sector hierarchy to speed up build time.

The memory requirements for ZenNode have been reduced. In some cases, ZenNode now requires significantly less memory (up to 3M less!) to rebuild the BSP tree. A minor change was made to the REJECT algorithm to handle maps that are large (i.e.: maps that cover a large area).

• Added simple level sanity check before processing any level.
• Reduced run-time memory requirements for BSP Algorithms.
• Changed logic in REJECT algorithm to handle larger levels.
• Fixed logic for checking map level names.
• Fixed bug in BSP code to detect 'almost' parallel lines.

• Fixed bug in REJECT algorithm.

• Fix run-time error building BSP.
• Improved REJECT algorithm.
• Win32: Restore cursor after Ctrl-C, Ctrl-Break, or GP-Fault.

ZenNode will now build a REJECT resource! Given a valid .wad file, ZenNode will conduct a complete set of line-of-sight (LOS) calculations for every sector in the map. There are several methods currently in use to create a REJECT resource: distance, # of intervening sectors, sampling, and 'perfect' testing. The first two base the results solely on distances without regards to solid walls and LOS but are relatively fast. The third tests several points along two linedefs and bases it's decision on the results. This results in a more accurate resource than the first two methods, but may miss a valid LOS if the test points aren't chosen correctly or too few are used. However, the more points that are used, the slower this method runs (it slows down exponentially as the number of test points increases). The fourth is the most accurate (and the one used in ZenNode). It attempts to look at all of the intervening solid lines and find a LOS if one exists. This exhaustive test can be slow at times, but as usual, things may speed up in the future... ;)

• Added REJECT builder.
• Changed command-line default to create a real REJECT.
• Improved method used to determine the PWAD type.

IMPORTANT BUG FIX: ZenNode now handles the case where a fully qualified pathname to the input .WAD is specified on the command line for a .WAD file in the current directory. Previous versions would not handle this case properly and would create invalid .WAD files.

• Fix - related to saving .WADs given a full pathname.
• Fix - related to [unique-sectors] option in .zen files.
• Fix - related -n2 switch on large levels.
• Improved error detection for .WAD file operations.

You can now extract the maps to a new PWAD file. From the command line, use the -x switch to indicate that the specified levels are to be extracted to a separate PWAD file. This feature can be used to extract any map(s) without modifying them by turning off all the other options (i.e.: -b- -n-).

The default settings for the -n2 option have been changed. The new values are: y1=1, y2=7, y3=0, y4=1.

You can now set all your favorite command line settings in a configuration file. When ZenNode starts, it looks for a file called ZenNode.cfg. It will look in the current directory, then in the directory where the ZenNode.exe file is located. If one is found, it's contents override the normal default values. Then, actual command line parameters are checked.

Improved support for special effects. By using a customization file, you can now add virtually any special effect to a .wad file. See custom.doc for a more detailed description of how to use the customization file. A sample .wad file has been included showing a variety of special effects and a custom file demonstrating how to get all the effects in the .wad to work. For more information regarding this .wad file and a description of how to create all the effects (and more) check out:

• Added -x switch to extract rebuilt levels to a PWAD
• Added configuration file for default command-line switches
• Added customization file indicating:
  • linedefs that should be ignored
  • sectors/linedefs that should not be split
  • sectors that should/should not be unique in a SSECTOR
• Improved BLOCKMAP compression routines
• Fixed bugs in the minimize depth algorithm

Support for 'special effects' has been improved. Using the -nu switch, you can affect the creation of sub-sectors. What this means (for those of you who don't know/care what a sub-sector is) is that you can get most of the special effects to work in your .WAD file. By default all sub-sectors are unique. This works with most special effects (i.e.: deep-water, invisible stairs, ...). If the effect you're trying to achieve doesn't work, try turning off this feature with -nu-. This works for other effects, such as light striking a wall from no visible source (different sector).

For those of you who think ZenNode is too slow <g>, there's a new method for partitioning (-n3) available for you! Both of the existing algorithms (-n1 & -n2) examine every valid segment to see if they should be used as the partition for a node. Examining every segment can slow things down, so if you really can't wait, if ZenNode is way too slow for you, try the new algorithm. It only looks at a small sub-set of segments instead (saving you valuable seconds that could be used testing your new .WAD).

You can now 'customize' ZenNode's partitioning logic! The formula used to determine the merit of a particular SEG is now user adjustable. You can now set the four coefficients used in the calculation. If you don't like the way ZenNode picks lines, or you just want to experiment, now you can actually do something about it. The metric formula used is:

metric = ( L * R ) / ( x1 * S / x2 ) - ( x3 * S + x4 ) * S;

Where L, R, and S represent the # of SEGS to the left, right, and split by the candidate SEG. Checks are made to avoid division by zero. The programmable values x1, x2, x3, and x4 can be modified by setting the environment variables ZEN_X1, ZEN_X2, ZEN_X3, and ZEN_X4 respectively. The default settings are:

x1=24, x2=5, x3=1, x4=25 (Older versions of ZenNode used the values x1=4 or 5, x2=1, x3=0, x4=0).

Algorithm 2 also uses a similar set of variables, ZEN_Y1, ZEN_Y2, ZEN_Y3, and ZEN_Y4, where L, R, and S represent sectors rather than SEGS. The default settings are: y1=0, y2=1, y3=1, y4=5. Have fun.

• Changed command line option syntax.
• Added user customization of the partition formula
• Added BLOCKMAP compression
• Added minimal support for the REJECT structure
• Added -nu switch for controlling unique sub-sector creation
• Added a new algorithm (-n3) for more speed
• Changed switch for minimizing BSP tree depth (-d) to -n2
• Modified the original algorithm - fewer splits/a little slower :(
  • uses fewer diagonal partitions
  • slightly slower than before :( - but just a little - ☺
• Modified the algorithm for minimizing BSP tree depth - lower depth
• Fixed bugs in the BLOCKMAP routines
• Added balance information to BSPInfo

Support for Hexen has been added. This has been largely untested, but a quick test of the hexen.wad file seems to be working. So, as soon as you get your favorite WAD Editor to support Hexen, ZenNode will be ready!

ZenNode now offers two methods of partitioning your level. The new method makes an attempt to minimize the average depth of the BSP tree. This should make it slightly faster for the DOOM engine to render a screen, since it has to traverse fewer NODES each time. The original method is still intact and attempts to minimize the number of splits made. Currently the new method has not been optimized for speed but it is still reasonably fast.

BSPInfo has been included to allow you to gather information about how your node builders compare to each other. You can see if one favors certain characteristics over others, or just get an overall feel for their performance.

• Added support for HEXEN WADs
• Added -d switch for minimizing BSP tree depth
• Added -ri switch to ignore non important linedefs
• Improved error messages for invalid/open WADs
• Fixed bug related to WADs w/o existing NODES/SEGS
• A few more minor speed-ups
• Included BSPInfo

• Added BLOCKMAP creation
• Added new command line options:
  • select multiple levels for each WAD
  • merge multiple WADs into one
  • specify output filename
  • handle multiple seperate WADs
• Replaced ZenNT with a 32-bit DPMI/Win32 Console version
• Placed each platform version in its own sub-directory in .ZIP

• Added ZenNT - Win32 Console version
• A few more minor speed-ups
• Fixed minor bugs
• Added /q switch

• Added new routines to speed up the BSP build process.
• Added /t switch

• Replaced Borland C++'s malloc/free to avoid a bug that causes a GP Fault at run-time on large levels.
• Added Heretic™ to the help screen.

• First public release. Rebuilds BSP found in a single .WAD file specified on the command line.