POV-Ray

Setting File_Gamma=1.0 produces unexpectedly bright output files for most output file formats, as if File_Gamma was set to 2.2 instead.

The underlying problem is a bug that, when File_Gamma is set to exactly 1.0, causes the encoding gamma function to be undefined, which was not meant to happen in current versions, and instead was reserved for future versions to signal that a file-format-specific default encoding gamma should be used. The image file output handlers already support this, most of them choosing the sRGB transfer function, giving roughly the same output as setting File_Gamma=2.2.

As a preliminary workaround, users may want to set File_Gamma=1.02 (any value smaller than 0.99 or greater than 1.01 should do).

When aborting a render when there are unfinished blocks among finished ones, under certain conditions some of those blocks are skipped when continuing the render later.

There are a number of problems with the Windows version of POV-Ray under Windows Vista. To resolve these, the setup program needs to be re-written and the location of internal files changed.

Recruit version 3.7 documentation editors from the users community.

Bounding box computation for CSG intersection appears to be broken when one member is an arbitrarily transformed plane.

POV-Ray 3.6.2 has the same problem (can’t test for 3.6.1).

// +W640 +H480 +MB1

#include "transforms.inc"

camera {
  location  <-0.2, 0.5, -4.0>
  direction 1.5*z
  right     x*image_width/image_height
  look_at   <0.0, 0.0,  0.0>
}

sky_sphere {
  pigment {
    gradient y
    color_map {
      [0.0 rgb <0.6,0.7,1.0>]
      [0.7 rgb <0.0,0.1,0.8>]
    }
  }
}

light_source {
  <0, 0, 0>            // light's position (translated below)
  color rgb <1, 1, 1>  // light's color
  translate <-30, 30, -30>
}

plane {
  y, -1
  pigment { color rgb <0.7,0.5,0.3> }
}

intersection {
  sphere {
    0.0, 1 }
  plane { -x, 0 transform { Shear_Trans(x,y+x*0.3,z) } }
  texture {
    pigment {
      radial
      frequency 8
      color_map {
        [0.00 color rgb <1.0,0.4,0.2> ]
        [0.33 color rgb <0.2,0.4,1.0> ]
        [0.66 color rgb <0.4,1.0,0.2> ]
        [1.00 color rgb <1.0,0.4,0.2> ]
      }
    }
    finish{
      specular 0.6
    }
  }
  rotate -y*5
}

Source code inspection during examination of issues with the scene published at http://povray.sitewww.ch/?p=177 show the following issues with current (beta.34) implementation of dispersion in POV-Ray 3.7:

• The same adjustment to the IOR that is applied at the very first dispersion interface is erroneously applied to all subsequent interfaces.

• As an exception, dispersion adjustment is erroneously not applied to any interface defined by the surface of a non-dispersing object embedded into a dispersing object.

While this still allows to use dispersion for artistic effect, it is neither physically realistic, nor does it match 3.6 behavior.

This item may need to be merged with item FS#81. This is another sphere sweep bug, though they are of different spline types.

The code is

#include "colors.inc"

camera {
  location  <0, 0.0, -4.0>
  direction 1.5*z
  right     x*image_width/image_height
  look_at   <0.0, 0.0,  0.0>
}

light_source {
  <0, 0, 0>            // light's position (translated below)
  color rgb <1, 1, 1>  // light's color
  translate <-30, 30, -30>
}


#declare i_start = 0;
#declare i_stop = 3;
#declare i_step = 0.05;
#declare i_inc = i_start;
sphere_sweep {
  linear_spline                 // linear curve

  (i_stop - i_start)/i_step + 1,    // number of specified sphere positions
#while(i_inc<=i_stop)
  
  #declare y_coor = 0.23*sin(7.1*i_inc);
  <i_inc, y_coor, 0>, 0.05
        #declare i_inc = i_inc + i_step;
 
        
#end

pigment{color Orange}

}

The code to attenuate transmitted photons according to surface texture was apparently duplicated during refactoring of the source code for version 3.7. Behavior has changed from 3.6 to 3.7 (beta.36) accordingly, as can be demonstrated with the following scene:

global_settings {
  assumed_gamma 1.0
  max_trace_level 10
  photons { spacing 0.02 }
}

camera {
  right x*image_width/image_height
  location  <0,2.6,-10>
  look_at   <0,0.75,0>
}

light_source {
  <500,300,150>
  color rgb 1.3
  photons {
    refraction on
    reflection on
  }
}

sky_sphere {
  pigment {
    gradient y
    color_map {
      [0.0 rgb <0.6,0.7,1.0>]
      [0.7 rgb <0.0,0.1,0.8>]
    }
  }
}

plane {
  y, 0
  texture { pigment { color rgb <1.0, 0.8, 0.6> } }
}

#declare M_Glass=
material {
  texture {
    pigment {rgbt 1}
    finish {
      ambient 0.0
      diffuse 0.05
      specular 0.6
      roughness 0.005
      reflection { 0.1, 1.0 fresnel on }
      conserve_energy
    }
  }
  interior {
    ior 1.5
    fade_power 1001
    fade_distance 0.9
    fade_color <0.5,0.8,0.6>
  }
}

#declare M_PseudoGlass2=
material {
  texture {
    pigment {rgbf <0.8,0.2,0.2,0.8>}
    finish {
      ambient 0.0
      diffuse 0.05
      specular 0.6
      roughness 0.005
      reflection { 0.1, 1.0 fresnel on }
      conserve_energy
    }
  }
  interior {
    ior 1.0
  }
}

sphere {
  <1.1,1,-1.3>, 1
  material { M_Glass }
  photons {
    target 1.0
    refraction on
    reflection on
  }
}

box {
  <2.4,0,-2.3>, <2.6,4,0.3>
  material { M_PseudoGlass2 }
  photons { target 1.0 refraction on reflection on }
}

Reflections in multi-layered textures are broken in 3.7 betas, as can be demonstrated with the following scene showing two reflective hemispheres on a checkered plane:

camera {
  location  <1.0, 0.5, -4.0>
  direction 1.5*z
  right     x*image_width/image_height
  look_at   <0.0, 0.0,  0.0>
}

sky_sphere {
  pigment {
    gradient y
    color_map {
      [0.0 rgb <0.6,0.7,1.0>]
      [0.7 rgb <0.0,0.1,0.8>]
    }
  }
}

light_source {
  <0, 0, 0>            // light's position (translated below)
  color rgb <1, 1, 1>  // light's color
  translate <-30, 30, -30>
}

default {
 finish { diffuse 0 ambient 0 specular 0 }
}

// ----------------------------------------

plane {               // checkered floor
  y, -1
  texture
  {
    pigment { checker color rgb 1 color blue 1 }
    finish{ diffuse 0.8 ambient 0.1 }
  }
}

// left hemisphere
intersection {
  sphere { 0, 1 }
  plane { x, -0.002 }
  texture {
    pigment { color rgb 1 }
    finish{ reflection { 0.5 } }
  }
  texture {
    pigment { color rgbt 1 }
    finish{ reflection { 0.4 } }
  }
  texture {
    pigment { color rgbt 1 }
    finish{ reflection { 0.1 } }
  }
}

// right hemisphere
intersection {
  sphere { 0, 1 }
  plane { -x, -0.002 }
  texture {
    pigment { color rgb 1 }
    finish{ reflection { 1.0 } }
  }
}

Note that the reflection parameters of the left, multi-layered hemisphere sum up to 1.0, i.e. the same value as used in the single layer in the right hemisphere.

The first attached file (test_3.6.2.png), rendered with POV-Ray 3.6.2, shows the expected output: Both hemispheres appear to have the same reflectivity.

The second attached file (test_3.7.0.beta37a.png), rendered with POV-Ray 3.7.0.beta.37a, shows a much brighter left (multi-layered) sphere.

As it turns out, in order to get the expected result with POV-Ray 3.7.0.beta.37a, the reflectivity of each layer must be divided by 3, 2 and 1, respectively (which obviously does not sum up to 1.0):

  ...
  texture {
    pigment { color rgb 1 }
    finish{ reflection { 0.5 / 3 } }
  }
  texture {
    pigment { color rgbt 1 }
    finish{ reflection { 0.4 / 2 } }
  }
  texture {
    pigment { color rgbt 1 }
    finish{ reflection { 0.1 / 1 } }
  }
  ...

Multi-textured blobs are broken with 3.7 beta 40 when used inside an intersection, as can be demonstrated by the following scene:

#default { texture { pigment { rgb 1 } } }

camera {
  right x*image_width/image_height
  location  <0,1.5,-4>
  look_at   <0,1,0>
}

light_source { <500,500,-500> color rgb 1 }

difference { blob {
  threshold 0.6
  sphere { < 0.75,   0,    0>, 1, 1 texture { pigment { color red 1 } } }
  sphere { <-0.375,  0.65, 0>, 1, 1 texture { pigment { color green 1 } } }
  sphere { <-0.375, -0.65, 0>, 1, 1 }
} }

With POV-Ray 3.7.0 beta 40, the entire blob is rendered with the default texture.

The same problem can be seen with “difference” or “merge” instead of “intersection”.

Omitting the CSG “envelope”, using “union”, or assigning the blob to a variable first and then using it inside an intersection, will yield the expected result.

POV-Ray 3.62 renders all variants as expected.

According to initial analysis, the problem appears to be caused by the dual use of the “MULTITEXTURE_FLAG”, which is used in CSG to indicate use of the “cutaway_textures” feature, and in blobs to indicate per-element texturing. (The same flag is also used in meshes to indicate per-face or per-vertex texturing, so similar problems are to expected there.)

My proposal is to use an entirely separate flag for the “cutaway_textures” feature (the blob and mesh can safely continue to share the MULTITEXTURE_FLAG).

I rendered attached .pov file with both 3.62 and 3.7RC1, and got different output between them.
In 3.7RC1, it looks like no_reflection option of the black sphere doesn’t work.

#macro A()
  #local foo = function { x }
  foo
#end

#local bar = A();

This causes either a segfault, corruption detected by malloc, or “Parse Error: Unknown user defined function”.

After some debugging I think this is what happens.

In source/backend/parser/parse.cpp, Parser::Parse_RValue is called to define the value of bar. Get_Token is called, which invokes A() and which ultimately returns foo as a FUNCT_ID_TOKEN. This token is handled by CASE_VECTOR in Parse_RValue. The relevant clause calls Parse_Unknown_Vector to parse additional tokens (e.g. “foo ( 1 )”). There aren’t any other tokens, but in the process of determining that, #end is reached and Return_From_Macro destroys the symbol table of A, including foo.

So by the time the CASE_VECTOR clause decides that foo is a function identifier that should be copied, the function is destroyed (both the function itself and its number in the symbol table). So here:

    Temp_Data  = (void *) Copy_Identifier((void *)*Token.DataPtr,*Token.NumberPtr);

if *Token.DataPtr (in this case, a function index) was already overwritten, we get “Unknown user defined function”; if it still has the valid function number, it increments the reference count of the function (which has already been freed) back from 0, and we get a double-free later.

A similar problem occurs when foo is a spline.

A tentative patch for the function case is attached.

UV-mapped textures for parametrics are broken in POV-Ray 3.70 RC3, in cases where two (or more) parametrics overlap in a scene.

In the following scene, note how the texture per se is always taken properly from whichever parametric is in front, while the UV coordinates are erroneously taken always from the red parametric where both overlap, no matter whether it is in front or back.

camera {
  location  <0.0, 1.5, -3.0>
  direction 1.5*z
  right     x*image_width/image_height
  look_at   0
}

light_source { <-30, 30, -30> color rgb 1 }

#declare Param = parametric {
  function { u*v*sin (15*v) },
  function { v },
  function { u*v*cos (15*v) }
  0, 1
  contained_by { box { -1,1 } }
  accuracy 0.002
  precompute 15 x,y,z
  rotate 180*x
  translate  <0.3,0.5,0>
}

object {
  Param
  uv_mapping
  texture {
    pigment {
      gradient x frequency 3
      color_map {
        [0 color red .5 ]
        [1 color red 1 ]
      }
    }
  }
}

object {
  Param
  uv_mapping
  texture {
    pigment {
      gradient x frequency 7
      color_map {
        [0 color green .5 ]
        [1 color green 1 ]
      }
    }
  }
  rotate y*180
}

POV-Ray 3.62 renders the scene properly.

As this bug has been found during code inspection, the uderlying cause has already been identified; I’m currently working on a fix.

Beta 32 is failing to render a mesh2 smoothly on 64-bit XP - output shows flat triangles rather than smoothed triangles.
Issue is not present in 32-bit build.

Reported in http://news.povray.org/49e51489%241%40news.povray.org. Demo image rendered using standard chessmesh scene.

The version 3.6 documentation needs to be updated to suit the changes for version 3.7.

Subsurface scattering must be made radiosity-aware.

Adjusting the brightness of an image-mapped sky sphere, although not an uncommon task especially when using HDR light probes, currently is cumbersome at best, as it is not possible to specify a “finish { ambient ... }” statement.

To simplify tuning a sky sphere’s brightness, I suggest introducing a “brightness FLOAT” modifier (defaulting to 1.0) to either the sky_sphere block or (as a more versatile solution) the image_map statement.

Input image files may have been created with gamma pre-correction for some specific target gamma, which may vary from image to image. Some file formats like PNG or HDR support embedding gamma pre-correction information in the image file, but this information may be missing or faulty, and some formats don’t support it at all. Additionally, it may be desirable to tamper with an input image’s gamma for artistic reasons.

Therefore, I suggest adding a means to explicitly specify input images’ originally intended target gamma on a per-image basis, like:

image_map { jpeg "MyImage.jpg" assumed_gamma 1.8 }

The Rect data type needs to be renamed to avoid a clash with a Mac OSX declaration. It was originally called Rectangle, but this clashed with a Windows declaration. Something more POV-specific should be used, e.g. PovRect.

Using a facet pattern in a normal map results in a unspecified error in Evaluate_TPat at the render stage.
This probably should be caught at parse time to give a more descriptive error and a line number.

Example:

sphere {
  0, 1
  texture{
    pigment{rgb <1,1,1>}   
    normal {
      facets
      normal_map {
         [0 bumps ]
         [0.5 facets ]
         [1 bumps ]
      }
    } 
  }
}

Files of exactly 4k length can cause a full crash exception when opened.

Overlapping partially transparent objects can result in speckled shadows.
Rays shouldn’t leak through the coincident areas, they should return one
of the two textures. This was correct in 3.6.

#declare testmat = material { texture {
      pigment {color <1,0,0> transmit 0.5}
}};

camera { location  <1.0, 2.0, -4.0>
   direction 1.5*z
   right     x*image_width/image_height
   look_at   <1.0, -0.2,  0.0>
   angle 30 }

light_source {<-10, 10, -5> color rgb <1, 1, 1>}

plane {y,-1 pigment{rgb <1,1,1>}}

union {
   sphere {<0.0,0,0>,0.5 material{testmat}}
   sphere {<0.1,0,0>,0.5 material{testmat}}
   sphere {<0.2,0,0>,0.5 material{testmat}}
   sphere {<0.3,0,0>,0.5 material{testmat}}
   sphere {<0.4,0,0>,0.5 material{testmat}}
   sphere {<0.5,0,0>,0.5 material{testmat}}
}

Using trace or inside with a julia fractal causes a crash.

#declare Test = julia_fractal {
  <-0.083,0.0,-0.83,-0.025>
  quaternion
  cube 
  max_iteration 8
  precision 20
};
#declare Norm = <0,0,0>;
#declare Hit = trace(Test,<0,0,-10>,z,Norm);
#declare Center = inside(Test,<0,0,0>); 

Reflective texture maps can cause a stack overflow crash.

sphere{0,1
  texture{
   bozo
   texture_map{
    [0 pigment{rgb 0}]
    [1 pigment{rgb 0} finish{reflection 1}]
   }
  }
}

There can be square (32×32) blotches in partially transparent objects.

global_settings {
   max_trace_level 10
}

camera { 
   location <-30,10,5> 
   look_at <0,0,0> 
   angle 25 
}


light_source { 
   <-100,30,70> 
   rgb 1 
}

difference { // make a dome
  sphere { <0,0,0> 5 }  // ball
  sphere { <0,0,0> 4.9 } // hollow interior
  box { <-6,-6,-6> <6,1,6>  pigment { rgb <0,0,0> }}  // chop off bottom half
  pigment { rgbt <1,1,1,0.675> }
}

box { 
   <-6,-6,-6>, <6,0.99,6> 
   pigment { rgb <1,1,1> } 
   rotate <0,45,0>
} // sit it on a box

Array.inc and subsurface.pov are in read only mode, they probably should have normal permissions.

Adding an AOI pattern is asked for fairly frequently.

In unix distribution these scripts

• allscene.sh
• allanim.sh
• porfolio.sh

have the variable VERSION set to 3.6

3.6x only bug with easy/known fix. Error message: “Identifier expected, incomplete function call or spline call found instead.” caused by token counter variable using the wrong special value. The symptom occurs when using a lot of splines. See this thread for details.

(I am using a self-compiled special build because I use a lot of splines in 3.6 but would rather use an official 3.6)

Beta 32, compiled from source on Linux/Ubuntu, amd64.

The random “window display lock” is back.
(as the previous “solution” was to get no window display usable, that’s not so bad).

What is it: sometime, when the rendering window is activated, povray just draw the frame
of the window, paint it black, does not display anything else but seems to perform the
rendering in separate threads. Whenever the mouse move over the frame of the window, it
unlock the updating process and big parts of the rendered image pop up.

What it is not fine: if you do not move the mouse over the window, povray will just stall.
This is more a problem for animation rendering, as getting the display might be a wanted
bonus to monitor the rendering images, and you just fall into that lock: your expected
night rendering could very well be suspended on the first frame.
Moreover, the “move the mouse over” works only for local display. In previous beta (not
yet checked with 32), with a remote display, there was no way to unlock povray.

Linux beta 32, 64bits, compiled from sources.

povray -w800 -h600 +a0.3 +kfi1 +kff78
-L/usr/local/share/povray-3.7/scenes/incdemo
-Ii_internal.pov +WT5 +R4 +AM1 +MB1

Important issue: +WT5 +MB1

Seems Fine for +WT1 +MB1
Also fine for +WT5 +MB9

The intersection with the containing box displays some two-shades of grey
random checkered patterns.
Size of square looks like size of renderering thread. Position too.

Impacted frames (of 78):
01, 02, 03, 30, 48, 74, 76.

Versions of POV-Ray prior to 3.7 had the ability to write the image output as a stream to STDOUT. This was particularly useful in unix as it allowed POV-Ray output to be directly piped to other processes.

The introduction of SMP and the associated non-linear generation of pixels complicates stream output to the extent that it is not currently available in v3.7.

At a minimum 3.7 must at least be able to write the completed image to STDOUT after a render - this is not an optimal solution but is better than nothing. Ideally however once entire lines are complete (most likely this will occur in batches due to the block nature of the render subdivision) these lines will be written immediately to STDOUT (after possibly being processed through the appropriate image format routines).

NB currently the image format routines are not invoked until the entire render is completed, so to do this would be a significant modification. However if we limit real-time stream output to “simple” non-compressed formats (e.g. PPM), it would not be overly difficult, and from the point of view of Unix-like operating systems (where the piping feature is most useful), if the data is in PPM format it can easily be transformed into anything else.

Function use in image maps is broken.

The following should result in a white and green checkered unit square, but is transparent.

camera {
   location  <0.0, 0.5, -4.0>
   direction 1.5*z
   right     x*image_width/image_height
   look_at   <0.0, 0.0,  0.0>
}

background {rgb <1,1,1>}

light_source {
  <-30, 10, -30>           
  color rgb <1, 1, 1> 
}

plane {y,-1 pigment{checker rgb <1,0,0> rgb <1,0.5,0.5> }}

plane {y,-0.99 
 pigment {
  image_map { 
   function 10,10 { 
    pigment {checker rgb <0,1,0>, rgb <1,1,1> scale 0.1}
   }
   once 
  }
  rotate <90,0,0>
 }
}

The parser is failing to read the .tiff file extension from the input string...

bump_map { tiff "earth03_hf2.tiff" }

Results in file not found, but

bump_map { tiff "earth03_hf2" }

will find the file. It might be that it’s not a three character extension?

The parser is missing extra period characters when it parses a float as a vector component.

#local sample = <0.0.0.1,0,0>;

Doesn’t generate an error, but should.

I’ve been trying to upgrade povray 3.6.1 to 3.7-beta-32. I’ve configured with no additional arguments, and the configure dies with:

checking whether to build the boost thread library from sources... no
checking for boostlib >= 1.35... yes
checking whether the Boost::Thread library is available... yes
checking for exit in -lboost_thread... no
checking for exit in -lboost_thread-boost_thread... no
configure: error: Could not link against boost_thread-boost_thread !

I figured that the problem was with my boost installation (1.35) and upgraded boost to 1.39; the problem remains. I tried to see if exit was defined in libboost_thread and/or libboost_thread-boost_thread and it isn’t. Just to be sure that my currrent setup works for the released version, I rebuilt/reninstalled 3.6.1, which went without problem.

I’m on a slackware-12.2 box, using gcc-4.4.0.

The commands:

povray +i /home/ronis/Nm=500/povray.00001.pov

or

povray +i/home/ronis/Nm=500/povray.00001.pov

fail with: povray: this pre-release version of POV-Ray for Unix expires in 2 day(s) and 1 hour(s)
Failed to parse command-line option

Going to the directory and simply running: povray +i povray.00001.pov
works.

I came across this by accident trying to get emac’s povray mode to work; apparently it passes the full path name to povray.

I don’t think there is a problem in 3.6.1

After a recent update on the POV-Wiki the GuMax skin doesn’t recognize MediaWiki:Common.css entries.

Develop MediWiki extension to extract documentation sets from the POV-Wiki.

The following files were garbled in changelist #4648 by stripping all line terminators, making the files unusable:

• .../scenes/advanced/cats/cattext.inc
• .../scenes/animations/life/blink4.inc
• .../scenes/animations/life/walker.inc

Line terminators of these files were already problematic in previous versions of the file, having been CR-only.

The following files changed with #4648 should be reviewed closely as well, as they were previously CR-only, too, and at least some of them exhibit some peculiarities regarding line and/or file terminators:

• .../scenes/animations/pentmap/pentmap.ini
• .../scenes/animations/pentmap/pentmap.pov
• .../scenes/animations/slinky/slnk.ini
• .../scenes/incdemo/metals/metals.doc
• .../scenes/incdemo/stones/stones.doc
• .../scenes/incdemo/woods/morewood.doc
• .../scenes/incdemo/woods/woods.doc
• .../scenes/textures/pigments/skies/skies.doc

Reported for freebsd 7.2 (current production version, true for previous version, unknown for 8.0 in beta now)

freebsd does not provide CLOCK_PROCESS_CPUTIME_ID
(even if CLOCK... is posix).

As a consequence, compilation of the unix-source is currently not possible for freebsd target.

Might be a simple selection for Change 4356 ?
(assuming a relevant test in ./configure)
(getrusage() seems available on freebsd, but does it provide the pieces of information needed, I do not know that code good enough to assert that)

In POV-ray 3.7 beta 33 under Windows XP, the editor’s MRU list incorrectly handles files that have a comma in the pathname. Only the part of the name before the comma appears on the MRU list, but the rest of the name is left off.
Consequently, the file cannot be reopened via the MRU list. The file is also not reopened on launch if pov was closed with the file open. This also occurs in 3.6.1, I haven’t tried it under 3.6.2 yet.

Interestingly enough, a quick peek in the registry shows that both 3.6 and 3.7
are saving the entire path name correctly under HKEY_CURRENT_USER\Software\POV-Ray\v3.6\POV-Edit\Recent (or \v3.7\POV-Edit\Recent).

This seems to be limited strictly to the editor’s MRU list. The file can still be opened normally using the open dialog box. Calling POV-ray from the command line and using a file or path name with commas in it works correctly. Included files with commas in the path work correctly, and the Tools→Edit last rendered file/View last rendered file work correctly also.

To duplicate, save a file with a comma in the pathname (either in the directory
name or the filename itself). Close the file, then attempt to reopen it using the MRU list in the file menu.

Some sample scenes are no longer up-to-date, causing warnings, and should be fixed. For instance, the advanced/benchmark scene still includes “Buffer_Output=Off” and “Buffer_Size=0” in its .ini file. This should be checked systematically, and fixed as appropriate.

It seems that the new area_illuminate flag for area lights does not take into account fade_power and fade_distance. The illumination falloff is still being calculated from the center of the light_source.

Here’s some relevant code:

camera{
  location<0,10,-10>
  look_at 0
}
plane{y,0 pigment{rgb 1}}
light_source{
  y*.1,100
  area_light x*10, z*1, 8, 8
  jitter
  area_illumination
  fade_power 2 fade_distance 1
}

When rendering a series of scenes (e.g. animation, or render queue in POV-Ray for Windows), number_of_waves is not properly reset to its default value between scenes, causing the parameter to default to the value set by the previous scene.

For instance, rendering the following scenes from a queue will cause “arches.pov” to be rendered differently the second time:

1. scenes\textures\finishes\arches.pov
2. scenes\textures\normals\normavg.pov
3. scenes\textures\finishes\arches.pov (again!)

The following (bogus) SDL code causes POV-Ray 3.7 beta to crash hard with an access violation:

#include "fubar.inc"
Bar(42)
#macro FooBar() #end

//fubar.inc
#macro Foo(Fnord) #end
#macro Bar(Ignord) Foo(23 #end

The parser does not accept mesh objects (or CSG objects including a mesh object) as a parameter to the inside() built-in function, reporting error “Solid object identifier expected”, even if the mesh is “solidified” by specifying an inside_vector.

(see news://news.povray.org:119/4a983716@news.povray.org)