Merge branch 'release/v3.8.0' into autobuild/alpha_v380

Author: c-lipka

changes.txt

@@ -50,6 +50,11 @@ Changed Behaviour
   - Any new behaviour formerly activated by `#version 3.71` now requires
     `#version 3.8` (or higher); specifying `#version 3.71` will trigger a
     corresponding warning.
+  - Some defaults have been changed (requires `#version 3.8` as the _very first_
+    statement of the scene, or a corresponding command line / INI setting):
+      - `ambient` now defaults to 0.0 instead of 0.1.
+      - Camera `right` vector length now defaults to the output image aspect
+        ratio (presuming square pixels) instead of 1.33.
 
 Other Noteworthy
 ----------------

source/backend/control/scene.cpp

@@ -99,6 +99,10 @@ void Scene::StartParser(POVMS_Object& parseOptions)
     sceneData->inputFile = parseOptions.TryGetUCS2String(kPOVAttrib_InputFile, "object.pov");
     sceneData->headerFile = parseOptions.TryGetUCS2String(kPOVAttrib_IncludeHeader, "");
 
+    DBL outputWidth  = parseOptions.TryGetFloat(kPOVAttrib_Width, 160);
+    DBL outputHeight = parseOptions.TryGetFloat(kPOVAttrib_Height, 120);
+    sceneData->aspectRatio = outputWidth / outputHeight;
+
     sceneData->defaultFileType = parseOptions.TryGetInt(kPOVAttrib_OutputFileType, DEFAULT_OUTPUT_FORMAT); // TODO - should get DEFAULT_OUTPUT_FORMAT from the front-end
     sceneData->clocklessAnimation = parseOptions.TryGetBool(kPOVAttrib_ClocklessAnimation, false); // TODO - experimental code
 

source/core/material/texture.cpp

@@ -212,6 +212,10 @@ void Transform_Textures(TEXTURE *Textures, const TRANSFORM *Trans)
 *   6/27/98  MBP  Added initializers for reflection blur
 *   8/27/98  MBP  Added initializers for angle-based reflectivity
 *
+* NOTES
+*   since v3.8, the default ambient will be be overriden to 0.0 when the first statement
+*   is a #version with value 3.8 or greater or when such version is set explicitly in command line or ini file
+*
 ******************************************************************************/
 
 FINISH *Create_Finish()

source/core/scene/scenedata.h

@@ -70,7 +70,7 @@ struct Skysphere_Struct;
 /// This class just provides access to scene specific data
 /// needed in many parts of the code. Be aware that while most
 /// data is members are public, they shall **not** be modified
-/// carelessly. Code from POV-Ray 3.6 and earlier does depend
+/// carelessly. Code from POV-Ray v3.6 and earlier does depend
 /// on simple access of this data all over the old code, so
 /// this provides an efficient way to reuse all the old code.
 /// By no means shall this way of data access be used for any
@@ -166,7 +166,7 @@ class SceneData
         bool realTimeRaytracing;
 
         // ********************************************************************************
-        // Old globals from 3.6 and earlier are temporarily kept below. Please carefully
+        // Old globals from v3.6 and earlier are temporarily kept below. Please carefully
         // consider what is added and mark it accordingly if it needs to go away again
         // prior to final release! [trf]
         // ********************************************************************************
@@ -196,6 +196,9 @@ class SceneData
         UCS2String inputFile; // TODO - handle differently
         UCS2String headerFile;
 
+        /// Aspect ratio of the output image.
+        DBL aspectRatio;
+
         int defaultFileType;
 
         FrameSettings frameSettings; // TODO - move ???
@@ -227,13 +230,13 @@ class SceneData
 
         /// Convenience function to determine the effective SDL version.
         ///
-        /// Given that version 3.7 and later require the first statement in the file to be
+        /// Given that version v3.7 and later require the first statement in the file to be
         /// a `#version` statement, the absence of such a statement can be presumed to
-        /// indicate a pre-3.7 scene; this function assumes version 3.62 in that case
-        /// (which was the latest 3.6 version when 3.7.0 was released).
+        /// indicate a pre-v3.7 scene; this function assumes v3.6.2 in that case
+        /// (which was the latest version before v3.7.0).
         /// @note       It is recommended to use this function only where behaviour differs
-        ///             significantly from pre-3.7 versions.
-        /// @return     The current language version in integer format (e.g. 370 for 3.70)
+        ///             significantly from pre-v3.7 versions.
+        /// @return     The current language version in integer format (e.g. 370 for v3.7.0)
         ///             if explicitly specified, or 362 otherwise.
         ///
         inline unsigned int EffectiveLanguageVersion() const

source/core/shape/ovus.cpp

@@ -45,16 +45,18 @@
 *
 *  ovus
 *  {
-*     bottom_radius,top_radius
+*     bottom_radius,top_radius [distance d] [radius r] [precision p]   [sturm]
 *  }
 *
 *  The so long awaited 'Egg' forms.
 *
 *  Normally, the bottom_radius is bigger than the top_radius
-*  the center of the top sphere is at the zenith of the bottom sphere
+*  the center of the top sphere is at the zenith of the bottom sphere, unless
+*    a greater distance d is specified with "distance"
 *  and the bottom sphere is centered at 0.0
 *  The radius of the connecting surface is the double of the biggest radius
 *   (yes, the biggest diameter is used as the curvature of the connection)
+*   unless overriden with "radius"
 *
 *  The hard part was just to find where the connection starts and ends.
 *
@@ -82,13 +84,6 @@ namespace pov
 * Local preprocessor defines
 ******************************************************************************/
 
-// Minimal depth for a valid intersection.
-// TODO FIXME - can we use EPSILON or a similar more generic constant instead?
-const DBL DEPTH_TOLERANCE = 1.0e-4;
-
-// Tolerance used for order reduction during root finding.
-// TODO FIXME - can we use EPSILON or a similar more generic constant instead?
-const DBL ROOT_TOLERANCE = 1.0e-4;
 
 
 
@@ -110,6 +105,7 @@ void Ovus::Intersect_Ovus_Spheres(const Vector3d& P, const Vector3d& D,
     *Depth1 = *Depth2 = *Depth3 = *Depth4 = *Depth5 = *Depth6 = -100; // TODO FIXME - magic value
     // no hit unless...
 
+    // compute intersection with bottom sphere
     Padj = -P;
     Rad1 = Sqr(BottomRadius);
     Rad2 = Sqr(TopRadius);
@@ -140,8 +136,10 @@ void Ovus::Intersect_Ovus_Spheres(const Vector3d& P, const Vector3d& D,
             }
         }
     }
+    // shape can only have a maximum of 2 intersections, if we have them already, return
     if (lcount > 1) return;
-    Second_Center = Vector3d(0, BottomRadius, 0);
+    // compute intersection with top sphere
+    Second_Center = Vector3d(0, VerticalSpherePosition, 0);
     Padj = Second_Center - P;
 
     OCSquared = Padj.lengthSqr();
@@ -172,7 +170,9 @@ void Ovus::Intersect_Ovus_Spheres(const Vector3d& P, const Vector3d& D,
 
         }
     }
+    // shape can only have a maximum of 2 intersections, if we have them already, return
     if (lcount > 1) return;
+    // need to evaluate the spindle of the torus, because intersions are not yet all found
     Second_Center = Vector3d(0, VerticalPosition, 0);
     Padj = P - Second_Center;
     R2 = Sqr(HorizontalPosition);
@@ -196,7 +196,7 @@ void Ovus::Intersect_Ovus_Spheres(const Vector3d& P, const Vector3d& D,
 
     c[4] = k1 * k1 + 4.0 * R2 * (Py2 - r2);
 
-    n = Solve_Polynomial(4, c, r, Test_Flag(this, STURM_FLAG), ROOT_TOLERANCE, Thread->Stats());
+    n = Solve_Polynomial(4, c, r, Test_Flag(this, STURM_FLAG), RootTolerance, Thread->Stats());
     while (n--)
     {
         // here we only keep the 'lemon' inside the torus
@@ -213,7 +213,7 @@ void Ovus::Intersect_Ovus_Spheres(const Vector3d& P, const Vector3d& D,
         {
             horizontal = sqrt(Sqr(IPoint[X]) + Sqr(IPoint[Z]));
             OCSquared = Sqr((horizontal + HorizontalPosition)) + Sqr((vertical - VerticalPosition));
-            if (fabs(OCSquared - Sqr(ConnectingRadius)) < ROOT_TOLERANCE)
+            if (fabs(OCSquared - Sqr(ConnectingRadius)) < RootTolerance)
             {
                 if (*Depth5 < 0)
                 {
@@ -322,7 +322,7 @@ bool Ovus::All_Intersections(const Ray& ray, IStack& Depth_Stack, TraceThreadDat
             if (Clip.empty()||(Point_In_Clip(Real_Pt, Clip, Thread)))
             {
                 INormal = IPoint;
-                INormal[Y] -= BottomRadius;
+                INormal[Y] -= VerticalSpherePosition;
                 INormal /= TopRadius;
                 MTransNormal(Real_Normal, INormal, Trans);
                 Real_Normal.normalize();
@@ -341,7 +341,7 @@ bool Ovus::All_Intersections(const Ray& ray, IStack& Depth_Stack, TraceThreadDat
             if (Clip.empty()||(Point_In_Clip(Real_Pt, Clip, Thread)))
             {
                 INormal = IPoint;
-                INormal[Y] -= BottomRadius;
+                INormal[Y] -= VerticalSpherePosition;
                 INormal /= TopRadius;
                 MTransNormal(Real_Normal, INormal, Trans);
                 Real_Normal.normalize();
@@ -435,7 +435,7 @@ bool Ovus::Inside(const Vector3d& IPoint, TraceThreadData *Thread) const
     DBL horizontal, vertical;
     bool INSide = false;
     Vector3d Origin, New_Point, Other;
-    Origin = Vector3d(0, BottomRadius, 0);
+    Origin = Vector3d(0, VerticalSpherePosition, 0);
     MInvTransPoint(New_Point, IPoint, Trans);
     OCSquared = New_Point.lengthSqr();
     if (OCSquared < Sqr(BottomRadius))
@@ -698,6 +698,8 @@ Ovus::Ovus() : ObjectBase(OVUS_OBJECT)
     BottomVertical = 0.0;
     TopVertical = 0.0;
     ConnectingRadius = 0.0;
+    VerticalSpherePosition = 0.0;
+    RootTolerance = 1.0e-4;
 }
 
 
@@ -774,7 +776,8 @@ ObjectPtr Ovus::Copy()
 ******************************************************************************/
 
 Ovus::~Ovus()
-{}
+{
+}
 
 
 
@@ -811,7 +814,11 @@ void Ovus::Compute_BBox()
 {
     // Compute the biggest vertical cylinder radius
     DBL biggest;
+    DBL bottom;
+    DBL length;
     biggest = ConnectingRadius - HorizontalPosition;
+    bottom = -BottomRadius;
+    length = BottomRadius + VerticalSpherePosition + TopRadius;
     if (biggest < BottomRadius)
     {
         biggest = BottomRadius;
@@ -820,9 +827,17 @@ void Ovus::Compute_BBox()
     {
         biggest = TopRadius;
     }
+    // handle degenerated ovus in sphere
+    // negative value have been intercepted by Parser::Parse_Ovus
+    // and the 0.0 is only possible for detected degenerated ovus in that function
+    if (BottomRadius == 0.0)
+    {
+        bottom = VerticalSpherePosition-TopRadius;
+        length = 2*TopRadius;
+    }
 
-    Make_BBox(BBox, -biggest, -BottomRadius, -biggest,
-              2.0 * biggest, 2.0 * BottomRadius + TopRadius, 2.0 * biggest);
+    Make_BBox(BBox, -biggest, bottom, -biggest,
+              2.0 * biggest, length, 2.0 * biggest);
 
     Recompute_BBox(&BBox, Trans);
 }
@@ -883,46 +898,64 @@ void Ovus::UVCoord(Vector2d& Result, const Intersection *Inter, TraceThreadData
 *
 * CHANGES
 *
+* due to the addition of distance, the mapping is changed to something similar
+* to lemon, cone & cylinder
+*
 ******************************************************************************/
 
 void Ovus::CalcUV(const Vector3d& IPoint, Vector2d& Result) const
 {
-    DBL len, x, y, z;
+    DBL len, x, z, t;
     DBL phi, theta;
     Vector3d P;
 
-    // Transform the ray into the ovus space.
+    // Transform the point back into the ovus space.
     MInvTransPoint(P, IPoint, Trans);
 
-    // the center of UV coordinate is the bottom center when top radius ->0
-    // and it is the top center when top radius -> 2.0* bottom radius
-    // when top radius == bottom radius, it is half-way between both center
-    //
-    // bottom center is <0,0,0>
-    // top center is <0,BottomRadius,0>
-    // TODO FIXME - comment doesn't seem to match the following code
+    // the center of UV coordinate is the <0,0> point
     x = P[X];
-//  y = P[Y] - BottomRadius*(TopRadius/(2.0*BottomRadius));
-    y = P[Y] - (TopRadius/2.0);
     z = P[Z];
 
-    // now assume it's just a sphere, for UV mapping/projection
-    len = sqrt(x * x + y * y + z * z);
+    // Determine its angle from the point (0, 0, 0) in the x-z plane.
+    len = x * x + z * z;
 
-    if (len == 0.0)
-        return;
+    if ( (P[Y] > EPSILON) && (P[Y] < (VerticalSpherePosition - EPSILON) ) )
+    {
+    // when on the spindle, the range 0.25 to 0.75 is used 
+    // Verbatim from C-Lipka:
+    // Dividing at 1/4 and 3/4 has the advantage of the division being exactly at a pixel boundary
+    // if the texture is an image 2^N by 2^M pixels in size, which is common for image textures
+    // originally designed for mesh-based renderers. It also happens to work for 20N by 20M pixels, 
+    // which is common for image textures with "arbitrary" sizes.
+        phi = 0.75-0.5*(P[Y])/(VerticalSpherePosition);
+    }
+    else if (P[Y]>EPSILON)
+    {
+        // aka P[Y] is above VerticalSpherePositon, use TopRadius, from 0% to 25%
+        phi = 0.0;
+        if (TopRadius != 0.0)
+        {
+            t = ((P[Y]-VerticalSpherePosition)/(TopRadius));
+            phi = (sin(sqrt(1-t)*M_PI_2)/(4.0));
+        }
+    }
     else
     {
-        x /= len;
-        y /= len;
-        z /= len;
+        // aka P[Y] is below origin (<0), use BottomRadius, from 75% to 100%
+        phi = 1.0;
+        if (BottomRadius != 0.0)
+        {
+            t = ((BottomRadius+P[Y])/(BottomRadius));
+            phi = 1.0-sin(sqrt(t)*M_PI_2)/(4.0);
+        }
+        else if (TopRadius != 0.0) // per Parser::Parse_Ovus, TopRadius & BottomRadius cannot be both 0.0 at the same time, but keep the test due to division
+        {
+            // degenerate ovus in sphere
+            t = ((TopRadius-VerticalSpherePosition+P[Y])/(TopRadius));
+            phi = 1.0-sin(sqrt(t)*M_PI_2)/(4.0);
+        }
     }
 
-    // Determine its angle from the x-z plane.
-    phi = 0.5 + asin(y) / M_PI; // This will be from 0 to 1
-
-    // Determine its angle from the point (1, 0, 0) in the x-z plane.
-    len = x * x + z * z;
 
     if (len > EPSILON)
     {

source/core/shape/ovus.h

@@ -96,8 +96,12 @@ class Ovus : public ObjectBase
         DBL BottomVertical;
         /// highest vertical for the connecting surface (computed)
         DBL TopVertical;
-        /// Radius of the connecting surface (computed)
+        /// Radius of the connecting surface (computed, or provided in SDL)
         DBL ConnectingRadius;
+        /// vertical position of center of top sphere (computed or provided in SDL)
+        DBL VerticalSpherePosition;
+        /// precision for root solver
+        DBL RootTolerance;
 
     private:
         void CalcUV(const Vector3d& IPoint, Vector2d& Result) const;