POV-Ray

The Persistence of Vision Raytracer (POV-Ray).

This is the legacy Bug Tracking System for the POV-Ray project. Bugs listed here are being migrated to our github issue tracker. Please refer to that for new reports or updates to existing ones on this system.

IDCategoryTask TypeReported InPrioritySeveritySummaryStatusProgress  descDue In Version
25AnimationDefinite Bug3.70 beta 32DeferLowPause sometimes fails when rendering animationTracked on GitHub
90%
Task Description

There is an issue where the pause button in POVWIN will sometimes not work during an animation (primarily where the frame rate is high), and furthermore, POVWIN can then get into a state where it’s not possible to use the pause until it is re-started.

Newsgroup report.

321OtherDefinite Bug3.70 releaseVery LowLowbounding threshold inconsistencyTracked on GitHub
90%
Task Description

User reported documentation inconsistency. Investigation led to the discovery of a bug in the setting of the current default value.

~source/frontend/renderfrontend.cpp reports the value “3” while ~source/backend/scene/scene.cpp sets a default value of “1”

Before for addressing this issue, are there any thoughts as to what the default value should be?

4Subsurface ScatteringUnimp. Feature/TODO3.70 beta 32Very LowLowIntegrate Subsurface Scattering with standard lighting ...Tracked on GitHub
90%
Future release Task Description

Subsurface Scattering still uses its own rudimentary code to compute illumination from classic light sources; this must be changed to use the standard light source & shadow handling code, to add support for non-trivial light sources (e.g. spotlights, cylindrical lights, area lights), partially-transparent shadowing objects etc.

196Subsurface ScatteringDefinite Bug3.70 RC3Very LowLowMore SSLT CaveatsTracked on GitHub
90%
Future release Task Description

when a prism is differenced with a primitive (cylinder in this case) if sslt is used it causes a seq fault. Reference distribution file logo.inc and the Povray_Logo_Prism definition.

301OtherDefinite Bug3.70 RC7Very LowLowFallback to default image size causes wrong values to b...Tracked on GitHub
50%
Task Description

When resolution is not specified (neither via POVRAY.INI nor via QUICKRES.INI nor via command line or custom .ini file), random values are displayed for image resolution in the Image Output Options message output. (The actual render will be performed at the default size of 160×120 pixels though.)

206OtherPossible Bug3.70 RC3Very LowLow"Cannot open file" error when text output files specifi...Tracked on GitHub
50%
3.71 release Task Description

I created an INI file which specifies the Input_File_Name, Output_File_Name, and also the Render_File and the remaining four text outputs as double-quoted absolute paths on my disk. When I run the render, I get the following output:

Preset INI file is ‘C:\USERS\TPREAL\DOCUMENTS\POV-RAY\V3.7\INI\QUICKRES.INI’, section is ‘[512×384, No AA]’.
Preset source file is ‘D:\Ruby\POV-Rb\ini\20110521_004037_Noix.ini’.
Rendering with 2 threads.
-
Cannot open file.
Render failed
-
CPU time used: kernel 0.06 seconds, user 0.02 seconds, total 0.08 seconds.
Elapsed time 0.52 seconds.

And the render does not start. The five text output files are not even created, and where the output image should be, there is a file with extension pov-state. The render works as it should only when I remove all five lines defining the five text output files. The paths I specify for the files are correct (paths exist and files do not, no white-spaces or anything), read/write restrictions are disabled in POV-Ray. This used to work in 3.6 and does not work now in 3.7 RC3. The error happens no matter if I run the render using GUI or command line.

(Also please note that the error message is really not useful here, it does not say which file it failed to open, and not even if it was an attempt to open for read or for write.)

I’d be really glad if you could correct this as it’s a critical functionality for me. I’m generating the POV-Ray code automatically and I need to parse the text output automatically to return the status to the generator.

98Refactoring/CleanupUnimp. Feature/TODO3.70 beta 36DeferMediumRefactor Windows UI code for Unicode supportTracked on GitHub
50%
Future release Task Description

Windows UI code should be refactored to use _TCHAR throughout instead of char, as well as the corresponding string function macros, to head for Unicode support.

183Texture/Material/FinishPossible Bug3.70 beta 40Very LowLowcutaway_textures broken with child unionsTracked on GitHub
50%
Future release Task Description

When using cutaway_textures in a CSG object that has union children, results are not as expected; instead, surfaces in the union children that have no explicit texture will be rendered with the default texture instead. This is not the case for e.g. difference children.

Example:

#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 }

#declare U = union {
  sphere { <0,-0.1,-1>, 0.3 }
  sphere { <0, 0.1,-1>, 0.3 pigment { color red 1 } }
}

intersection {
  sphere { <0,0,0>, 1 pigment { color green 1 } }
  object { U }
  cutaway_textures
  rotate y*90
}

When declaring U as an intersection instead, the results are as expected, with the surface of the first sphere in U being rendered with the texture defined in the outer intersection.

275Light sourceDefinite Bug3.70 RC7Very LowLowcircular area lights exhibit anisotropyTracked on GitHub
50%
Future release Task Description

circular area lights exhibit some anisotropy, being brighter along the diagonals than on average, as can be demonstrated with the following scene:

//+w800 +h800
#version 3.7;
global_settings{assumed_gamma 1}
plane{-z,-10 pigment{rgb 1} finish{ambient 0 brilliance 0}}
disc{0,z,10000,0.5}
camera{orthographic location z look_at 10*z up y*12 right x*12}
light_source{-10*z rgb 10 area_light 10*x 10*y 257 257 adaptive 4 circular}
287Light sourceDefinite Bug3.70 RC7Very LowLowarea_illumination shadow calculationTracked on GitHub
50%
Future release Task Description

not sure if this is something needing further work or an intended effect.

Shadows from and area light with area_illumination on seem to follow the same shadow calculation as a standard area light by giving more weight to lights near the center of the array. I would assume the shadows would be calculated similarly to individual lights in the same pattern as the array by evenly distributing the amount of shadow equally for each light. But this is not what I see.

The code sample below when rendered with scene 1 will show shadows grouped near the center from the area light with area_illumination. If scene 1 is commented out and scene 2 is uncommented then rendered, you will see evenly distributed shadows from individual lights. Area lighting with area_illumination I would assume should give a result identical to scene 2. If scene 1 is rendered with area_illumination off, the shadow calculation is exactly the same as with area_illumination on.

example images rendered on win32 XP

#version 3.7;

global_settings {
 ambient_light 0
 assumed_gamma 1
}

camera {
  location <0, 3, -5>
  look_at <0, 2, 0>
}

background { rgb <.3, .5, .8> }
plane { y,0 pigment { rgb .7 } }
torus { 1.5,.1 rotate 90*x translate 4*z pigment { rgb .2 } }
plane { -z,-7 pigment { rgb .7 } }

/*
// scene 1
light_source{
  y
  1
  area_light 3*x, z, 7, 1
  area_illumination on
}
union {
 sphere { 0,.05 }
 sphere { .5*x,.05 }
 sphere { x,.05 }
 sphere { 1.5*x,.05 }
 sphere { -.5*x,.05 }
 sphere { -x,.05 }
 sphere { -1.5*x,.05 }
 translate y
  hollow pigment { rgbt 1 } interior { media { emission 10 } }
}
// end scene 1
*/


// scene 2
#declare Light = light_source {
  0
  1/7
  looks_like { sphere { 0,.05 hollow pigment { rgbt 1 } interior { media { emission 10 } } } }
}

union {
 object { Light }
 object { Light translate .5*x }
 object { Light translate x }
 object { Light translate 1.5*x }
 object { Light translate -.5*x }
 object { Light translate -x }
 object { Light translate -1.5*x }
 translate y
}
// end scene 2

75Geometric PrimitivesUnimp. Feature/TODO3.70 beta 34Very LowMediumReplace POV_MALLOC with std::vector in shape codeTracked on GitHub
30%
Future release Task Description

In the files bezier.cpp, fpmetric.cpp, fractal.cpp, hfield.cpp, isosurf.cpp, lathe.cpp, poly.cpp, polygon.cpp, prism.cpp, sor.cpp, and sphsweep.cpp the use of POV_MALLOC can be replaced by std::vector quite easily because the containing class already is a C++ class. As this is a low hanging fruit for continued code cleanup, it should be done sooner rather than later.

313RadiosityDefinite Bug3.70 releaseLowHighradiosity.cpp pov::RadiosityFunction::BeforeTile assert...Tracked on GitHub
20%
Task Description

With 3.7.0 final, rendering attached files (for Computer Engineering college course),
which renders without issues in povray 3.6.1, fails with following error:

...
==== [Rendering...] ========================================================
povray: backend/lighting/radiosity.cpp:324: virtual void pov::RadiosityFunction::BeforeTile(int, unsigned int): Assertion `(pts >= PRETRACE_FIRST) && (pts <= PRETRACE_MAX)' failed.

Command line:

povray +K0.6500 \
+FN +Q9 +MB1 \
+W600 +H400 \
+AM1 +A0.0 +R2 \
+D +SP32 +EP4 \
+L/usr/share/povray-3.7/include \
+Imain.pov \
+Omain-0.6500.png

Using Arch Linux testing current:
Linux archmidi 3.12.0-1-ARCH #1 SMP PREEMPT Wed Nov 6 09:06:27 CET 2013 x86_64 GNU/Linux

Downstream bug report:
https://bugs.archlinux.org/task/37689

145Parser/SDLFeature Request3.70 beta 37aVery LowLowStack trace report on errorTracked on GitHub
10%
Task Description

In other languages if you encounter an error you’ll often be presented with a stack trace showing not only the file and line number the error occurred at, but also any calling functions and _their_ calling functions and so on.

Currently, Povray reports the line number of the error as well as the last five or so lines prior to the error. This is usually OK in simple scenes, but breaks down when you start making use of inclusion and macros.

Let’s say you have a macro located in a file that you then include in your scene. Within your scene you call the macro multiple times, passing input to it. However, by accident you pass _invalid_ input to the macro at some point, resulting in an error when parsing. In this case Povray will report the error as belonging to the macro whereas the actual bug exists in the calling code. If the macro is called more than once in your scene it can be difficult to figure out _which_ instance is the one supplying the bad input.

Not sure how much of this is achievable in Povray.

7RadiosityUnimp. Feature/TODO3.70 beta 32LowMediumRe-implement Radiosity render abort/continue supportTracked on GitHub
0%
Task Description

For proper render abort/continue support, radiosity cache data must be written to (or read from) disk even if the user does not explicitly opt to have a sample data file written/read. This feature has temporarily been dropped from 3.7 beta and is still pending re-implementation.

To meet high-reproducibility requirements in conjunction with SMP operation, it may be necessary to extend the 3.6 radiosity cache file format.

20User interfaceFeature Request3.70 beta 32Very LowVery Lowrender window behaviorTracked on GitHub
0%
Task Description

When changing the behavior of the render window, “Keep above main”, requires restarting the POV editor to take effect. It would be nice either to get a warning to restart, or to get it to work without restarting.

41OtherFeature Request3.70 beta 32Very LowLowimprove command-line parsing error messagesTracked on GitHub
0%
Task Description

POV-Ray 3.6, upon encountering problems when parsing command line and/or .ini file options, would quote the offending option in the error message.

POV-Ray 3.7 currently just reports that there is some problem with the command line, without providing any details. I suggest changing this, as the information may be helpful at times.

42OtherDefinite Bug3.70 beta 32Very LowMediumcommand line parameters are not parsed properly on UnixTracked on GitHub
0%
Task Description

POV-Ray does not follow common practice on command-line handling; for instance:

povray +i"My File"

entered on a Unix shell would be passed to POV-Ray as

povray
+iMy File

(each line representing a distinct parameter here), which POV-Ray would further dissect, interpreting it as

povray
+iMy
File

To achieve the desired effect, one would actually have to quote the string twice:

povray +i"'My File'"

which the shell would translate to

povray
+i'My File'

which POV-Ray would interpret as

povray
+iMy File

In both cases, this is obviously not what a Unix user would expect.

The further dissecting of individual command-line parameters may have had its valid roots in the peculiarities of DOS’ command-line handling, but to my knowledge all major contemporary operating systems follow a concept akin to Unix, passing a list of parameters instead of a monolithic command line, and burdening the respective command shells with the task of dissecting command lines into parameters.

Therefore I suggest to disable this anachronistic feature in favor of contemporary standards; a compiler flag might be used to allow for easy re-enabling of the feature, for compiling POV-Ray on exotic targets.

- edit -

It has been pointed out that the described behaviour differs from 3.6, so I’m promoting this to a bug and changing the title.

47PreviewPossible Bug3.70 beta 32Very LowLowRender Preveiw window can become disabledTracked on GitHub
0%
Task Description

If a render is continued with the +c option and the render had completed, the render preview window will disappear and the show/hide render window button will be grayed. Even after the scene is modified and the command line options have been changed, the show/hide button will still be grayed.

Opening or changing to another scene and rendering will not restore the button, nor will rendering with +d. However, if a trace is started using -d, halted, then continued using +d (or allowed to finish completely with -d and a new one is started using +d), then the preview window is restored.

This behavior is different from 3.6.1, which correctly always showed the preview window (since +d is default) unless -d was specified.

50Runtime errorPossible Bug3.70 beta 32Very LowMediumFrequent segfaults with photon scenesTracked on GitHub
0%
Task Description

I observe frequent segfaults with POV-Ray 3.7 betas when rendering scenes using photons:

  • Debian Linux 4.0r5 “etch” for AMD64
  • AMD Phenom X4 9650 2.3GHz, 6 GB RAM
  • POV-Ray compiled with Intel icpc 11.0

Segfaults are sporadic but frequent (occurring in roughly 50% of all photon renders).

58Parser/SDLUnimp. Feature/TODO3.70 beta 32DeferLowallow SDL code to detect optional featuresTracked on GitHub
0%
Task Description

Some features are optional in custom builds of POV-Ray (I’m thinking about OpenEXR in particular); it would be nice to have a syntax for an SDL script to check for support of such features, so it may take some fallback action if the feature is not supported.

70PhotonsUnimp. Feature/TODO3.70 beta 34LowHighload/save photons should be controlled via command lineTracked on GitHub
0%
Task Description

Just like radiosity load/save, the photon mapping load/save mechanism should be moved to the frontend and controlled via command-line switch, instead of being SDL-driven in the backend.

71User interfaceUnimp. Feature/TODO3.70 beta 34Very LowLowraise warning when command line option has no effectTracked on GitHub
0%
Task Description

Warnings should be raised when a command line option has no effect,
for example...

pvengine +am

is legal, but without the number after it, it has no effect.

pvengine +am7

should be an error, and also raises no warnings.

81Geometric PrimitivesDefinite Bug3.62Very LowMediumsphere_sweep generating artifactsTracked on GitHub
0%
Task Description

I’m running POV-Ray for (64 bit) Windows v3.62 on (64 bit) Windows Vista

This pov file:


#include "colors.inc"
#include "metals.inc"

light_source { <6, 9, -21> color White }
camera { location <0, 0, -3> look_at <0, 0, 0> }

sphere_sweep {
                cubic_spline
                6
                <-2.0, 0, 0> 0.05

                <0.000,0,0> 0.2
                <0.025,0,0> 0.2
                <0.050,0,0> 0.2
                <0.075,0,0> 0.2

                <3.0,0,0> 0.2
                pigment { color White }
}

Produces two strange artifacts: A disk at the center of the sweep, and a faint “halo” or veil which shows as 4 faint hyperbolas centered around the origin.

I have tried tweaking tolerance (for no other reason than I saw that someone else was tweaking it to solve a problem) but this does not seem to change things.

For a look at MY result when I run this, view this image:

riventree.comarchivebugdatapovrayspheresweepartifacts.jpg

Alain reports the same behavior in the latest version: “It’s still there with the latest version: 3.7 beta 35a.” This MAY move the status to “confirmed”, but I can’t do that

Someone else says that changing the scale (!) “solves” the problem by moving the disk and the halo offscreen, but that sounds like a bad idea to me.

-Jeff Evarts, first-time POVRay bug reporter

106DistributionUnimp. Feature/TODO3.70 beta 37Very LowLowUpdate sample scenes and include files for POV-Ray 3.7 ...Tracked on GitHub
0%
Task Description

Most sample scenes and include files were designed at times when POV-Ray did not to any proper gamma handling, or still used the inferior 3.6 “assumed_gamma” mechanism.

All the scenes and include files should be reviewed, and updated to fit the new 3.7 gamma model.

The primary task will probably be gamma-adjusting literal color values and ambient parameters; I suggest using macros (which ideally should be defined in an include file) to be set according to the #version statement, so the scene/include file could be kept compatible with older versions.

138User interfaceFeature Request3.70 beta 37aVery LowLow"Rename" option in File menuTracked on GitHub
0%
Task Description

Would be great if there were a “Rename” option in the editor File menu to rename the current file name. Otherwise, you have to close the file, rename it in file manager, then open the file again, thus loosing the current tab position and undo history for the file.

140Platform-specificFeature Request3.70 beta 37aVery LowLow"Reload" option in File menuTracked on GitHub
0%
Task Description

Would be great to have a “Reload” option in the File menu to manually reload the current file from disk, discarding all subsequent changes since the last save.

151Runtime errorPossible Bug3.70 beta 37aVery LowLowNo way to cancel save while parsing, never ending error...Tracked on GitHub
0%
Task Description

On Windows, when I try and save a file while it is being parsed prior to rendering, I get an error, “Failed to save file: The operation completed successfully”, with a single OK button to click. Despite the weird wording, I’m OK with that.

However after clicking OK I get the error, “Failed to save file ‘...’“, with three buttons: Cancel, Try Again, Continue. Not sure what “Continue” means in this context, given that the possibilities would seem to be covered by the other two buttons. Whatever.

Also, sometimes I get a message with only a single “Retry” button. Not sure what the exact message was.

Anyway, the real problem is that, regardless of which button I press, the program continues to spawning the same error message endlessly. Luckily there is a delay between them, but still it would be nice to have at least one of the three buttons *stop* POV-Ray from asking me again.

Also, once the program finishes parsing the file and it becomes possible once again to save the file, it does nothing. I.e. it doesn’t save the file. So what’s the point of the message and all the options? Why not just say, “Unable to save the file, file is parsing” and be done with it?

I think I recall the same behavior in 3.6.2, so it’s nothing new that’s been introduced.

177Light sourceFeature Request3.70 beta 39Very LowLowAdd support for conserve_energy to shadow computationsTracked on GitHub
0%
Task Description

The following scene gives a comparison of current conserve_energy handling in standard shadow computations vs. photons.

Note how the rather highly reflective slabs fail to cast shadows, except where the photons target sphere enforces computation of shadow brightness to be done by the photons algorithm.

For more realistic shadowing without the need to enable photons, I suggest do add proper conserve_energy handling to the shadow computation code (which shouldn’t be too much effort).

global_settings {
  max_trace_level 10
  photons { spacing 0.003 media 10 }
}

camera {
  right x*image_width/image_height
  location  <-2,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 0.7 } }
}

#declare M_Glass=
material {
  texture {
    pigment {rgbt 1}
    finish {
      ambient 0.0
      diffuse 0
      specular 0.2 // just to give a hint where the sphere is
    }
  }
  interior { ior 1.0 }
}

#declare M_PseudoGlass=
material {
  texture {
    pigment {rgbt 1}
    finish {
      ambient 0.0
      diffuse 0.5
      specular 0.6
      roughness 0.005
      reflection { 0.3, 1.0 fresnel on }
      conserve_energy
    }
  }
  interior { ior 1.5 }
}


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

// behind target object
box {
  <-0.2,0,-2.3>, <0.0,4,0.3>
  material { M_PseudoGlass }
  rotate z*1 // just to better see the reflection of the horizon
}

// before target object
box {
  <2.4,0,-2.3>, <2.6,4,-0.3>
  material { M_PseudoGlass }
  photons { pass_through }
  rotate z*1 // just to better see the reflection of the horizon
}
178Texture/Material/FinishFeature Request3.70 beta 39Very LowLowModify metallic reflection code to better work with con...Tracked on GitHub
0%
Task Description

The combination of metallic reflection with conserve_energy causes the reflection to lose colour, as demonstrated by the following scene:

global_settings {
  max_trace_level 10
}

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

light_source {
  <500,300,150>
  color rgb 1.3
}

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 0.7 } }
}

#declare M=
material {
  texture {
    pigment {rgbt <1.0,0.7,0.2,0.99>}
    finish {
      ambient 0.0
      diffuse 0.5
      specular 0.6
      roughness 0.005
      reflection { 0.8, 1.0 metallic }
      conserve_energy
    }
  }
  interior { ior 1.5 }
}

box {
  <-0.2,0,-2.3>, <0.0,4,0.3>
  material { M }
  rotate z*5
  rotate x*2
}
181BackendUnimp. Feature/TODO3.70 beta 40Very LowMediumUnimplemented, altered or missing features to document ...Tracked on GitHub
0%
Task Description

This is a list of unimplemented features and things to fix with respect to 3.7 vs 3.6 compatibility. They either need to be fixed in code, or failing that, to be documented prior to release.


Create_INI works differently from 3.6. Prior versions of POV-Ray would write all options to the file, even if they were not supplied by the user (non-supplied options would take the default value). Currently in 3.7, only supplied options are written, because the front-end does not send unused options to the back-end. The proper fix for this would be to have a set of defines that establish the defaults all in one place (currently we rely on hard-coded values scattered around the code), and for the Output_INI_Option() function to look up and use the default when not supplied. As this is not likely to be done before 3.7 release, we need to document it as a temporary situation.

The following messages are marked as ‘currently not supported by code’ in povmsgid.h. We need to check where this comment is correct and if so the docs need to be updated to indicate this (for items that are already documented). Some items may be re-implemented later, and some may never be:

  • kPOVAttrib_TestAbort
  • kPOVAttrib_TestAbortCount
  • kPOVAttrib_VideoMode
  • kPOVAttrib_Palette
  • kPOVAttrib_DisplayGammaType
  • kPOVAttrib_FieldRender
  • kPOVAttrib_OddField
  • kPOVAttrib_AntialiasGammaType
  • kPOVAttrib_LightBuffer
  • kPOVAttrib_VistaBuffer
  • kPOVAttrib_DrawVistas

This bug should be edited to add/remove items as time goes by.

202Geometric PrimitivesDefinite Bug3.70 RC3Very LowLowNumerical oddities in Julia_FractalTracked on GitHub
0%
Task Description

I understand that some things have changed in the way certain computations in POV-Ray decide when something is “good enough” and I think this is biting me in Julia_Fractal (where, of course, the highest-resolution computations are needed).

The bug has been posted here:

http://news.povray.org/povray.bugreports/thread/%3Cweb.4dbf2e26b56a53c15b4449250%40news.povray.org%3E/

Including a short .pov file and instructions that reproduce it.

(It pops up in other configurations and view angles as well, but this one captures in in a way that makes it clear it’s a bug: the distance of the camera from the origin appears to change the shape of the rendered object).

This appeared first on a Windows Server 2003 machine, it is apparently confirmable on at least one other system as per that thread.

205DocumentationUnimp. Feature/TODO3.70 RC3Very LowLowSyntax documentation uses inconsistent notationTracked on GitHub
0%
Task Description

The syntax notation used in the main documentation is different than that used in the quick-reference section. This should be changed for consistency, using the superior quick-reference notation throughout.

226Geometric PrimitivesPossible Bug3.70 RC3Very LowLowNear-coincident surface accuracyTracked on GitHub
0%
Task Description

This is a transparent box very close to a plane.

box {
    -1, 1
    pigment { rgbf <0, 0, 1, 1> }
}

plane {
    #if (version < 3.7)
        y, -1.0000007
    #else
        y, -1.00007
    #end
    pigment { rgb 1 }
    finish { ambient 1 }
}

camera {
    location <1, 2, 3>
    look_at 0
}

The box is placed 100 times closer to the plane for 3.6, but both 3.6 and 3.7 produce exactly the same black artifact (attached).

So apparently 3.7 is less accurate. (And the exact factor 100 feels suspicious.)

227Refactoring/CleanupUnimp. Feature/TODO3.70 RC3Very LowHighFixed Vector LimitationsTracked on GitHub
0%
Task Description

See this documentation entry for more details.

229Image formatFeature Request3.70 RC3Very LowLowClock value into EXIF data for PNGTracked on GitHub
0%
Task Description

The best time for a picture....

I set the day time and so the position of the sun by “clock=”

Normal I document my source very good, but this time,
I forgot the clock seting for the picture of my book cover.

So I would find it very practicall to put the clock value
and other setings for rendering
into EXIF data of the picture.

230User interfaceFeature Request3.70 RC3Very LowLowImproved handling of animationsTracked on GitHub
0%
Task Description

October to middle November, I prodduced a 5 minutes video mainly py POVRAY.

Here a part of the video.ini file

#

# szenes based on games.pov
#

#game-pat
#Initial_Frame=450 - time scale 1000 - 30 seconds
#Final_Frame=899
#Initial_Clock=-12500
#Final_Clock=17500

#game-lost - time scale 1000 - 22 seconds
#Initial_Frame=0
#Final_Frame=659
#Initial_Clock=2000
#Final_Clock=24000

#game-lost - time scale 3000 - 12 seconds - fast through the night
#Initial_Frame=0
#Final_Frame=359
#Initial_Clock=24000
#Final_Clock=60000

#book-cover
#clock=64000

#game-sunrise - time scale 1000 - 35 seconds
#Initial_Frame=0
#Final_Frame=1049
#Initial_Clock=60000
#Final_Clock=95000

Now imagine all the problems:

One computer crashes often because of thermal problems.
Last picture rendere 487.

Now calculate the setings, that this computer continues the task at 487

Or 2 computers should render a scene.

Sounds very easy. Something like computer 1 makes 0..499 computer 2 makes 500..999.

But the computers are different in speed and the pictures are
very different in computation time.

So it would be best

computer 1: 0 to 999
computer 2: 999 to 0

They would meet in the middle, where ever this middle is.

So it would be much easier with

#game-sunrise - time scale 1000 - 35 seconds
Initial_Frame=0
Final_Frame=1049
Initial_Clock=60000
Final_Clock=95000
Initial_Task=487
Final_Task=1049

So I have not to calculate the exact clock seting,
when a computer sould continue a task after crashing at picture 487

#game-sunrise - time scale 1000 - 35 seconds
Initial_Frame=0
Final_Frame=1049
Initial_Clock=60000
Final_Clock=95000
Initial_Task=1049
Final_Task=0

This would be the reverse calcualtion order.
Starting with picture 1049 and going down 1048..1047

237User interfaceDefinite Bug3.70 RC3DeferVery LowGlitch in displaying rendered pixels and percentageTracked on GitHub
0%
Task Description

When rendering in multiple passes (radiosity in my case), the elapsed pixels and percentage, written to terminal
are first displayed like this:
Rendered 126202 of 360000 pixels (35%)
Then on the second stage the output text becomes shorter and you see
Rendered 25344 of 360000 pixels (7%)%)
The contents of the previous status are not erased, so the longer text persists (note the duplicate percentage sign and closing parenthesis). Such a glitch could have more drastic effect in rare cases.

I’m running
Version 3.7.0.RC3 (g++ 4.6.2 x86_64-unknown-linux-gnu)
compiled for the Arch Linux package.

240Geometric PrimitivesFeature Request3.70 RC3Very LowLowObject for efficient automatic periodic pavementTracked on GitHub
0%
Task Description

Whenever some object is to be periodically repeated in some kind of grid, you can achieve this with macros, but it
a) wastes a lot of resources

 even if object references are implemented in the future, wrapper with its own transformation matrix still takes space and bookkeeping

b) is not infinite

 annoying when making infinite planar tiling with arbitrary objects
 like an approximate water surface or tiling with real bricks
 or anything that needs to extend to horizon

c) is not optimized for periodicity

I think it can be very efficiently implemented as an object that takes a finite object argument (like CSG functions) and can be periodic in either 1D,2D or (possibly dangeorous?) 3D with specified period. In each dimension, the number of repetitions can be any integer or even infinity (or max_int). Something like
periodicity <2,2,Infinity> 2 copies in 1 direction, 2 in the other, infinite in the third
grid_separation <1,2,2>
1 unit size in first direction, 2 unit sizes in the other two

All the code needs to do is raytrace in the current unit cell and if the ray passes uninterrupted, pass it through the neighbouring unit cell (which means trace a translated ray through the same object). The object itself would just feel an additional clipping box, everything else would work seamlessly.

In case of infinite column of transparent object, max_trace stops the infinite loop anyway.

This is just a suggestion, I realize this is more of a long-term change but it is quite easy to implement and would simplify a large number of projects.

242OtherFeature RequestAllDeferVery LowAlgorithm to fix the so-called shadow line artifactTracked on GitHub
0%
Task Description

The so-called shadow line artifact (http://wiki.povray.org/content/Knowledgebase:The_Shadow_Line_Artifact) which affects objects with a ‘normal’ statement as well as smooth meshes and heightfields can be really annoying sometimes. Currently the only way to remove it is to make the object shadowless, which isn’t a good solution except in very special cases.

This algorithm could remove the artifact: If the actual normal vector of the object points away from the light source (its dot-product with the light vector is negative) but the perturbed normal points towards it (dot-product positive), then ignore the first shadow-test intersection with the object itself.

There are alternative ways of implementing an equivalent functionality:

- Don’t check the condition (if it’s too difficult to check due to how the code is designed) but always ignore the first intersection with the objects itself. This will work properly with closed surfaces but not with open ones, so it might need to be a feature for the user to turn on with a keyword (similar to eg. ‘double_illuminate’).

- Alternatively, don’t ignore the first intersection, but instead ignore the “opposite side” of the object’s surface (again, possibly only if a keyword has been specified). In other words, if we are rendering the outer side of the object, ignore its inner side when shadow-testing, and vice-versa.

- Perhaps simply add a feature to make surfaces one-sided (similarly to how they can be made so in OpenGL and similar scanline rendering systems). In other words, the inner side of a surface is completely ignored everywhere, making the object virtually invisible from the inside. The advantage of this feature would be that it can have uses other than simply removing the shadow line artifact.

246OtherPossible Bug3.70 RC6Very LowLowRegression on scale limit between 3.7 and previous rele...Tracked on GitHub
0%
Task Description

From Thomas de Groot

Using the following code for a (sky) sphere in a scene, with light source well outside the sphere;
works correctly until the above scale value. Use a value of >=100*10e4 and the sphere becomes black.

#version 3.7;
global_settings{ assumed_gamma 1.0 }

#declare T_sky =
texture {
  pigment {
    gradient y
    pigment_map {
      [0.0 srgb <1.0,0.7,0.6>*1 transmit 0.5]
      [1.0 srgb <0.8,0.1,0.0>*1 transmit 0.5]
    }
  }
  finish {
    emission 0.9
    diffuse 0.0
  }
}

#declare T_cosmos =
texture {
  pigment {
    color rgbt <0,0,0,1>
  }
  finish {
    ambient 0.0
    diffuse 0.0
  }
}

sphere {
  <0,0,0>,1
  texture {T_sky}
  interior_texture {T_cosmos}
  no_shadow
  no_reflection
  inverse
  scale 99.9*10e4
}

Working with windows version of POV-Ray and Win7 x64

Is this normal for version 3.7 RC5? I seem to remember that with lower
versions of POV-Ray on could go at least to 10e6. Especially with the
Ringworld scenes back in 2010 the scales used where much larger without
any black out.

I can indeed confirm that the Ringworld scene does not render correctly anymore, with identical black out.

252PhotonsDefinite Bug3.70 RC6Very LowLowphotons and light_group is brokenTracked on GitHub
0%
Task Description

photons are not working when used with a light_group. verified in NG posting in p.general a simple scene file is attached.

256Texture/Material/FinishFeature Request3.70 RC6Very LowLowCSG texturing modesTracked on GitHub
0%
Task Description

At times, the current method of specifying texture for
CSG components and compounds is restricting. The issue
pops up now and then, see e.g.

http://news.povray.org/povray.pov4.discussion.general/thread/%3Cweb.4799def8e1857b77c150d4c10%40news.povray.org%3E/

http://news.povray.org/povray.general/thread/%3Cweb.4fc892634f065c00e32b83540@news.povray.org%3E/

http://news.povray.org/povray.general/thread/%3Cweb.5073e9f7dae1fbb2d97ee2b90%40news.povray.org%3E/

There should be a new CSG option “texture_mode” or similar, which could take
one of the following values:

preserve (the current behavior)
cutaway (the current behavior when specifying cutaway_textures)
override (replace all individual textures with compound texture)
layer (layer the compound texture over the existing textures)

and possibly, more involved

modify/merge: if both element and compund textures are simple, i.e.
not layered or mapped, override all default values of the element
textures with the values from the compound texture. The idea would
be to, e.g., have the elements already pigmented but then apply
common normal or finish properties.

263Parser/SDLFeature Request3.70 RC6Very LowLowFunctions and patterns for finish variationsTracked on GitHub
0%
Task Description

the pigment {} and normals {} sections allow spatial variation of color, transparency and normal map. On the other hand, the specular parameter is a fixed scalar. This removes many possibilities. For instance, specularity could vary in space (speckles of oil or water on a surface, worn-out finish, having specularity reduce where the pigment transparency increases) and have color components. With current settings, the light’s color is simply multiplied by the scalar specified by “specular”, whereas multiplying each component with different color could create diverse effects (the “metallic” keyword already acts similar to duplicating the specular color from the pigment). The syntax could be exactly the same as for the pigment (all the patterns, color maps, image maps and functions would apply, allowing reuse of most of the code).

The effect can now be partially faked by having patterned textures, but it requires a very complex code and the lack of layering of patterned textures makes it difficult to vary the specularity and pigment separately.

In a similar way, roughness and brilliance could also vary in space.

Doing the same for varying reflectivity would be more difficult, as it has angular dependence and possibilty of Fresnel calculation, but it could at least be a full color instead of a simple scalar multiplier. For instance, having a blue surface that reflects only red component of the light should not be impossible.

I think at least part of this functionality actually makes the scene description language more uniform and self-consistent.

264PhotonsUnimp. Feature/TODO3.70 RC6DeferLowImprove precision of photon direction informationTracked on GitHub
0%
Task Description

In the photons map, the direction of each photon is stored as separate latitude & longitude angles (encoded in one byte each), causing the longitudinal direction component’s precision to be unnecessarily high for directions close to the “poles” (Y axis); in addition, encoded value -128 is never used. For better overall precision as well as precision homogenity, the following scheme could be used instead:

  • Encode the latitude (-pi/2 to +pi/2) into LatCount=226 distinct values (= 256*sqrt(pi)/2) rounded to the next even number) from 0 to LatCount-1 using
latCode = (int)((LatCount-1) * (lat/M_PI + 0.5) + 0.5)
  • For each latitude code, define a specific number of encodable longitude values, LngCount[latCode] = approx. cos(lat)*pi*65536/(2*LatCount); this can be a pre-computed table, and may need slight tweaking for optimum use of the code space. Encode the longitude (-pi to +pi) into a value from 0 to (LngCount[lat]-1) using
LC = LngCount[latCode];
lngCode = (int)(LC * (lng/(2*M_PI) + 0.5) + 0.5) % LC;
  • Besides LngCount[latCode], also store the sum of LngCount[i] with i < latCode as LatBase[latCode]; encode the direction as
dirCode = LatBase[latCode] + lngCode;
  • For decoding, a simple lookup from a precomputed list of directions could be used (2^15 entries, i.e. one hemisphere, will suffice). To conserve space, direction vectors could be scaled by (2^N-1) and stored as (N+1)-bit signed integer triples rather than floating point values; due to the limited precision of the lat/long information, 8 bits per coordinate might be enough, giving a table size of 96k. A full double-precision table would require 786k instead.
269Texture/Material/FinishPossible Bug3.70 RC6Very LowLowTransparent Objects inside Media Cause ArtefactsTracked on GitHub
0%
Task Description

When placing a transparent object inside another object which contains media, artefacts may occur (see attached file). They look similar to specular highlights or are just strange white spots in the image.

I discovered artefacts of that kind first in the image of which MediaArtefactDetail.png is a cropped part. The code I managed to reproduce such artefacts with contained a “starfield” sphere

sphere {
  <0,0,0>, 1
  
  pigment { rgbt 1 }
  
  interior {
    media {
      emission rgb 1/10
      density {
        crackle form <1,0,0>
        density_map {
          [0.0 rgb 1]
          [0.05 rgb 0]
        }
        scale 0.002
      }
    }
  }
  
  scale 1000
  
  hollow on
}

and a transparent sphere

sphere {
  <0,0,0>, 1
  
  pigment { rgbt 1 }
  
  scale 2
  
  hollow on
}

which is, obviously, completely inside the other sphere. So is the camera.

Since the sphere has a pigment { rgbt 1 }, it should be completely invisible, which is correctly rendered as long as the scaling factor is 1 and hollow off (MediaArtefact1.png). Changing hollow to on does not yet produce the artefact, but the right half of the output image seems to be shifted by one pixel (MediaArtefact2.png). Changing the scaling factor to 2 (as it is in the above code) produces the artefact (MediaArtefact3.png). Changing the camera location (MediaArtefact4.png) does not change anything, the artefact just “moves with the sphere”. Changing the sphere size again, however, seems to stir up the “stars” in the “starfield” sphere while not removing the artefacts (MediaArtefact5.png). Changing hollow to off again does neither (MediaArtefact6.png).

The artefacts are definitely no specular highlights. There is not even a light source in the scene that could produce any. I used POV-Ray 3.7 RC6 to render the images, but the artefact shown in MediaArtefactDetail.png already occured in POV-Ray 3.6 which I used to render that image.

273OtherDefinite Bug3.70 RC6Very LowMediumNo automatic backup files from inc filesTracked on GitHub
0%
Task Description

If enabled, POVray always created backups of pov and inc files once per session.
Now using 3.7 RC6 only pov file backups are created but not from inc files.

278BackendFeature Request3.70 RC7Very LowMediumImplement Lens Flare RenderingTracked on GitHub
0%
Task Description

Currently POV-Ray does not support rendering lens flare effects, however, they can be simulated using a macro (include file) by Chris Colefax.

I would like to suggest adding a feature to POV-Ray to support lens effects “natively” since

  • as far as I know the macro has been designed for POV-Ray 3.1 so with each new POV-Ray version it gets more likely that this macro does not work properly any more
  • the macro does not work when rendering with radiosity, probably because the macro creates the lens effect by using a pigment with a high ambient value (which is ignored by POV-Ray 3.7’s radiosity algorithm).

Additionally, the macro is not quite easy to employ because

  • it needs to know the exact camera parameters (location etc.) and defines an own camera itself so any important camera information has to be stored if the effect has to work as expected
  • it does not (actually cannot) take into account that objects may (partially) hide the lens effect
  • reflections and refractions (of light sources) cannot be combined with it properly - the user would have to calculate both the point where the reflected/refracted light source can be observed and the shape it then has due to distortion, and in more complex scenes such computations are nearly impossible in SDL.

I would suggest integrating such a lens flare rendering feature with the “looks like” mechanism you already have for light sources. Several parameters that can currently be set for the macro - including effect brightness and intensity, lens options and whether to create a flare at all - could be set for the light source.

Then POV-Ray could store the location and colour of each ray that finally intersected the “looks like” object of a light source and, having finished the main rendering, from that data compute a partially transparent “lens flare layer” eventually mixed into the rendered image. By this, the above mentioned problems could be avoided:

  • an object fully or partially intersecting a light source’s “looks like” object would also reduce the number of pixels used to create a flare - and therefore reduce that flare until fully hiding it
  • the same goes for reflected and/or refracted versions of the “looks like” object
  • the camera’s location and other properties would be used automatically
  • and finally, as a feature supported by POV-Ray itself, there would be neither compatibility issues nor problems like the effect not fitting together with radiosity.

Do not get me wrong, I would not expect POV-Ray to really calculate intersections that naturally happen in a camera lens, causing lens flares. Effects looking appropriate can actually be created just in 2D space (as some graphics programs do support) so the work to be done would, as far as I have any overview, be:

  • storing, as mentioned above, the relevant data for pixels showing “looks like” objects
  • calculating a lens flare from that data after the render has finished
  • overlaying the rendered image with the newly created lens effect.
286Texture/Material/FinishPossible Bug3.70 RC7Very LowLowreflection exponent other than 1 causes black artifacts...Tracked on GitHub
0%
Task Description

[EDIT: Original title was “radiosity causing black patches when using emission less than 0”]

see attached image for reference.

mountain on left has emission set to -.13 and black patches show up, when emmission set to 0 or greater no patches

changing max_trace or any radiosity settings has no effect

setting no_radiosity on mountain fixed problem as a temp fix

code sample ...

#version 3.7;

#default { finish { ambient 0 } }
#declare rad_lvl = 4;

global_settings {
  assumed_gamma 1
  max_trace_level max(5,rad_lvl*3)
  adc_bailout .007
  ambient_light 0
  radiosity {
   pretrace_start 64/max(image_width,image_height)
   #if(rad_lvl)
    pretrace_end max(2,int(8/rad_lvl))/max(image_width,image_height)
   #else
    pretrace_end 32/max(image_width,image_height)
   #end
   count pow(rad_lvl+1,2)*10
   nearest_count 1
   #if(rad_lvl) error_bound 1/rad_lvl #end
   low_error_factor max(.4,(8-rad_lvl)/10)
   recursion_limit 1
   gray_threshold .25
   brightness 1
   max_sample 1
   normal on
   media off
   always_sample off
   minimum_reuse min(.008,8/max(image_width,image_height))
   maximum_reuse .1
   adc_bailout .02
  }
}

#declare sunC = rgb <1, 1, .9925>; // actual D65 standard illuminant
#declare SkyC = rgb <.3195, .5745, .8805>;
#macro GammaAdj(C,G) rgb <pow(C.red,G),pow(C.green,G),pow(C.blue,G)> #end

light_source {
  50000*y
  sunC*1.06
  area_light <-300, 0, -300>, <300, 100, 300>, 3, 3
  rotate <-28, 0, 14>
  adaptive 0
  circular
}

 sphere { 0, 1
  texture {
   pigment{
    gradient y
    pigment_map{
     [.07 GammaAdj(SkyC,.5)]
     [.2 average pigment_map { [.5 GammaAdj(SkyC,.75)][1 wrinkles turbulence .65 octaves 5 lambda 3 omega .9 color_map { [.2 rgb 1][.5 SkyC] } scale <10, .1, 1>] }]
     [.4 GammaAdj(SkyC,1.15)]
     [.5 GammaAdj(SkyC,1.35)]
    }
    rotate -75*y scale <1, 1, 100>
   }
   finish { diffuse .72 }
  }
  scale 100000
  inverse
 }


#declare Cam_pos = Cam_pos + <0, 20, -40>;
#declare Cam_lkt = Cam_lkt + <0, 10, 50>;
camera {
  location Cam_pos
  direction <0,0,1>
  right 1.33*x
  up y
  sky <0,1,0>
  #if(Cam_agl) angle Cam_agl #end
  look_at Cam_lkt
}

#macro sinai(HillQ)
 #local F = function { pattern { granite poly_wave 4 turbulence .01 lambda 2.1 omega .9 scale 5 translate <.2, 0, 18.08> scale <2, 1, 3> } }
 #local N = function { pigment { crackle ramp_wave turbulence .3 lambda 2.2 omega .76 color_map {[0 rgb 0][1 rgb 1] } scale .07 translate <-.15, -.12, .13> } }
 height_field {
  function HillQ, HillQ { F(x,y,z) + N(x,y,z).grey/47 }
  water_level .05
  clipped_by { box { <0, .05, .3>, <1, 1, 1> } }
  translate <-.5, -.05, -.5>
  rotate 20*y
  texture {
   pigment{ crackle color_map { [0 rgb <161, 107, 71>/255][.25 rgb <193, 132, 93>/255][.35 rgb <218, 163, 123>/255][.45 rgb <212, 153, 112>/255][.55 rgb <222, 166, 125>/255][.65 rgb <236, 178, 124>/255][.75 rgb <220, 154, 102>/255][.85 rgb <160, 121, 103>/255] } turbulence .75 lambda 3 omega .7 scale .1 }
   finish{ diffuse albedo .56 emission -.13 specular .25 roughness .02 brilliance 1.5 metallic 1.3 }
   normal { crackle poly_wave .7 turbulence .4 omega .8 scale <.007, .03, .007> }
  }
  rotate 12*y
  scale <2400, 2000, 3000>*1.5
  translate <1900, 0, 1900>
  scale <-1,1,1>
  no_radiosity
 }
#end


sinai(1600)
plane { y,0 pigment { rgb <1, 1, 1> } }

//courtyard gating not included due to size of code and many external files needed. add anything around <0,0,0> to try to reproduce effect of error
288Geometric PrimitivesPossible Bug3.70 RC7Very LowLowTolerance problem with refraction in blobs in CSG inter...Tracked on GitHub
0%
Task Description

If a blob is intersected by something else, the composite object has incorrect refractions if it is too small (in absolute units). Having the same object constructed without a blob, the errors happen at much smaller scales. The errors don’t affect solid objects, just refractions.

An example shows a half-sphere, constructed as CSG sphere + plane, and identical half-pshere, constructed as CSG blob + plane. When the scale of the entire construction is changed, the refractions disappear first for the blob, and at 100x times smaller scale, also for the sphere. The right side shows the solid version, showing that the surface intersection test is ok, it’s just the refraction that fails.

The problem is not present when looking from the curved side (the blob side). So the ray that hits the blob, gets refracted correctly, but the ray that hits the intersecting plane first, and should then refract in the blob from the inside, doesn’t work. If in attached sphere, you exchange -y with y in clipping planes, everything is ok.

The scale when this happens is not very small - blobs of radius 0.02 already fail (noticed because in 1=1metre scale, blob raindrops on a glass plate didn’t have intersections when looking from the back).

Examples are named by factor=9,0.9,0.09,0.009 and you can see first the blob (top) refraction gets smaller and disappears, then later the bottom (sphere) also gets the same problem.

289Light sourcePossible Bug3.70 RC7Very LowLowarea_illumination with light fading and scattering medi...Tracked on GitHub
0%
Task Description

with reference to http://bugs.povray.org/task/46

still some issue with area illumination and light fading when interacting with media

seems light fade is not taken into account with scattering media.
emission and absorption media seem to work fine.
occurs with all scattering types.

#version 3.7;

global_settings {
 ambient_light 0
 assumed_gamma 1
}

camera {
  location <0, 3, -5>
  look_at <0, 2, 0>
}


#declare Light = 3; // light 1 = individual lights
                   // light 2 = standard area light
                   // light 3 = area light with area illumination

#declare Fade = 1; // light fading: 1 on, 0 off

#declare Media = 1; // media 1 = scattering
                    // media 2 = emission
                    // media 3 = absorption

#declare Type = 1; // scattering media type


#switch(Light)
 #case(1)

  #declare Ls = light_source {
    0
    1/7
    #if(Fade) fade_distance 2 fade_power 2 #end
  }

  union {
   object { Ls }
   object { Ls translate .5*x }
   object { Ls translate x }
   object { Ls translate 1.5*x }
   object { Ls translate -.5*x }
   object { Ls translate -x }
   object { Ls translate -1.5*x }
   translate y
  }

 #break
 #case(2)

  light_source{
    y
    1
    area_light 3*x, z, 7, 1
    #if(Fade) fade_distance 2 fade_power 2 #end
  }

 #break
 #case(3)

  light_source{
    y
    1
    area_light 3*x, z, 7, 1
    #if(Fade) fade_distance 2 fade_power 2 #end
    area_illumination on
  }

 #break

#end


cylinder { <0, .01, 0>, <0, 5, 0>, 2 pigment { rgbt 1 } hollow no_shadow
 interior {
  media {
   #if(Media = 1) scattering {Type, 30 } #end
   #if(Media = 2) emission 2 #end
   #if(Media = 3) absorption 2 #end
    density { cylindrical turbulence 1.5 scale <1, .14, 1> }
  }
 }
 scale <.15, 1, .4> translate 4*z
}

plane { y,0 pigment { rgb .7 } }
plane { -z,-7 pigment { gradient y color_map { [.5 rgb 1][.5 rgb 0] } } }
union {
 sphere { 0,.05 }
 sphere { .5*x,.05 }
 sphere { x,.05 }
 sphere { 1.5*x,.05 }
 sphere { -.5*x,.05 }
 sphere { -x,.05 }
 sphere { -1.5*x,.05 }
 translate y
  hollow pigment { rgbt 1 } interior { media { emission 10 } }
}
Showing tasks 1 - 50 of 103 Page 1 of 31 - 2 - 3 -

Available keyboard shortcuts

Tasklist

Task Details

Task Editing