Am 05.03.2021 um 16:54 schrieb Cousin Ricky:
> Does anyone know whether it is possible for a scene file to detect 
> whether or not it is being rendered by UberPOV, without bombing out if 
> it is rendered by official POV-Ray?
> 
> Why would I need to do this?  Because I'm writing a macro that needs to 
> know whether or not true inverse square light attenuation is available. 
> For official POV-Ray, this is version >= 3.8, but for UberPOV, it is 
> version >= 3.71.
> 
> My first (and so far only) idea was to start with a test for the 
> existence of the variable 'unofficial', but it turns out POV-Ray 3.8 
> does the same test--but treats it as if it were a keyword.  This screws 
> up the test for any SDL code running under 3.8.


Some background information:

The problem arises with recent development versions of POV-Ray that (1) 
recognize `unofficial` as a proper keyword (as in `#version unofficial 
FOO`, which official POV-Ray has been supporting for ages in the sense 
that it prompts a very specific error message), and (2) report all 
recognized keywords as "defined" with respect to the `#ifdef` statement 
and its kin.

In v3.7 and early development versions identifying as v3.7.1, the 
statement had been handled in a comparatively hackish manner, which did 
not recognize `unofficial` as a proper keyword. Therefore, those 
versions are unproblematic.

In later v3.7.1 development versions, starting with 
v3.7.1-alpha.8449793, `unofficial` was promoted to a keyword proper. 
However, `#ifdef` and its kin still reported keywords as "not defined", 
so those versions are also unproblematic.

The problem was only introduced with the experimental 
v3.8.0-tokenizer.9841908, and later with the mainline 
v3.8.0-alpha.10008988, which changed the behaviour of `#ifdef` to report 
keywords as "defined", including the `unofficial` keyword.

Note however that the change of the `#ifdef` statement also means that 
support for the `patch` keyword can be tested directly, in a manner that 
is also compatible with older versions. Also, whether or not `#ifdef` 
works this way can be tested with a known keyword.


The following code will cause parse warnings with some versions, but 
other than that it should work fine for any version:

---------------------------------------------------------------
// Tell POV-Ray that we'll be doing our own feature probing.
#version version;

// Test whether UberPOV-style `#patch`/`patch()` mechanism
// seems to be available
#ifdef(ifdef)
   // New `#ifdef` behaviour, reporting supported keywords as defined.
   // We can probe for support of the `patch` keyword directly.
   #declare HAVE_PATCH = defined(patch);
#else
   // Old `#ifdef` behaviour, reporting keywords as undefined.
   // We can probe for support of the `unofficial` variable.
   #ifdef(unofficial)
     #declare HAVE_PATCH = (unofficial = "patch");
   #else
     #declare HAVE_PATCH = false;
   #end
#end

// Probe for required features
#if(HAVE_PATCH)
   // Probe features individually via `#patch`/`patch()`
   // (or probe for UberPOV version via that same mechanism
   // using "upov" as the feature name, though this is somewhat
   // discouraged)
   ...
#else
   // Probe via `#version`/`version´
   ...
#end
---------------------------------------------------------------


Note that support for the `patch` keyword per se does _not_ necessarily 
imply that the version used is actually UberPOV. Most notably, the 
details of the mechanism were specifically designed such that other 
derivatives of POV-Ray could use the same mechanism without conflict, 
and official POV-Ray might also eventually support it, if only to 
further promote it as a standard mechanism for detecting derivatives and 
probing for their features.

Post a reply to this message