LScript Patch Release Notes

                                                                                        
  As a result of a new "buffering" mechanism, the pointmove() function was
  moving points in a relative fashion, instead of treating the provided
  coordinates as absolute locations (as they were in v1.3).

                                                                                        
  The new garbage collection mechanism contained a bug that reclaimed function
  memory in both the caller and the called functions upon return from the
  called function!

                                                                                        
  The writeln() method had been inadvertently ommitted from the save()
  i/o object when a new function jump table was implemented.

                                                                                        
  Only the first Layout script to link in an external Object Agent Library
  (OAL) could do so successfully because of an oversight in the Layout
  LScript code.

                                                                                        
  The internal callback functions that support the ctlrefresh() and
  ctlvisible() requester commands were munging LScript's run-time stack.

                                                                                        
  The setvalue() function was not performing sanity checks and data
  conversions where certain Panels controls were concerned (such as
  popup controls).  The symptoms of the problem were that the correct
  value was not appearing in the control after setvalue() was called.

                                                                                        
  The ctlrefresh() and ctlactive() functions were behaving in a mutually-
  exclusive fashion.

                                                                                        
  Although it was documented in the original v1.4 release notes, Point
  and Polygon identifier usage in mathematical expressions was not
  complete in the LScript code.  Thinking I had completed this feature,
  I documented it in the release notes.

                                                                                        
  An unforseen side effect of the correction to default value assignments,
  UDF arguments were being ignored in the pre-/post-increment code because
  of their (new) special type designations.

                                                                                        
  The Camera Object Agent fStop() method was actually returning the camera's
  focal distance setting.

                                                                                        
  Certain Camera- and Light-specific methods were incorrectly given to the
  Mesh Object interface.

                                                                                        
  Added a 'range' data member to the Light Object Agent.  This contains the
  maximum range (in meters) of the intensity falloff if this setting is
  enabled, and the light is not distant.

                                                                                        
  Added a 'null' data member to the Mesh Object Agent that contains a
  boolean true/false to indicate if an object is a Null.

                                                                                        
  Corrected the Tab requester control code to correctly recognize and
  handle ctlimage() data on pages.

                                                                                        
  Images placed on panels (with ctlimage()) now have the ability to
  be active or inactive (i.e., they can be used with ctlactive()
  callbacks).  When inactive, they are rendered in black and white.

                                                                                        
  Altering the value of a control using setvalue() while a panel
  was active (i.e., from a callback) did not invoke that control's
  registered refresh callback function.  This is not a bug, as it
  is a situation not explicitly handled by Panels (for good reason),
  however the lack of this type of handling was causing some
  problems with properly refreshing some controls.  A new mechanism
  in LScript now deals with this situation.

                                                                                        
  A new integral object method has been added called hash().  This
  method, useful only with character strings, will return an integer
  value that represents a calculated hash value for that string.  The
  array type also responds to this method, and will calculate a hash
  value for all string elements in the array.

                                                                                        
  Array duplications (which take place when an existing array is
  assigned to a variable) were only duplicating the contents of
  the source array in the target.  Other attributes of the source
  array, such as its dimension count, were not being duplicated.
  In cases of where multidimensional arrays are assigned to existing
  linear arrays, the target array would remain linear.

                                                                                        
  A new integral object method has been added called crc().  This
  method can be used to derive a CRC32 value for the data type.  In
  the case of arrays, all the elements in the array will generate
  a CRC32 value that will be added to the total for the array (making
  it the preferable method of equality testing for arrays).

                                                                                        
  As a result of poor design, the requester callback mechanism was
  treating the ctlactive(), ctlrefresh() and ctlvisible() settings
  as mutually exclusive.

                                                                                        
  Character string arguments passed to a UDF were not being set to the
  correct data type, and as a result, were being discarded by the memory
  manager along with other temporary memory.

                                                                                        
  The Shader API function raycast() has been added to the LS/PT Shader
  Object Agent's toolbox.  Raycast() is essentially a faster version of
  raytrace(), accepting the same parameters, but only returning the ray
  length.  No shading is evaluated, and no recursive raytracing takes
  place.

                                                                                        
  Internal corrections and updates have been effected in order to
  successfully build LScript v1.4 for the Mac PPC platform.  Changes
  in the PPC compiler between updates broke LScript's Object Agent
  loading code.

                                                                                        
  The ctlimage() requester function has been hooked into LScript's
  internal component search engine.  This means that all defined
  search paths will be used to locate the image file it is not
  immediately visible as it is referenced in the script.  If the
  image cannot be found in any of the existing search directories
  (locations that LScript remembers when it prompts you to locate
  script components), it will now prompt you to locate the image
  referenced, and will remember that location in subsequent searches.

                                                                                        
  The LScript internal component search engine has had it's maximum
  number of maintained search paths reduced from 100 to 20 for disk
  space and run-time memory considerations.  As a consequence, the
  search engine will "age" search paths each time this maximum amount
  is reached.  The oldest path in the list will be discarded each time
  a new path is introduced.

                                                                                        
  Images referenced by ctlimage() were being ignored by the compiler
  if they were not immediately visible by the name provided.  The
  compiler will now prompt you to locate images that it cannot find
  through its existing search paths.

                                                                                        
  The code in the effectedby() function that dealt with Bones contained
  an endless-loop condition that would cause Layout to hang if one or
  more bones were referenced.

                                                                                        
  The effectedby() function could potentially crash the application if
  no valid object names were provided.

                                                                                        
  The component search engine was performing selected-file comparisons
  in a case-sensitive fashion.  This resulted in failed searches.

                                                                                        
  The Scene Object Agent's 'fps' data member was being returned as
  an integer instead of a floating-point value.

                                                                                        
  The polyinfo() function was running horrendously slow.  This wasn't
  really apparent until the function was called repeatedly in a loop.
  The reason for this was that polygon points were processed each
  time to determine their index values--each call to polyginfo() scanned
  all the points in an object to determine point order.

  A new generate-on-the-fly point indexing scheme has been implemented
  in LScript.  A point's index order in the mesh is not calculated until
  the point is used in a fashion that would render it as an integer (i.e.,
  in a mathematical expression or an array index).  Distributing this
  overhead on an as-needed basis increases the polyinfo() function's
  processing speed by more than two orders of magnitude.

                                                                                        
  A new Layout LScript function called targetobject() has been added.
  This function, given a source and target object identifier, along
  with a time index, will return the heading, pitch, and bank values
  required to make the source object's Z-axis normal face the target
  object.  (This function was added to support a NewTekniques article
  that provided automated weapons targeting.)

  Because targetobject() returns these three rotational values as
  a vector, its output can be piped directly into the Item Motion's
  set() method:

      ...
      ma.set(ROTATION,targetobject(me,source,time));
      ...

                                                                                        
  Reentrancy has been a problem for Layout LScript in certain
  situations.  Specifically, when objects have dependencies upon
  each other and "Show Motion Paths" has been enabled.  In order to
  properly update the display, Layout will often call a plug-in's
  process() function even while the plug-in is already in its
  process() function handling another instance.

  A new instance stack mechanism has been implemented to handle
  these recursive calls to process() by Layout.  Among other things,
  it enables objects to have dependencies upon each other.

                                                                                        
  A few other minor bug fixes.

                                                                                        
  The instance stack mechanism introduced in thE last release had
  some hidden issues.  After some quality therapy, those issues have
  been addressed.

                                                                                        
  Certain error messages were performing NULL pointer dereferencing
  under particular circumstances.

                                                                                        
  The getfile() function was using character buffer sizes that would 
  hold only up to 99 characters.  This has been greatly increased,
  approximately double the operating-system standard size of 256
  characters.

                                                                                        
  The pointinfo() function, only valid during a MeshDataEdit session,
  was not correctly being trapped when no edit session is active.

                                                                                        
  The readVector() method was incorrectly reading floating-point
  values into variables declared as doubles.  These two numeric
  values have completely different internal sizes and formats.

                                                                                        
  Static memory allocations made for the instance mechanism were
  causing the Alpha run-time plug-ins to more than double in size.

                                                                                        
  The Image chunk of a compiled LScript was not being recognized by
  the Layout run-time system.  This was causing images embedded in
  the compiled script to be improperly prompted for when it was run.

                                                                                        
  The pre-processor would not properly ignore/regard pragma
  directives that were enclosed with an @if/@end conditional
  sequence.

                                                                                        
  The run-time name construction system, introduced in release 1.4,
  (over a year ago!) was not working properly to construct function
  names when those functions were called with arguments.

                                                                                        
  The number() function was not handling all valid data types.

                                                                                        
  The modulo operator (%) was not functioning properly with integer
  values.