| POV-Ray for Unix version 3.7.1 | ||||
|
|
||||
| Home | POV-Ray for Unix | POV-Ray Tutorial | POV-Ray Reference | |
This section covers the include files that come with every distribution of POV-Ray. File location varies, so see your platform specific documentation for more information.
The main include files in alphabetical order:
This file contains macros for manipulating arrays.
ARRAYS_WriteDF3(Array, FileName, BitDepth): Write an array to a df3 file.
Parameters:
Array = The array that contains the data.FileName = The name of the file to be written.BitDepth = The size of the binary word.Note: See the #write directive for more information.
Rand_Array_Item(Array, Stream): Randomly Picks an item from a 1D array.
Parameters:
Array = The array from which to choose the item.Stream = A random number stream.Resize_Array(Array, NewSize): Resize a 1D array, retaining its contents.
Parameters:
Array = The array to be resized.NewSize = The desired new size of the array.Reverse_Array(Array): Reverses the order of items in a 1D array.
Parameters:
Array = The array to be reversed.Sort_Compare(Array, IdxA, IdxB): This macro is used by the Sort_Array()
and Sort_Partial_Array() macros. The given macro works for 1D arrays of floats, but
you can redefine it in your scene file for more complex situations, arrays of vectors or
multidimensional arrays for example. Just make sure your macro returns true if the item at IdxA <
the item at IdxB, and otherwise returns false.
Parameters:
Array = The array containing the data being sorted.IdxA, IdxB = The array offsets of the data elements being compared.Sort_Swap_Data(Array, IdxA, IdxB): This macro is used by the Sort_Array()
and Sort_Partial_Array() macros. The given macro works for 1D arrays only,
but you can redefine it in your scene file to handle multidimensional arrays if needed.
The only requirement is that your macro swaps the data at IdxA with that at IdxB.
Parameters:
Array = The array containing the data being sorted.IdxA, IdxB = The array offsets of the data elements being swapped.Sort_Array(Array): This macro sorts a 1D array of floats, though you can
redefine the Sort_Compare() and Sort_Swap_Data() macros to
handle multidimensional arrays and other data types.
Parameters:
Array = The array to be sorted.Sort_Partial_Array(Array, FirstInd, LastInd): This macro is like
Sort_Array(), but sorts a specific range of an array instead of the whole array.
Parameters:
Array = The array to be sorted.FirstInd, LastInd = The start and end indices of the range being sorted.This file includes 26 upper-case letter and other characters defined as objects. The size of all characters is 4 * 5 * 1. The center of the bottom side of a character face is set to the origin, so you may need to translate a character appropriately before rotating it about the x or z axes.
Letters:
char_A, char_B, char_C,
char_D, char_E, char_F,
char_G, char_H, char_I,
char_J, char_K, char_L,
char_M, char_N, char_O,
char_P, char_Q, char_R,
char_S, char_T, char_U,
char_V, char_W, char_X,
char_Y, char_Z
Numerals:
char_0, char_1,
char_2, char_3,
char_4, char_5,
char_6, char_7,
char_8, char_9
Symbols:
char_Dash, char_Plus, char_ExclPt,
char_Amps, char_Num, char_Dol,
char_Perc, char_Astr, char_Hat,
char_LPar, char_RPar, char_AtSign,
char_LSqu, char_RSqu
Usage:
#include "chars.inc"
.
.
object {char_A ...}
This file is mainly a list of predefined colors, but also has a few color manipulation macros.
This file contains 125 predefined colors that you can use in your scenes. Simply #include them in your scene file to use them:
#include "colors.inc"
These basic colors:
A series of percentage grays that are useful for fine-tuning lighting color values and for other areas where subtle variations of grays are needed, and a palette of over 100 additional color definitions are available. See the distribution file ~include/colors.inc for more details.
In POV-Ray all colors are handled in RGB color space with a component for the amount of red, green and blue light. However, not everybody thinks this is the most intuitive way to specify colors. For your convenience there are macros included in colors.inc that converts between a few different types of color spaces.
The supported color spaces:
RGB = < Red, Green, Blue, Filter, Transmit >HSL = < Hue, Saturation, Lightness, Filter, Transmit >HSV = < Hue, Saturation, Value, Filter, Transmit >XYZ = < X, Y, Z, Filter, Transmit > (CIEXYZ; New in 3.7.1)Lab = < Lightness L*, Chroma a*, Chroma b* > (more accurately L*a*b*, CIELAB; New in 3.7.1)Note: The Hue parameter is given in degrees.
CHSL2RGB(Color): Converts a color given in HSL space to one in RGB space.
Parameters:
Color = HSL color to be converted.CRGB2HSL(Color): Converts a color given in RGB space to one in HSL space.
Parameters:
Color = RGB color to be converted.CHSV2RGB(Color): Converts a color given in HSV space to one in RGB space.
Parameters:
Color = HSV color to be converted.CRGB2HSV(Color): Converts a color given in RGB space to one in HSV space.
Parameters:
Color = RGB color to be converted.CXYZ2RGB(Color): Converts a color given in XYZ space to one in RGB space.
Parameters:
Color = XYZ color to be converted.CRGB2XYZ(Color): Converts a color given in RGB space to one in XYZ space.
Parameters:
Color = RGB color to be converted.CLab2RGB(Color,WhiteXYZ): Converts a color given in Lab space to one in RGB space.
Parameters:
Color = Lab color to be converted.WhiteXYZ = XYZ color of the chosen L*a*b* variant's reference white point.CRGB2Lab(Color,WhiteXYZ): Converts a color given in RGB space to one in Lab space.
Parameters:
Color = RGB color to be converted.WhiteXYZ = XYZ color of the chosen L*a*b* variant's reference white point.CLab2RGB_D65(Color): Converts a color given in Lab space (using D65 as reference white point) to one in RGB space.
Parameters:
Color = Lab color to be converted.CRGB2Lab_D65(Color): Converts a color given in RGB space to one in Lab space (using D65 as reference white point).
Parameters:
Color = RGB color to be converted.This file contains approximately 200 predefined colors from the German RAL institute's RAL Classic collection of standardized paint pigments that you can use in your scenes. Simply #include them in your scene file to use them:
#include "colors_ral.inc"
The colors are named RAL_nnnn, where nnnn is the 4-digit numerical RAL Classic color code.
This file defines a number of constants, including things such as mapping types and ior definitions.
o = < 0, 0, 0> (origin)xy = < 1, 1, 0>yz = < 0, 1, 1>xz = < 1, 0, 1>Plane_Map = 0Sphere_Map = 1Cylinder_Map = 2Torus_Map = 5Bi = 2Norm = 4Uniform_Fog = 1Ground_Fog = 2Hex_Blur1 = 7Hex_Blur2 = 19Hex_Blur3 = 37Air_Ior = 1.000292Amethyst_Ior = 1.550Apatite_Ior = 1.635Aquamarine_Ior = 1.575Beryl_Ior = 1.575Citrine_Ior = 1.550Crown_Glass_Ior = 1.51Corundum_Ior = 1.765Diamond_Ior = 2.47Emerald_Ior = 1.575 Flint_Glass_Ior = 1.71Flint_Glass_Heavy_Ior = 1.8Flint_Glass_Medium_Ior = 1.63Flint_Glass_Light_Ior = 1.6Fluorite_Ior = 1.434Gypsum_Ior = 1.525Ice_Ior = 1.31Plexiglas_Ior = 1.5Quartz_Ior = 1.550Quartz_Glass_Ior = 1.458Ruby_Ior = 1.765Salt_Ior = 1.544Sapphire_Ior = 1.765Topaz_Ior = 1.620Tourmaline_Ior = 1.650Water_Ior = 1.33Quartz_Glass_Dispersion = 1.012Water_Dispersion = 1.007Diamond_Dispersion = 1.035Sapphire_Dispersion = 1.015ISOTROPIC_SCATTERING = 1;MIE_HAZY_SCATTERING = 2;MIE_MURKY_SCATTERING = 3;RAYLEIGH_SCATTERING = 4;HENYEY_GREENSTEIN_SCATTERING = 5;This file contains a set of macros designed to make debugging easier. It also functions like the old debug.inc, with the exception that you have to call the Debug_Inc_Stack() macro to get the include stack output.
Debug_Inc_Stack(): Activates include file tracking, each included file will send a debug message when it is included.
Parameters:
Set_Debug(Bool): Activate or deactivate the debugging macros.
Parameters:
Bool = A boolean (true/false) value.Debug_Message(Str): If debugging, sends the message to the debug stream.
Parameters:
Str = The desired message.Debug(Condition, Message): Sends a message to the #debug stream depending on a given condition.
Parameters:
Condition = Any boolean expression.Message = The message to be sent if Condition evaluates as true.Warning(Condition, Message): Sends a message to the #warning stream depending on a given condition.
Parameters:
Condition = Any boolean expression.Message = The message to be sent if Condition evaluates as true.Error(Condition, Message): Sends a message to the #error stream depending on a given condition.
Parameters:
Condition = Any boolean expression.Message = The message to be sent if Condition evaluates as true.This file contains some predefined finishes.
DullShinyGlossyPhong_DullPhong_ShinyPhong_GlossyLuminousMirrorThis include file contains interfaces to internal functions as well as several predefined functions. The ID's used to access the internal functions through calls to internal(XX), are not guaranteed to stay the same between POV-Ray versions, so users are encouraged to use the functions declared here.
The number of required parameters and what they control are also given in the include file, this chapter gives more information. For starter
values of the parameters, see the ~scenes/incdemo/i_internal.pov demo file.
Syntax to be used:
#include "functions.inc"
isosurface {
function { f_torus_gumdrop(x,y,z, P0) }
...
}
pigment {
function { f_cross_ellipsoids(x,y,z, P0, P1, P2, P3) }
COLOR_MAP ...
}
Some special parameters are found in several of these functions. These are described in the next section and later referred to as Cross section type, Field Strength, Field Limit, SOR parameters.
In the helixes and spiral functions, the 9th parameter is the cross section type.
Some shapes are:
0: square0.0 to 1.0: rounded squares1: circle1.0 to 2.0: rounded diamonds2: diamond2.0 to 3.0: partially concave diamonds3: concave diamondThe numerical value at a point in space generated by the function is multiplied by the Field Strength. The set of points where the function evaluates to zero are unaffected by any positive value of this parameter, so if you are just using the function on its own with threshold = 0, the generated surface is still the same.
In some cases, the field strength has a considerable effect on the speed and accuracy of rendering the surface. In general, increasing the field strength speeds up the rendering, but if you set the value too high the surface starts to break up and may disappear completely.
Setting the field strength to a negative value produces the inverse of the surface, like making the function negative.
This will not make any difference to the generated surface if you are using threshold that is within the field limit (and will kill the surface completely if the threshold is greater than the field limit). However, it may make a huge difference to the rendering times.
If you use the function to generate a pigment, then all points that are a long way from the surface will have the same color, the color that corresponds to the numerical value of the field limit.
If greater than zero, the curve is swept out as a surface of revolution (SOR). If the value is zero or negative, the curve is extruded linearly in the Z direction.
If the SOR switch is on, then the curve is shifted this distance in the X direction before being swept out.
If the SOR switch is on, then the curve is rotated this number of degrees about the Z axis before being swept out.
Sometimes, when you render a surface, you may find that you get only the shape of the container. This could be caused by the fact that some of the build in functions are defined inside out.
We can invert the isosurface by negating the whole function: -(function) - threshold
Here is a list of the internal functions in the order they appear in the functions.inc include file
f_algbr_cyl1(x,y,z, P0, P1, P2, P3, P4): An algebraic cylinder is what you get if you take any 2d curve and plot it in 3d.
The 2d curve is simply extruded along the third axis, in this case the z axis. With the SOR Switch switched on, the figure-of-eight curve
will be rotated around the Y axis instead of being extruded along the Z axis.
P0 : Field StrengthP1 : Field LimitP2 : SOR SwitchP3 : SOR OffsetP4 : SOR Anglef_algbr_cyl2(x,y,z, P0, P1, P2, P3, P4): An algebraic cylinder is what you
get if you take any 2d curve and plot it in 3d.
The 2d curve is simply extruded along the third axis, in this case the z axis.With the SOR Switch switched on, the cross section curve will
be rotated around the Y axis instead of being extruded along the Z axis.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Field LimitP2 : SOR SwitchP3 : SOR OffsetP4 : SOR Anglef_algbr_cyl3(x,y,z, P0, P1, P2, P3, P4): An algebraic cylinder is what you get
if you take any 2d curve and plot it in 3d. The 2d curve
is simply extruded along the third axis, in this case the Z axis. With the SOR Switch switched on, the cross section curve will be rotated
around the Y axis instead of being extruded along the Z axis.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Field LimitP2 : SOR SwitchP3 : SOR OffsetP4 : SOR Anglef_algbr_cyl4(x,y,z, P0, P1, P2, P3, P4): An algebraic cylinder is what you get
if you take any 2d curve and plot it in 3d. The 2d curve
is simply extruded along the third axis, in this case the z axis. With the SOR Switch switched on, the cross section curve will be rotated
around the Y axis instead of being extruded along the Z axis.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Field LimitP2 : SOR SwitchP3 : SOR OffsetP4 : SOR Anglef_bicorn(x,y,z, P0, P1): The surface is a surface of revolution.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Scale. The mathematics of this surface suggest that the shape should be different
for different values of this parameter. In practice the difference in shape is hard to spot.
Setting the scale to 3 gives a surface with a radius of about 1 unitf_bifolia(x,y,z, P0, P1): The bifolia surface looks something like the top part of
a a paraboloid bounded below by another paraboloid.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Scale. The surface is always the same shape. Changing this parameter has the
same effect as adding a scale modifier. Setting the scale to 1 gives a surface with a radius
of about 1 unitf_blob(x,y,z, P0, P1, P2, P3, P4): This function generates blobs that are
similar to a CSG blob with two spherical components. This function only seems to work
with negative threshold settings.
P0 : X distance between the two componentsP1 : Blob strength of component 1P2 : Inverse blob radius of component 1P3 : Blob strength of component 2P4 : Inverse blob radius of component 2f_blob2(x,y,z, P0, P1, P2, P3): The surface is similar to a CSG blob
with two spherical components.
P0 : Separation. One blob component is at the origin, and the other is this distance away on the X axisP1 : Inverse size. Increase this to decrease the size of the surfaceP2 : Blob strengthP3 : Threshold. Setting this parameter to 1 and the threshold to zero has exactly the same effect as setting this parameter to zero and the threshold to -1f_boy_surface(x,y,z, P0, P1): For this surface, it helps if the field strength
is set low, otherwise the surface has a tendency to break up or disappear entirely. This has
the side effect of making the rendering times extremely long.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Scale. The surface is always the same shape. Changing this parameter has the
same effect as adding a scale modifierf_comma(x,y,z, P0): The comma surface is very much like a comma-shape.
P0 : Scalef_cross_ellipsoids(x,y,z, P0, P1, P2, P3): The cross ellipsoids surface is
like the union of three crossed ellipsoids, one oriented along each axis.
P0 : Eccentricity. When less than 1, the ellipsoids are oblate, when greater than 1 the
ellipsoids are prolate, when zero the ellipsoids are spherical (and hence the whole surface is a sphere)P1 : Inverse size. Increase this to decrease the size of the surfaceP2 : Diameter. Increase this to increase the size of the ellipsoidsP3 : Threshold. Setting this parameter to 1 and the threshold to zero has exactly the same
effect as setting this parameter to zero and the threshold to -1f_crossed_trough(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_cubic_saddle(x,y,z, P0): For this surface, it helps if the field strength is set quite low, otherwise the surface has a
tendency to break up or disappear entirely.
P0 : Field Strength (Needs a negative field strength or a negated function)f_cushion(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_devils_curve(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_devils_curve_2d(x,y,z, P0, P1, P2, P3, P4, P5): The f_devils_curve_2d curve can be
extruded along the z axis, or using the SOR parameters it can be made into a surface of revolution.
The X and Y factors control the size of the central feature.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : X factorP2 : Y factorP3 : SOR SwitchP4 : SOR OffsetP5 : SOR Anglef_dupin_cyclid(x,y,z, P0, P1, P2, P3, P4, P5):
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Major radius of torusP2 : Minor radius of torusP3 : X displacement of torusP4 : Y displacement of torusP5 : Radius of inversionf_ellipsoid(x,y,z, P0, P1, P2): f_ellipsoid generates spheres and ellipsoids. Needs threshold 1.
Setting these scaling parameters to 1/n gives exactly the same effect as performing a scale operation to increase the scaling by n
in the corresponding direction.
P0 : X scale (inverse)P1 : Y scale (inverse)P2 : Z scale (inverse)f_enneper(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_flange_cover(x,y,z, P0, P1, P2, P3):
P0 : Spikiness. Set this to very low values to increase the spikes. Set it to 1 and you get a sphereP1 : Inverse size. Increase this to decrease the size of the surface. (The other parameters
also drastically affect the size, but this parameter has no other effects)P2 : Flange. Increase this to increase the flanges that appear between the spikes. Set it to 1 for no flangesP3 : Threshold. Setting this parameter to 1 and the threshold to zero has exactly the
same effect as setting this parameter to zero and the threshold to -1f_folium_surface(x,y,z, P0, P1, P2): A folium surface looks something like a paraboloid glued to a plane.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Neck width factor - the larger you set this, the narrower the neck where the
paraboloid meets the planeP2 : Divergence - the higher you set this value, the wider the paraboloid getsf_folium_surface_2d(x,y,z, P0, P1, P2, P3, P4, P5): The f_folium_surface_2d curve can be
rotated around the X axis to generate the same 3d surface as the f_folium_surface, or it can be extruded
in the Z direction (by switching the SOR switch off)
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Neck width factor - same as the 3d surface if you are revolving it around the Y axisP2 : Divergence - same as the 3d surface if you are revolving it around the Y axisP3 : SOR SwitchP4 : SOR OffsetP5 : SOR Anglef_glob(x,y,z, P0): One part of this surface would actually go off to
infinity if it were not restricted by the contained_by shape.
P0 : Field Strength (Needs a negative field strength or a negated function)f_heart(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_helical_torus(x,y,z, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9): With some sets of parameters, it looks like a torus with a
helical winding around it. The
winding optionally has grooves around the outside.
P0 : Major radiusP1 : Number of winding loopsP2 : Twistiness of winding. When zero, each winding loop is separate. When set to one,
each loop twists into the next one. When set to two, each loop twists into the one after nextP3 : Fatness of winding?P4 : Threshold. Setting this parameter to 1 and the threshold to zero has s similar effect
as setting this parameter to zero and the threshold to 1P5 : Negative minor radius? Reducing this parameter increases the minor radius of the
central torus. Increasing it can make the torus disappear and be replaced by a vertical column.
The value at which the surface switches from one form to the other depends on several other parametersP6 : Another fatness of winding control?P7 : Groove period. Increase this for more groovesP8 : Groove amplitude. Increase this for deeper groovesP9 : Groove phase. Set this to zero for symmetrical groovesf_helix1(x,y,z, P0, P1, P2, P3, P4, P5, P6):
P0 : Number of helixes - e.g. 2 for a double helixP1 : Period - is related to the number of turns per unit lengthP2 : Minor radius (major radius > minor radius)P3 : Major radiusP4 : Shape parameter. If this is greater than 1 then the tube becomes fatter in the y directionP5 : Cross section typeP6 : Cross section rotation angle (degrees)f_helix2(x,y,z, P0, P1, P2, P3, P4, P5, P6): Needs a negated function
P0 : Not usedP1 : Period - is related to the number of turns per unit lengthP2 : Minor radius (minor radius > major radius)P3 : Major radiusP4 : Not usedP5 : Cross section typeP6 : Cross section rotation angle (degrees)f_hex_x(x,y,z, P0): This creates a grid of hexagonal cylinders stretching along
the z-axis. The fatness is controlled
by the threshold value. When this value equals 0.8660254 or cos(30) the sides will touch, because
this is the distance between centers. Negating the function will inverse the surface and create a
honey-comb structure. This function is also useful as pigment function.
P0 : No effect (but the syntax requires at least one parameter)f_hex_y(x,y,z, P0): This is function forms a lattice of infinite boxes
stretching along the z-axis. The fatness is
controlled by the threshold value. These boxes are rotated 60 degrees around centers, which
are 0.8660254 or cos(30) away from each other. This function is also useful as pigment function.
P0 : No effect (but the syntax requires at least one parameter)f_hetero_mf(x,y,z, P0, P1, P2, P3, P4, P5): f_hetero_mf (x,0,z) makes multifractal height fields and patterns
of 1/f noise. Multifractal refers to their characteristic of having a fractal dimension which varies with
altitude. Built from summing noise of a number of frequencies, the hetero_mf parameters determine how many, and which frequencies are to be
summed. An advantage to using these instead of a height_field {} from an image (a number of height field programs output multifractal types
of images) is that the hetero_mf function domain extends arbitrarily far in the x and z directions so huge landscapes can be made without
losing resolution or having to tile a height field. Other functions of interest are f_ridged_mf and f_ridge.
P0 : H is the negative of the exponent of the basic noise frequencies used in building these functions (each frequency
f's amplitude is weighted by the factor f - H ). In landscapes, and many natural forms, the amplitude of high frequency
contributions are usually less than the lower frequencies. When H is 1, the fractalization is relatively smooth (1/f noise). As H
nears 0, the high frequencies contribute equally with low frequencies as in white noise.P1 : Lacunarity is the multiplier used to get from one octave to the next. This parameter affects the
size of the frequency gaps in the pattern. Make this greater than 1.0P2 : Octaves is the number of different frequencies added to the fractal. Each Octave frequency is the previous
one multiplied by Lacunarity, so that using a large number of octaves can get into very high frequencies very quickly.P3 : Offset is the base altitude (sea level) used for the heterogeneous scalingP4 : T scales the heterogeneity of the fractal. T=0 gives straight 1/f (no heterogeneous
scaling). T=1 suppresses higher frequencies at lower altitudesP5 : Generator type used to generate the noise3d. 0, 1, 2 and 3 are legal values.f_hunt_surface(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_hyperbolic_torus(x,y,z, P0, P1, P2):
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Major radius: separation between the centers of the tubes at the closest pointP2 : Minor radius: thickness of the tubes at the closest pointf_isect_ellipsoids(x,y,z, P0, P1, P2, P3): The isect ellipsoids surface is like the
intersection of three crossed ellipsoids, one oriented along each axis.
P0 : Eccentricity. When less than 1, the ellipsoids are oblate, when greater than 1 the
ellipsoids are prolate, when zero the ellipsoids are spherical (and hence the whole surface is a sphere)P1 : Inverse size. Increase this to decrease the size of the surfaceP2 : Diameter. Increase this to increase the size of the ellipsoidsP3 : Threshold. Setting this parameter to 1 and the threshold to zero has exactly
the same effect as setting this parameter to zero and the threshold to -1f_kampyle_of_eudoxus(x,y,z, P0, P1, P2): The kampyle of eudoxus is like two infinite planes with a dimple at the
center.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Dimple: When zero, the two dimples punch right through and meet at the center.
Non-zero values give less dimplingP2 : Closeness: Higher values make the two planes become closerf_kampyle_of_eudoxus_2d(x,y,z, P0, P1, P2, P3, P4, P5): The 2d curve that generates the above surface can be extruded in the
Z direction or rotated about various axes by using the SOR parameters.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Dimple: When zero, the two dimples punch right through and meet at the center.
Non-zero values give less dimplingP2 : Closeness: Higher values make the two planes become closerP3 : SOR SwitchP4 : SOR OffsetP5 : SOR Anglef_klein_bottle(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_kummer_surface_v1(x,y,z, P0): The Kummer surface consists of a collection of radiating rods.
P0 : Field Strength (Needs a negative field strength or a negated function)f_kummer_surface_v2(x,y,z, P0, P1, P2, P3): Version 2 of the kummer surface only looks like radiating rods when the
parameters are set to particular negative values. For positive values it tends to look rather like a superellipsoid.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Rod width (negative): Setting this parameter to larger negative values increases the diameter of the rodsP2 : Divergence (negative): Setting this number to -1 causes the rods to become
approximately cylindrical. Larger negative values cause the rods to become fatter further
from the origin. Smaller negative numbers cause the rods to become narrower away from
the origin, and have a finite lengthP3 : Influences the length of half of the rods.Changing the sign affects the other half of the rods. 0 has no effectf_lemniscate_of_gerono(x,y,z, P0): The Lemniscate of Gerono surface is an hourglass shape, or two teardrops with
their ends connected.
P0 : Field Strength (Needs a negative field strength or a negated function)f_lemniscate_of_gerono_2d(x,y,z, P0, P1, P2, P3, P4, P5): The 2d version of the Lemniscate can be extruded in the Z
direction, or used as a surface of revolution to generate the equivalent of the 3d version, or revolved in different ways.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Size: increasing this makes the 2d curve larger and less roundedP2 : Width: increasing this makes the 2d curve fatterP3 : SOR SwitchP4 : SOR OffsetP5 : SOR Anglef_mesh1(x,y,z, P0, P1, P2, P3, P4): The overall thickness of the threads is controlled by the isosurface threshold, not
by a parameter. If you render a mesh1 with zero threshold, the threads have zero thickness and are therefore invisible. Parameters P2 and P4
control the shape of the thread relative to this threshold parameter.
P0 : Distance between neighboring threads in the x directionP1 : Distance between neighboring threads in the z directionP2 : Relative thickness in the x and z directionsP3 : Amplitude of the weaving effect. Set to zero for a flat gridP4 : Relative thickness in the y directionf_mitre(x,y,z, P0): The Mitre surface looks a bit like an ellipsoid which has been nipped at each end with a pair
of sharp nosed pliers.
P0 : Field Strength (Needs a negative field strength or a negated function)f_nodal_cubic(x,y,z, P0): The Nodal Cubic is something like what you would get if you were to extrude the Stophid2D
curve along the X axis and then lean it over.
P0 : Field Strength (Needs a negative field strength or a negated function)f_noise3d(x,y,z):
f_noise_generator(x,y,z, P0):
P0 : Noise generator numberf_odd(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_ovals_of_cassini(x,y,z, P0, P1, P2, P3): The Ovals of Cassini are a generalization of the torus shape.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Major radius - like the major radius of a torusP2 : Filling. Set this to zero, and you get a torus. Set this to a higher value and the hole in the middle starts to heal
up. Set it even higher and you get an ellipsoid with a dimpleP3 : Thickness. The higher you set this value, the plumper is the resultf_paraboloid(x,y,z, P0): This paraboloid is the surface of revolution that you get if you rotate a parabola about the Y
axis.
P0 : Field Strength (Needs a negative field strength or a negated function)f_parabolic_torus(x,y,z, P0, P1, P2):
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Major radiusP2 : Minor radiusf_ph(x,y,z): When used alone, the PH function gives a surface that consists of all points that are at a particular
latitude, i.e. a cone. If you use a threshold of zero (the default) this gives a cone of width zero, which is invisible. Also look at
f_th and f_r
f_pillow(x,y,z, P0):
P0 : Field Strengthf_piriform(x,y,z, P0): The piriform surface looks rather like half a lemniscate.
P0 : Field Strengthf_piriform_2d(x,y,z, P0, P1, P2, P3, P4, P5, P6): The 2d version of the Piriform can be extruded in the Z
direction, or used as a surface of revolution to generate the equivalent of the 3d version.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Size factor 1: increasing this makes the curve largerP2 : Size factor 2: making this less negative makes the curve larger but also thinnerP3 : Fatness: increasing this makes the curve fatterP4 : SOR SwitchP5 : SOR OffsetP6 : SOR Anglef_poly4(x,y,z, P0, P1, P2, P3, P4): This f_poly4 can be used to generate the surface of revolution of any
polynomial up to degree 4. To put it another way: If we call the parameters A, B, C, D, E; then this function generates the surface of
revolution formed by revolving x = A + By + Cy2 + Dy3 + Ey4 around the Y axis.
P0 : ConstantP1 : Y coefficientP2 : Y2 coefficientP3 : Y3 coefficientP4 : Y4 coefficientf_polytubes(x,y,z, P0, P1, P2, P3, P4, P5): The Polytubes surface consists of a number of tubes. Each tube follows
a 2d curve which is specified by a polynomial of degree 4 or less. If we look at the parameters, then this function generates P0
tubes which all follow the equation x = P1 + P2y + P3y2 + P4y3 + P5y4 arranged around the Y axis. This function needs a
positive threshold (fatness of the tubes).
P0 : Number of tubesP1 : ConstantP2 : Y coefficientP3 : Y2 coefficientP4 : Y3 coefficientP5 : Y4 coefficientf_quantum(x,y,z, P0): It resembles the shape of the electron density cloud for one of the d orbitals.
P0 : Not used, but requiredf_quartic_paraboloid(x,y,z, P0): The Quartic Paraboloid is similar to a paraboloid, but has a squarer shape.
P0 : Field Strength (Needs a negative field strength or a negated function)f_quartic_saddle(x,y,z, P0): The Quartic saddle is similar to a saddle, but has a squarer shape.
P0 : Field Strengthf_quartic_cylinder(x,y,z, P0, P1, P2): The Quartic cylinder looks a bit like a cylinder that is swallowed an
egg.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Diameter of the eggP2 : Controls the width of the tube and the vertical scale of the eggf_r(x,y,z): When used alone, the R function gives a surface that consists of all the points that are a specific
distance (threshold value) from the origin, i.e. a sphere. Also look at f_ph and f_th
f_ridge(x,y,z, P0, P1, P2, P3, P4, P5): This function is mainly intended for modifying other surfaces as you might use a
height field or to use as pigment function. Other functions of interest are f_hetero_mf and f_ridged_mf.
P0 : LambdaP1 : OctavesP2 : OmegaP3 : OffsetP4 : RidgeP5 : Generator type used to generate the noise3d. 0, 1, 2 and 3 are legal values.f_ridged_mf(x,y,z, P0, P1, P2, P3, P4, P5): The Ridged Multifractal surface can be used to create multifractal
height fields and patterns. Multifractal refers to their characteristic of having a fractal dimension which varies with altitude.
They are built from summing noise of a number of frequencies. The f_ridged_mf parameters determine how many, and which frequencies are to be
summed, and how the different frequencies are weighted in the sum.
An advantage to using these instead of a height_field{} from an image is that the ridged_mf function domain extends
arbitrarily far in the x and z directions so huge landscapes can be made without losing resolution or having to tile a height field. Other
functions of interest are f_hetero_mf and f_ridge.
P0 : H is the negative of the exponent of the basic noise frequencies used in building these
functions (each frequency f's amplitude is weighted by the factor fE- H ). When H is 1, the
fractalization is relatively smooth. As H nears 0, the high frequencies contribute equally with
low frequenciesP1 : Lacunarity is the multiplier used to get from one octave to the next in the fractalization. This
parameter affects the size of the frequency gaps in the pattern. (Use values greater than 1.0)P2 : Octaves is the number of different frequencies added to the fractal. Each octave
frequency is the previous one multiplied by Lacunarity. So, using a large number of octaves can
get into very high frequencies very quicklyP3 : Offset gives a fractal whose fractal dimension changes from altitude to altitude. The high
frequencies at low altitudes are more damped than at higher altitudes, so that lower altitudes are
smoother than higher areasP4 : Gain weights the successive contributions to the accumulated fractal result to make
creases stick up as ridgesP5 : Generator type used to generate the noise3d. 0, 1, 2 and 3 are legal values.f_rounded_box(x,y,z, P0, P1, P2, P3): The Rounded Box is defined in a cube from <-1, -1, -1> to <1, 1, 1>. By
changing the Scale parameters, the size can be adjusted, without affecting the Radius of curvature.
P0 : Radius of curvature. Zero gives square corners, 0.1 gives corners that match sphere {0, 0.1}P1 : Scale xP2 : Scale yP3 : Scale zf_sphere(x,y,z, P0):
P0: radius of the spheref_spikes(x,y,z, P0, P1, P2, P3, P4):
P0 : Spikiness. Set this to very low values to increase the spikes. Set it to 1 and you get a sphereP1 : Hollowness. Increasing this causes the sides to bend in moreP2 : Size. Increasing this increases the size of the objectP3 : Roundness. This parameter has a subtle effect on the roundness of the spikesP4 : Fatness. Increasing this makes the spikes fatterf_spikes_2d(x,y,z, P0, P1, P2, P3):
P0 : Height of central spikeP1 : Frequency of spikes in the X directionP2 : Frequency of spikes in the Z directionP3 : Rate at which the spikes reduce as you move away from the centerf_spiral(x,y,z, P0, P1, P2, P3, P4, P5):
P0 : Distance between windingsP1 : ThicknessP2 : Outer radius of the spiral. The surface behaves as if it is contained_by a sphere of this diameterP3 : Not usedP4 : Not usedP5 : Cross section typef_steiners_roman(x,y,z, P0): The Steiners Roman is composed of four identical triangular pads which together make
up a sort of rounded tetrahedron. There are creases along the X, Y and Z axes where the pads meet.
P0 : Field Strength (Needs a negative field strength or a negated function)f_strophoid(x,y,z, P0, P1, P2, P3): The Strophoid is like an infinite plane with a bulb sticking out of it.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Size of bulb. Larger values give larger bulbs. Negative values give a bulb on the other side of the planeP2 : Sharpness. When zero, the bulb is like a sphere that just touches the plane. When
positive, there is a crossover point. When negative the bulb simply bulges out of the plane like a pimpleP3 : Flatness. Higher values make the top end of the bulb fatterf_strophoid_2d(x,y,z, P0, P1, P2, P3, P4, P5, P6): The 2d strophoid curve can be extruded in the Z direction or rotated
about various axes by using the SOR parameters.
P0 : Field StrengthP1 : Size of bulb. Larger values give larger bulbs. Negative values give a bulb on the other side of the planeP2 : Sharpness. When zero, the bulb is like a sphere that just touches the plane. When positive, there is a crossover
point. When negative the bulb simply bulges out of the plane like a pimpleP3 : Fatness. Higher values make the top end of the bulb fatterP4 : SOR SwitchP5 : SOR OffsetP6 : SOR Anglef_superellipsoid(x,y,z, P0, P1): Needs a negative field strength or a negated function.
P0 : east-west exponentxP1 : north-south exponentf_th(x,y,z): f_th() is a function that is only useful when combined with other surfaces. It produces a value
which is equal to the theta angle, in radians, at any point. The theta angle is like the longitude coordinate on the Earth. It
stays the same as you move north or south, but varies from east to west. Also look at f_ph and f_r
f_torus(x,y,z, P0, P1):
P0 : Major radiusP1 : Minor radiusf_torus2(x,y,z, P0, P1, P2): This is different from the f_torus function which just has the major and minor radii as
parameters.
P0 : Field Strength (Needs a negative field strength or a
negated function)P1 : Major radiusP2 : Minor radiusf_torus_gumdrop(x,y,z, P0): The Torus Gumdrop surface is something like a torus with a couple of gumdrops hanging
off the end.
P0 : Field Strength (Needs a negative field strength or a negated function)f_umbrella(x,y,z, P0):
P0 : Field Strength (Needs a negative field strength or a negated function)f_witch_of_agnesi(x,y,z, P0, P1, P2, P3, P4, P5): The Witch of Agnesi surface looks something like a witches
hat.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Controls the width of the spike. The height of the spike is always about 1 unitf_witch_of_agnesi_2d(x,y,z, P0, P1, P2, P3, P4, P5): The 2d version of the Witch of Agnesi curve can be extruded in
the Z direction or rotated about various axes by use of the SOR parameters.
P0 : Field Strength (Needs a negative field strength or a negated function)P1 : Controls the size of the spikeP2 : Controls the height of the spikeP3 : SOR SwitchP4 : SOR OffsetP5 : SOR Angleeval_pigment(Pigm, Vect): This macro evaluates the color of a pigment at a specific point. Some pigments require more
information than simply a point, slope pattern based pigments for example, and will not work with this macro. However, most pigments will
work fine.
Parameters:
Vect = The point at which to evaluate the pigment.Pigm = The pigment to evaluate.f_snoise3d(x, y, z): Just like f_noise3d(), but returns values in the range [-1, 1].
f_sine_wave(val, amplitude, frequency): Turns a ramping waveform into a sine waveform.
f_scallop_wave(val, amplitude, frequency): Turns a ramping waveform into a scallop wave waveform.
Predefined pattern functions, useful for building custom function patterns or performing displacement mapping on isosurfaces. Many of them are not really useful for these purposes, they are simply included for completeness.
Some are not implemented at all because they require special parameters that must be specified in the definition, or information that is not available to pattern functions. For this reason, you probably would want to define your own versions of these functions.
All of these functions take three parameters, the XYZ coordinates of the point to evaluate the pattern at.
f_agate(x, y, z)f_boxed(x, y, z)f_bozo(x, y, z)f_brick(x, y, z)f_bumps(x, y, z)f_checker(x, y, z)f_crackle(x, y, z)f_cylindrical(x, y, z)f_dents(x, y, z)f_gradientX(x, y, z)f_gradientY(x, y, z)f_gradientZ(x, y, z)f_granite(x, y, z)f_hexagon(x, y, z)f_leopard(x, y, z)f_mandel(x, y, z)f_marble(x, y, z)f_onion(x, y, z)f_planar(x, y, z)f_radial(x, y, z)f_ripples(x, y, z)f_spherical(x, y, z)f_spiral1(x, y, z)f_spiral2(x, y, z)f_spotted(x, y, z)f_waves(x, y, z)f_wood(x, y, z)f_wrinkles(x, y, z)This file contains glass materials using new features introduced in POV 3.1 and 3.5. The old glass.inc file is still included for backwards compatibility (it is named glass_old.inc, and is included by glass.inc, so you do not need to change any scenes), but these materials will give more realistic results.
Col_Glass_Beerbottle
|
Col_Glass_General
|
Col_Glass_Ruby
|
Col_Amber_01
|
Col_Amber_06
|
Col_Amethyst_02
|
Col_Apatite_01
|
Col_Aquamarine_01
|
Col_Aquamarine_06
|
Col_Beerbottle
|
Col_Citrine_01
|
Col_Emerald_04
|
Col_Fluorite_02
|
Col_Fluorite_07
|
Col_Green_02
|
Col_Gypsum_03
|
Col_Red_01
|
Col_Ruby_01
|
Col_Sapphire_01
|
Col_Topaz_03
|
Col_Tourmaline_05
|
Col_Yellow_01
|
F_Glass5, ..., F_Glass10
I_Glass1, ..., I_Glass4I_Glass_Fade_Sqr1 (identical to I_Glass1)I_Glass_Fade_Exp1 (identical to I_Glass2)I_Glass_Fade_Exp2 (identical to I_Glass3)I_Glass_Fade_Exp3 (identical to I_Glass4)I_Glass_Dispersion1, I_Glass_Dispersion2I_Glass_Dispersion1 has
an approximately natural glass dispersion. I_Glass_Dispersion2 is exaggerated.I_Glass_Caustics1, I_Glass_Caustics2I_Glass_Exp(Distance) and I_Glass_Sqr(Distance): These macros return an interior with either exponential or fade_power 2 falloff, and a fade_distance of Distance.
This file has its own versions of F_MetalA through F_MetalB. The gold textures themselves are T_Gold_1A through T_Gold_5E.
The official POV-Ray logo designed by Chris Colefax, in two versions
Povray_LogoPovray_Logo_PrismPovray_Logo_Bevelmakegrass.inc - grass and prairie building macros.
MakeBlade()MakeGrassPatch()MakePrairie()This file contains many general math functions and macros.
even(N): A function to test whether N is even, returns 1 when true, 0 when false.
Parameters:
N = Input valueodd(N): A function to test whether N is odd, returns 1 when true, 0 when false.
Parameters:
N = Input valueInterpolate(GC, GS, GE, TS, TE, Method): Interpolation macro, interpolates between the float values TS and TE. The method of interpolation is cosine, linear or exponential. The position where to evaluate the interpolation is determined by the position of GC in the range GS - GE. See the example below.
Parameters:
GC = global current, float value within the range GS - GEGS = global startGE = global endTS = target startTE = target endMethod = interpolation method, float value:
Method < 0 : exponential, using the value of Method as exponent.Method = 0 : cosine interpolation.Method > 0 : exponential, using the value of Method as exponent.
Method = 1 : linear interpolation,Example:
#declare A = Interpolate(0.5, 0, 1, 0, 10, 1); #debug str(A,0,2) // result A = 5.00 #declare A = Interpolate(0.0,-2, 2, 0, 10, 1); #debug str(A,0,2) // result A = 5.00 #declare A = Interpolate(0.5, 0, 1, 0, 10, 2); #debug str(A,0,2) // result A = 2.50
Mean(A): A macro to compute the average of an array of values.
Parameters:
A = An array of float or vector values.Std_Dev(A, M): A macro to compute the standard deviation.
Parameters:
A = An array of float values.M = Mean of the floats in the array.GetStats(A): This macro declares a global array named StatisticsArray containing: N, Mean, Min, Max, and Standard Deviation
Parameters:
A = An array of float values.Histogram(ValArr, Intervals): This macro declares a global, 2D array named HistogramArray. The first value in the array is the center of the interval/bin, the second the number of values in that interval.
Parameters:
ValArr = An array with values.Intervals = The desired number of intervals/bins.sind(v), cosd(v), tand(v), asind(v), acosd(v), atand(v), atan2d(a, b): These functions are versions of the
trigonometric functions using degrees, instead of radians, as the angle unit.
Parameters:
max3(a, b, c): A function to find the largest of three numbers.
Parameters:
a, b, c = Input values.min3(a, b, c): A function to find the smallest of three numbers.
Parameters:
a, b, c = Input values.f_sqr(v): A function to square a number.
Parameters:
v = Input value.sgn(v): A function to show the sign of the number. Returns -1 or 1 depending on the sign of v.
Parameters:
v = Input value.clip(V, Min, Max): A function that limits a value to a specific range, if it goes outside that range it is clipped. Input values larger than Max will return Max, those less than Min will return Min.
Parameters:
V = Input value.Min = Minimum of output range.Max = Maximum of output range.clamp(V, Min, Max): A function that limits a value to a specific range, if it goes outside that range it is clamped to this range, wrapping around. As the input increases or decreases outside the given range, the output will
repeatedly sweep through that range, making a sawtooth waveform.
Parameters:
V = Input value.Min = Minimum of output range.Max = Maximum of output range.adj_range(V, Min, Max): A function that adjusts input values in the range [0, 1] to a given range. An input value of 0 will return Min, 1 will return Max, and values outside the [0, 1] range will be linearly extrapolated (the graph will continue in a straight line).
Parameters:
V = Input value.Min = Minimum of output range.Max = Maximum of output range.adj_range2(V, InMin, InMax, OutMin, OutMax): Like f_range(), but adjusts input values in the range [InMin, InMax] to the range [OutMin, OutMax].
Parameters:
V = Input value.InMin = Minimum of input range.InMax = Maximum of input range.OutMin = Minimum of output range.OutMax = Maximum of output range.These are all macros in the current version because functions can not take vector parameters, but this may change in the future.
VSqr(V): Square each individual component of a vector, equivalent to V*V.
Parameters:
V = Vector to be squared.VPow(V, P), VPow5D(V, P): Raise each individual component of a vector to a given power.
Parameters:
V = Input vector.P = Power.VEq(V1, V2): Tests for equal vectors, returns true if all three components of V1equal the respective components of V2.
Parameters:
V1, V2 = The vectors to be compared.VEq5D(V1, V2): A 5D version of VEq(). Tests for equal vectors, returns true if all 5 components of V1 equal the respective components of V2.
Parameters:
V1, V2 = The vectors to be compared.VZero(V): Tests for a < 0, 0, 0> vector.
Parameters:
V = Input vector.VZero5D(V): Tests for a < 0, 0, 0, 0, 0> vector.
Parameters:
V = Input vector.VLength5D(V): Computes the length of a 5D vector.
Parameters:
V = Input vector.VNormalize5D(V): Normalizes a 5D vector.
Parameters:
V = Input vector.VDot5D(V1, V2): Computes the dot product of two 5D vectors. See vdot() for more information on dot products.
Parameters:
V = Input vector.VCos_Angle(V1, V2): Compute the cosine of the angle between two vectors.
Parameters:
V1, V2 = Input vectors.VAngle(V1, V2), VAngleD(V1, V2): Compute the angle between two vectors. VAngle() returns the angle in radians, VAngleD() in degrees.
Parameters:
V1, V2 = Input vectors.VRotation(V1, V2, Axis) and VRotationD(V1, V2, Axis): Compute the rotation angle from V1 to V2 around Axis. Axis should be perpendicular to both V1 and V2. The output will be in the range between -pi and pi radians or between -180 degrees and 180 degrees if you are using the degree version. However, if Axis is set to <0,0,0> the output will always be positive or zero, the same result you will get with the VAngle() macros.
Parameters:
V1, V2 = Input vectors.VDist(V1, V2): Compute the distance between two points.
Parameters:
V1, V2 = Input vectors.VPerp_To_Vector(V): Find a vector perpendicular to the given vector.
Parameters:
V = Input vector.VPerp_To_Plane(V1, V2): Find a vector perpendicular to both given vectors. In other words, perpendicular to the plane defined by the two input vectors.
Parameters:
V1, V2 = Input vectors.VPerp_Adjust(V1, Axis): Find a vector perpendicular to Axis and in the plane of V1 and Axis. In other words, the new vector is a version of V1 adjusted to be perpendicular to Axis.
Parameters:
V1, Axis = Input vectors.VProject_Plane(V1, Axis): Project vector V1 onto the plane defined by Axis.
Parameters:
V1 = Input vectors.Axis = Normal of the plane.VProject_Axis(V1, Axis): Project vector V1 onto the axis defined by Axis.
Parameters:
V1, Axis = Input vectors.VMin(V), VMax(V): Find the smallest or largest component of a vector.
Parameters:
V = Input vector.VWith_Len(V, Len): Create a vector parallel to a given vector but with a given length.
Parameters:
V = Direction vector.Len = Length of desired vector.SetGradientAccuracy(Value): All the macros below make use of a constant named __Gradient_Fn_Accuracy_ for numerical approximation of the derivatives. This constant can be changed with the macro, the default value is 0.001.
fn_Gradient(Fn): A macro calculating the gradient of a function as a function.
Parameters:
Fn = function to calculate the gradient from.Output: the length of the gradient as a function.
fn_Gradient_Directional(Fn, Dir): A macro calculating the gradient of a function in one direction as a function.
Parameters:
Fn = function to calculate the gradient from.Dir = direction to calculate the gradient.Output: the gradient in that direction as a function.
fn_Divergence(Fnx, Fny, Fnz): A macro calculating the divergence of a (vector) function as a function.
Parameters:
Fnx, Fny, Fnz= x, y and z components of a vector function.Output: the divergence as a function.
vGradient(Fn, p0): A macro calculating the gradient of a function as a vector expression.
Parameters:
Fn = function to calculate the gradient from.p0 = point where to calculate the gradient.Output: the gradient as a vector expression.
vCurl(Fnx, Fny, Fnz, p0): A macro calculating the curl of a (vector) function as a vector expression.
Parameters:
Fnx, Fny, Fnz = x, y and z components of a vector function.p0 = point where to calculate the gradient.Output: the curl as a vector expression
Divergence(Fnx, Fny, Fnz, p0): A macro calculating the divergence of a (vector) function as a float expression.
Parameters:
Fnx, Fny, Fnz = x, y and z components of a vector function.p0 = point where to calculate the gradient.Output: the divergence as a float expression.
Gradient_Length(Fn, p0): A macro calculating the length of the gradient of a function as a float expression.
Parameters:
Fn = function to calculate the gradient from.p0 = point where to calculate the gradient.Output: the length of the gradient as a float expression.
Gradient_Directional(Fn, p0, Dir): A macro calculating the gradient of a function in one direction as a float expression.
Parameters:
Fn = function to calculate the gradient from.
p0 = point where to calculate the gradient.
Dir = direction to calculate the gradient.
Output: the gradient in that direction as a float expression
meshmaker.inc - various mesh2 objects by splines.
MSM(SplineArray, SplRes, Interp_type, InterpRes, FileName)FileName.BuildWriteMesh2(VecArr, NormArr, UVArr, U, V, FileName)VecArr : The array that contains the vertices of the triangles in the mesh.NormArr : The array with the normal vectors that go with the vertices.UVArr : The array containing the uv_vectors.U : The amount of subdivisions of the surface in the u-direction.V : The amount of subdivisions in the v-direction.FileName : The name of the file to which the mesh will be written.
If is an empty string (""), no file will be written.BuildSpline(Arr, SplType)Arr a spline of the given spline type SplType.CheckFileName(FileName)LInterpolate(Val, Min, Max)Min and Max.Min : minimal float value or vector.Max : Maximal float value or vector.Val : A float in the range 0 - 1.RangeMM() = function(Val,Rmin,Rmax,Min,Max)RMin, RMax] to fit in the range [Min, Max].
Val: A float value in the range [Rmin, Rmax].Parametric(__F1__, __F2__, __F3__, UVmin, UVmax, Iter_U, Iter_V, FileName)__F1__, __F2__, __F3__
in the ranges between UVmin and UVmax with the iteration steps
Iter_U and Iter_V and optionally saves the mesh2 object as a file with the name FileName.Paramcalc(UVmin, UVmax, Iter_U, Iter_V, FileName)Parametric(). Prism1(Spl, ResSpl, PSpl, PRes, FileName)Spl along the y-axis with the resolution spline ResSpl.
In every step the spline is scaled by the 'relative' distance from the
y-axis of the second spline (PSpl).Spl : The spline to be extruded.ResSpl : The amount of triangles to be used along the spline.
PSpl : The spline that determines by what amount the extrusionSpl.FileName : The name of the file to which the mesh will be written.Lathe(Spl, ResSpl, Rot, ResRot, FileName)Spl : The spline to be rotated.
The spline is evaluated from t=0 to t=1. For the normal calculation,
it is required that all splines (also linear_spline) have one extra
point before t=0 and after t=1.
ResSpl : The amount of triangles to be used along the spline.
Rot : The angle the spline has to be rotated.ResRot : The amount of triangles to be used in the circumference.FileName : The name of the file to which the mesh will be written.Coons(Spl1, Spl2, Spl3, Spl4, Iter_U, Iter_V, FileName)Spl1 - 4 : The four spline that define the surface.Iter_U : The resolution for the splines 1 and 3.Iter_V : The resolution for the splines 2 and 4.FileName : The name of the file to which the mesh will be written.TwoVarSurf(__Fuv, Urange, Vrange, Iter_U, Iter_V, FileName)Urange : The range in x direction.Vrange : The range in y direction.Iter_U : The resolution in x direction.Iter_V : The resolution in y direction.FileName : The name of the file to which the mesh will be written.SweepSpline1(Track,Shape,Waist,U,V,Filename)Shape along Track
and optionally writes it as a file with method 1.FileName : The name of the file to which the mesh will be written.
If is an empty string (""), no file will be written. If a file name is given, the macro SweepSpline2(Track,Shape,Waist,U,V,Filename)Shape along Track
and optionally writes it as a file with method 2.FileName : The name of the file to which the mesh will be written.
If is an empty string (""), no file will be written. If a file name is given, the macro These files define several metal textures. The file metals.inc contains copper, silver, chrome, and brass textures, and golds.inc contains the gold textures. Rendering the demo files will come in useful in using these textures.
Pigments:
P_Brass1P_Brass2P_Brass3P_Brass4P_Brass5P_Copper1P_Copper2P_Copper3P_Copper4P_Copper5P_Chrome1P_Chrome2P_Chrome3P_Chrome4P_Chrome5P_Silver1P_Silver2P_Silver3P_Silver4P_Silver5Finishes:
F_MetalAF_MetalBF_MetalCF_MetalDF_MetalETextures:
T_Brass_1A to T_Brass_5ET_Copper_1A to T_Copper_5ET_Chrome_1A to T_Chrome_5ET_Silver_1A to T_Silver_5EThis file defines a macro that sets some common radiosity settings. These settings are extremely general and are intended for ease of use, and do not necessarily give the best results.
Usage:
#include "rad_def.inc"
global_settings {
...
radiosity {
Rad_Settings(Setting, Normal, Media)
}
}
Parameters:
A collection of macros for generating random numbers, as well as 4 predefined random number streams: RdmA, RdmB, RdmC, and RdmD. There are macros for creating random numbers in a flat distribution (all numbers equally likely) in various ranges, and a variety of other distributions.
SRand(Stream): Signed rand(), returns random numbers in the range [-1, 1].
Parameters:
Stream = Random number stream.RRand(Min, Max, Stream): Returns random numbers in the range [Min, Max].
Parameters:
Min = The lower end of the output range.Max = The upper end of the output range.Stream = Random number stream.VRand(Stream): Returns random vectors in a box from < 0, 0, 0> to < 1, 1, 1>
Parameters:
Stream = Random number stream.VRand_In_Box(PtA, PtB, Stream): Like VRand(), this macro returns a random vector in a box, but this version lets you specify the two corners of the box.
Parameters:
PtA = Lower-left-bottom corner of box.PtB = Upper-right-top corner of box.Stream = Random number stream.VRand_In_Sphere(Stream): Returns a random vector in a unit-radius sphere located at the origin.
Parameters:
Stream = Random number stream.VRand_On_Sphere(Stream): Returns a random vector on the surface of a unit-radius sphere located at the origin.
Parameters:
Stream = Random number stream.VRand_In_Obj(Object, Stream): This macro takes a solid object and returns a random point that is inside it. It does this by randomly sampling the bounding box of the object, and can be quite slow if the object occupies a small percentage of the volume of its bounding box (because it will take more attempts to find a point inside the object). This macro is best used on finite, solid objects (non-solid objects, such as meshes and bezier patches, do not have a defined inside, and will not work).
Parameters:
Object = The object the macro chooses the points from.Stream = Random number stream.Rand_Cauchy(Mu, Sigma, Stream): Cauchy distribution.
Parameters:
Mu = Mean.Sigma = Standard deviation.Stream = Random number stream.Rand_Student(N, Stream): Student's distribution.
Parameters:
N = degrees of freedom.Stream = Random number stream.Rand_Normal(Mu, Sigma, Stream): Normal distribution.
Parameters:
Mu = Mean.Sigma = Standard deviation.Stream = Random number stream.Rand_Gauss(Mu, Sigma, Stream): Gaussian distribution. Like Rand_Normal(), but a bit faster.
Parameters:
Mu = Mean.Sigma = Standard deviation.Stream = Random number stream.Rand_Spline(Spline, Stream): This macro takes a spline describing the desired distribution. The T value of the spline is the output value, and the .y value its chance of occuring.
Parameters:
Spline = A spline determining the distribution.Stream = Random number stream.Rand_Gamma(Alpha, Beta, Stream): Gamma distribution.
Parameters:
Alpha = Shape parameter > 0.Beta = Scale parameter > 0.Stream = Random number stream.Rand_Beta(Alpha, Beta, Stream): Beta variate.
Parameters:
Alpha = Shape Gamma1.Beta = Scale Gamma2.Stream = Random number stream.Rand_Chi_Square(N, Stream): Chi Square random variate.
Parameters:
N = Degrees of freedom (integer).Stream = Random number stream.Rand_F_Dist(N, M, Stream): F-distribution.
Parameters:
N, M = Degrees of freedom.Stream = Random number stream.Rand_Tri(Min, Max, Mode, Stream): Triangular distribution
Parameters:
Min, Max, Mode: Min < Mode < Max.Stream = Random number stream.Rand_Erlang(Mu, K, Stream): Erlang variate.
Parameters:
Mu = Mean >= 0.K = Number of exponential samples.Stream = Random number stream.Rand_Exp(Lambda, Stream): Exponential distribution.
Parameters:
Lambda = rate = 1/mean.Stream = Random number stream.Rand_Lognormal(Mu, Sigma, Stream): Lognormal distribution.
Parameters:
Mu = Mean.Sigma = Standard deviation.Stream = Random number stream.Rand_Pareto(Alpha, Stream): Pareto distribution.
Parameters:
Alpha = ?Stream = Random number stream.Rand_Weibull(Alpha, Beta, Stream): Weibull distribution.
Parameters:
Alpha = ?Beta = ?Stream = Random number stream.Rand_Bernoulli(P, Stream) and Prob(P, Stream): Bernoulli distribution. Output is true with probability equal to the value of P and false with a probability of 1 - P.
Parameters:
P = probability range (0-1).Stream = Random number stream.Rand_Binomial(N, P, Stream): Binomial distribution.
Parameters:
N = Number of trials.P = Probability (0-1)Stream = Random number stream.Rand_Geo(P, Stream): Geometric distribution.
Parameters:
P = Probability (0-1).Stream = Random number stream.Rand_Poisson(Mu, Stream): Poisson distribution.
Parameters:
Mu = Mean.Stream = Random number stream.Screen.inc will enable you to place objects and textures right in front of the camera. When you move the camera, the objects placed with screen.inc will follow the movement and stay in the same position on the screen. One use of this is to place your signature or a logo in the corner of the image.
You can only use screen.inc with the perspective camera. Screen.inc will automatically create a default camera definition for you when it is included. All aspects of the camera can than be changed, by invoking the appropriate 'Set_Camera_...' macros in your scene. After calling these setup macros you can use the macros Screen_Object and Screen_Plane.
Note: Even though objects aligned using screen.inc follow the camera, they are still part of the scene. That means that they will be affected by perspective, lighting, the surroundings etc.
For an example of use, see the screen.pov demo file.
Set_Camera_Location(Loc): Changes the position of the default camera to a new location as specified by the Loc vector.
Set_Camera_Look_At(LookAt): Changes the position the default camera looks at to a new location as specified by the LookAt vector.
Set_Camera_Aspect_Ratio(Aspect): Changes the default aspect ratio, Aspect is a float value, usually width divided by the height of the image.
Set_Camera_Aspect(Width,Height): Changes the default aspect ratio of the camera.
Set_Camera_Sky(Sky): Sets a new Sky-vector for the camera.
Set_Camera_Zoom(Zoom): The amount to zoom in or out, Zoom is a float.
Set_Camera_Angle(Angle): Sets a new camera angle.
Set_Camera(Location, LookAt, Angle): Set location, look_at and angle in one go.
Reset_Camera(): Resets the camera to its default values.
Screen_Object (Object, Position, Spacing, Confine, Scaling): Puts an object in front of the camera.
Parameters:
Object = The object to place in front of the screen.Position = UV coordinates for the object. <0,0> is lower left corner of the screen and <1,1> is upper right corner.Spacing = Float describing minimum distance from object to the borders. UV vector can be used to get different horizontal and vertical spacing.Confine = Set to true to confine objects to visible screen area. Set to false to allow objects to be outside visible screen area.Scaling = If the object intersects or interacts with the scene, try to move it closer to the camera by decreasing Scaling.Screen_Plane (Texture, Scaling, BLCorner, TRCorner): Screen_Plane is a macro that will place a texture of your choice on a plane right in front of the camera.
Parameters:
Texture = The texture to be displayed on the camera plane. <0,0,0> is lower left corner and <1,1,0> is upper right corner.Scaling = If the plane intersects or interacts with the scene, try to move it closer to the camera by decreasing Scaling.BLCorner = The bottom left corner of the Screen_Plane.TRCorner = The top right corner of the Screen_Plane.These files contain predefined shapes and shape-generation macros.
shapes.inc includes shapes_old.inc and contains many macros for working with objects, and for creating special objects, such as bevelled text, spherical height fields, and rounded shapes.
Many of the objects in shapes_old.inc are not very useful in the newer versions of POV-Ray, and are kept for backwards compatability with old scenes written for versions of POV-Ray that lacked primitives like cones, disks, planes, etc.
The file shapes2.inc contains some more useful shapes, including regular polyhedrons, and shapesq.inc contains several quartic and cubic shape definitions.
Some of the shapes in shapesq.inc would be much easier to generate, more flexible, and possibly faster rendering as isosurfaces, but are still useful for two reasons: backwards compatability, and the fact that isosurfaces are always finite.
Isect(Pt, Dir, Obj, OPt) and IsectN(Pt, Dir, Obj, OPt, ONorm): These macros are interfaces to the trace() function. Isect() only returns the intersection point, IsectN() returns the surface normal as well. These macros return the point and normal information through their parameters, and true or false depending on whether an intersection was found: If an intersection is found, they return true and set OPt to the intersection point, and ONorm to the normal. Otherwise they return false, and do not modify OPt or ONorm.
Parameters:
Pt = The origin (starting point) of the ray.Dir = The direction of the ray.Obj = The object to test for intersection with.OPt = A declared variable, the macro will set this to the intersection point.ONorm = A declared variable, the macro will set this to the surface normal at the intersection point.Extents(Obj, Min, Max): This macro is a shortcut for calling both min_extent() and max_extent() to get the corners of the bounding box of an object. It returns these values through the Min and Max parameters.
Parameters:
Obj = The object you are getting the extents of.Min = A declared variable, the macro will set this to the min_extent of the object.Max = A declared variable, the macro will set this to the max_extent of the object.Center_Object(Object, Axis): A shortcut for using the Center_Trans() macro with an object.
Parameters:
Object = The object to be centered.Axis = See Center_Trans() in the transforms.inc documentation.Align_Object(Object, Axis, Pt): A shortcut for using the Align_Trans() macro with an object.
Parameters:
Object = The object to be aligned.Axis = See Align_Trans() in the transforms.inc documentation.Point = The point to which to align the bounding box of the object. Bevelled_Text(Font, String, Cuts, BevelAng, BevelDepth, Depth, Offset, UseMerge): This macro attempts to bevel the front edges of a text object. It accomplishes this by making an intersection of multiple copies of the text object, each sheared in a different direction. The results are no perfect, but may be entirely acceptable for some purposes. Warning: the object generated may render considerably more slowly than an ordinary text object.
Parameters:
Font = A string specifying the font to use.String = The text string the object is generated from.Cuts = The number of intersections to use in bevelling the text.
More cuts give smoother results, but take more memory and are slower rendering.BevelAng = The angle of the bevelled edge.BevelDepth = The thickness of the bevelled portion.Depth = The total thickness of the resulting text object.Offset = The offset parameter for the text object. The z value
of this vector will be ignored, because the front faces of all the letters need
to be coplanar for the bevelling to work.UseMerge = Switch between merge (1) and union (0).Text_Space(Font, String, Size, Spacing): Computes the width of a text string, including white space, it returns the advance widths of all n letters. Text_Space gives the space a text, or a glyph, occupies in regard to its surroundings.
Parameters:
Font = A string specifying the font to use.String = The text string the object is generated from.Size = A scaling value.Spacing = The amount of space to add between the characters.Text_Width(Font, String, Size, Spacing): Computes the width of a text string, it returns the advance widths of the first n-1 letters, plus the glyph width of the last letter. Text_Width gives the physical width of the text and if you use only one letter the physical width of one glyph.
Parameters:
Font = A string specifying the font to use.String = The text string the object is generated from.Size = A scaling value.Spacing = The amount of space to add between the characters.Align_Left, Align_Right, Align_Center: These constants are used by the
Circle_Text() macro.
Circle_Text(Font, String, Size, Spacing, Depth, Radius, Inverted, Justification, Angle): Creates a text object with the bottom (or top) of the character cells aligned with all or part of a circle. This macro should be used inside an object{...} block.
Parameters:
Font = A string specifying the font to use.String = The text string the object is generated from.Size = A scaling value.Spacing = The amount of space to add between the characters.Depth = The thickness of the text object.Radius = The radius of the circle the letters are aligned to.Inverted = Controls what part of the text faces outside.
If this parameter is nonzero, the tops of the letters will point toward the center
of the circle. Otherwise, the bottoms of the letters will do so.Justification = Align_Left, Align_Right, or Align_Center.Angle = The point on the circle from which rendering will begin. The +x
direction is 0 and the +y direction is 90 (i.e. the angle increases
anti-clockwise).Wedge(Angle): This macro creates an infinite wedge shape, an intersection of two planes. It is mainly useful in CSG, for example to obtain a specific arc of a torus. The edge of the wedge is positioned along the y axis, and one side is fixed to the zy plane, the other side rotates clockwise around the y axis.
Parameters:
Angle = The angle, in degrees, between the sides of the wedge shape.Spheroid(Center, Radius): This macro creates an unevenly scaled sphere. Radius is a vector where each component is the radius along that axis.
Parameters:
Center = Center of the spheroid.Radius = A vector specifying the radii of the spheroid.Supertorus(MajorRadius, MinorRadius, MajorControl, MinorControl, Accuracy, MaxGradient): This macro creates an isosurface of the torus equivalent of a superellipsoid. If you specify a MaxGradient of less than 1, evaluate will be used. You will have to adjust MaxGradient to fit the parameters you choose, a squarer supertorus will have a higher gradient. You may want to use the function alone in your own isosurface.
Parameters:
MajorRadius, MinorRadius = Base radii for the torus.MajorControl, MinorControl = Controls for the roundness of the supertorus. Use numbers in the range [0, 1].Accuracy = The accuracy parameter.MaxGradient = The max_gradient parameter.Supercone(EndA, A, B, EndB, C, D): This macro creates an object similar to a cone, but where the end points are ellipses. The actual object is an intersection of a quartic with a cylinder.
Parameters:
EndA = Center of end A.A, B = Controls for the radii of end A.EndB = Center of end B.C, D = Controls for the radii of end B.Connect_Spheres(PtA, RadiusA, PtB, RadiusB): This macro creates a cone that will smoothly join two spheres. It creates only the cone object, however, you will have to supply the spheres yourself or use the Round_Cone2() macro instead.
Parameters:
PtA = Center of sphere A.RadiusA = Radius of sphere A.PtB = Center of sphere B.RadiusB = Radius of sphere B.Wire_Box_Union(PtA, PtB, Radius),
Wire_Box_Merge(PtA, PtB, Radius),
Wire_Box(PtA, PtB, Radius, UseMerge): Creates a wire-frame box from cylinders and spheres. The resulting object will fit entirely within a box object with the same corner points.
Parameters:
PtA = Lower-left-front corner of box.PtB = Upper-right-back corner of box.Radius = The radius of the cylinders and spheres composing the object.UseMerge = Whether or not to use a merge.Round_Box_Union(PtA, PtB, EdgeRadius),
Round_Box_Merge(PtA, PtB, EdgeRadius),
Round_Box(PtA, PtB, EdgeRadius, UseMerge): Creates a box with rounded edges from boxes, cylinders and spheres. The resulting object will fit entirely within a box object with the same corner points. The result is slightly different from a superellipsoid, which has no truely flat areas.
Parameters:
PtA = Lower-left-front corner of box.PtB = Upper-right-back corner of box.EdgeRadius = The radius of the edges of the box.UseMerge = Whether or not to use a merge.Round_Cylinder_Union(PtA, PtB, Radius, EdgeRadius),
Round_Cylinder_Merge(PtA, PtB, Radius, EdgeRadius),
Round_Cylinder(PtA, PtB, Radius, EdgeRadius, UseMerge): Creates a cylinder with rounded edges from cylinders and tori. The resulting object will fit entirely within a cylinder object with the same end points and radius. The result is slightly different from a superellipsoid, which has no truely flat areas.
Parameters:
PtA, PtB = The end points of the cylinder.Radius = The radius of the cylinder.EdgeRadius = The radius of the edges of the cylinder.UseMerge = Whether or not to use a merge.Round_Cone_Union(PtA, RadiusA, PtB, RadiusB, EdgeRadius),
Round_Cone_Merge(PtA, RadiusA, PtB, RadiusB, EdgeRadius),
Round_Cone(PtA, RadiusA, PtB, RadiusB, EdgeRadius, UseMerge): Creates a cone with rounded edges from cones and tori. The resulting object will fit entirely within a cone object with the same end points and radii.
Parameters:
PtA, PtB = The end points of the cone.RadiusA, RadiusB = The radii of the cone.EdgeRadius = The radius of the edges of the cone.UseMerge = Whether or not to use a merge.Round_Cone2_Union(PtA, RadiusA, PtB, RadiusB),
Round_Cone2_Merge(PtA, RadiusA, PtB, RadiusB),
Round_Cone2(PtA, RadiusA, PtB, RadiusB, UseMerge): Creates a cone with rounded edges from a cone and two spheres. The resulting object will not fit entirely within a cone object with the same end points and radii because of the spherical caps. The end points are not used for the conical portion, but for the spheres, a suitable cone is then generated to smoothly join them.
Parameters:
PtA, PtB = The centers of the sphere caps.RadiusA, RadiusB = The radii of the sphere caps.UseMerge = Whether or not to use a merge.Round_Cone3_Union(PtA, RadiusA, PtB, RadiusB),
Round_Cone3_Merge(PtA, RadiusA, PtB, RadiusB),
Round_Cone3(PtA, RadiusA, PtB, RadiusB, UseMerge): Like Round_Cone2(), this creates a cone with rounded edges from a cone and two spheres, and the resulting object will not fit entirely within a cone object with the same end points and radii because of the spherical caps. The difference is that this macro takes the end points of the conical portion and moves the spheres to be flush with the surface, instead of putting the spheres at the end points and generating a cone to join them.
Parameters:
PtA, PtB = The end points of the cone.RadiusA, RadiusB = The radii of the cone.UseMerge = Whether or not to use a merge.Quad(A, B, C, D) and Smooth_Quad(A, NA, B, NB, C, NC, D, ND): These macros create quads, 4-sided polygonal objects, using triangle pairs.
Parameters:
A, B, C, D = Vertices of the quad.NA, NB, NC, ND = Vertex normals of the quad.There are several HF macros in shapes.inc, which generate meshes in various shapes. All the HF macros have these things in common:
The usage of the different HF macros is described below.
HF_Square (Function, UseUVheight, UseUVtexture, Res, Smooth, FileName, MnExt, MxExt): This macro generates a mesh in the form of a square height field, similar to the built-in height_field primitive. Also see the general description of the HF macros above.
Parameters:
Function = The function to use for deforming the height field.UseUVheight = A boolean value telling the macro whether or not to use UV height mapping.UseUVtexture = A boolean value telling the macro whether or not to use UV texture mapping.Res = A 2D vector specifying the resolution of the generated mesh.Smooth = A boolean value telling the macro whether or not to smooth the generated mesh.FileName = The name of the output file.MnExt = Lower-left-front corner of a box containing the height field.MxExt = Upper-right-back corner of a box containing the height field.HF_Sphere(Function, UseUVheight, UseUVtexture, Res, Smooth, FileName, Center, Radius, Depth): This macro generates a mesh in the form of a spherical height field. When UV-mapping is used, the UV square will be wrapped around the sphere starting at +x and going anti-clockwise around the y axis. Also see the general description of the HF macros above.
Parameters:
Function = The function to use for deforming the height field.UseUVheight = A boolean value telling the macro whether or not to use UV height mapping.UseUVtexture = A boolean value telling the macro whether or not to use UV texture mapping.Res = A 2D vector specifying the resolution of the generated mesh.Smooth = A boolean value telling the macro whether or not to smooth the generated mesh.FileName = The name of the output file.Center = The center of the height field before being displaced, the displacement can, and most likely will, make the object off-center.Radius = The starting radius of the sphere, before being displaced.Depth = The depth of the height field.HF_Cylinder(Function, UseUVheight, UseUVtexture, Res, Smooth, FileName, EndA, EndB, Radius,Depth): This macro generates a mesh in the form of an open-ended cylindrical height field. When UV-mapping is used, the UV square will be wrapped around the cylinder. Also see the general description of the HF macros above.
Parameters:
Function = The function to use for deforming the height field.UseUVheight = A boolean value telling the macro whether or not to use UV height mapping.UseUVtexture = A boolean value telling the macro whether or not to use UV texture mapping.Res = A 2D vector specifying the resolution of the generated mesh.Smooth = A boolean value telling the macro whether or not to smooth the generated mesh.FileName = The name of the output file.EndA, EndB = The end points of the cylinder.Radius = The (pre-displacement) radius of the cylinder.Depth = The depth of the height field.HF_Torus (Function, UseUVheight, UseUVtexture, Res, Smooth, FileName, Major, Minor, Depth): This macro generates a mesh in the form of a torus-shaped height field. When UV-mapping is used, the UV square is wrapped around similar to spherical or cylindrical mapping. However the top and bottom edges of the map wrap over and under the torus where they meet each other on the inner rim. Also see the general description of the HF macros above.
Parameters:
Function = The function to use for deforming the height field.UseUVheight = A boolean value telling the macro whether or not to use UV height mapping.UseUVtexture = A boolean value telling the macro whether or not to use UV texture mapping.Res = A 2D vector specifying the resolution of the generated mesh.Smooth = A boolean value telling the macro whether or not to smooth the generated mesh.FileName = The name of the output file.Major = The major radius of the torus.Minor = The minor radius of the torus.TetrahedronOctahedronDodecahedronIcosahedronRhomboidHexagonHalfCone_YPyramidPyramid2Square_X, Square_Y, Square_ZThis file contains macros for segments of shapes, facetted shapes and others.
Segments of shapes:
Segment_of_Torus ( R_major, R_minor, Segment_Angle )Segment_of_CylinderRing ( R_out, R_in, Height, Segment_Angle )Segment_of_Object ( Segment_Object, Segment_Angle )Angular shapes:
Column_N (N, R_in, Height )R_in. Height is the height in y direction.Column_N_AB (N, A, B, R_in)A to point B, defined by the incircle radius R_in.Pyramid_N (N, R_in_1, R_in_2, Height )R_in_1 at y = 0 and R_in_2 at y = Height.Pyramid_N_AB(N, A, R_in_A, B, R_in_B)A to point B,
defined by the incircle radii:R_in_A at point A and R_in_B at point B.Facetted shapes:
Facetted_Sphere (Quarter_Segments, Radial_Segments)Quarter_Segments = number of equitorial facetts in one quarter (1/2 of the total number).Radial_Segments = number of radial facetts.Facetted_Egg_Shape (Quarter_Segments, Radial_Segments, Lower_Scale, Upper_Scale)Facetted_Egg_Shape().Lower_Scale,
Upper half scaled in y by Upper_Scale.Facetted_Egg (N_Quarter_Segments, N_Radial_Segments)Round shapes:
Egg_Shape (Lower_Scale, Upper_Scale)Lower_Scale,
Upper half scaled in y by Upper_Scale.EggRing_Sphere (Rmaj_H, Rmaj_V, Rmin_H, Rmin_V, Number_of_Rings_horizontal, Number_of_Rings_vertical)Rmaj_H, radius minor Rmin_H.Rmaj_V, radius minor Rmin_V.Round_Pyramid_N_out (N, A, CornerR_out_A, B, CornerR_out_B, R_Border, Filled, Merge )A to point B,
defined by the outcircle radii:
R_in_A at point A and R_in_B at point B.Round_Pyramid_N_in (N, A, FaceR_in_A, B, FaceR_in_B, R_Border, Filled, Merge_On )A to point B,
defined by the incircle radii:
R_in_A at point A and R_in_B at point B..Round_Cylinder_Tube( A, B, R_out, R_border, Filled, Merge)A to point B,
with the outer radius R_out and the border radius R_border.
The inner radius is R_out - R_border.Filled = 1 we get a Round_Cylinder.Rounded_Tube( R_out, R_in, R_Border, Height, Merge)Height in y, with the outer radius R_out, the inner radius R_in and the radius of the rounded borders R_border.Rounded_Tube_AB( A, B, R_out, R_in, R_Border, Merge)A to point B.R_out, the inner radius is R_in
and the radius of the rounded borders is R_border.Round_Conic_Torus( Center_Distance, R_upper, R_lower, R_border, Merge)R_lower,
the radius of the lower part is R_lower
The minor radius of the toroid is R_border.Round_Conic_Prism( Center_Distance, R_upper, R_lower, Length_Zminus, R_Border, Merge)Round_Conic_Torus(),
but filled and in the negativ z direction with the length Length_Zminus.Half_Hollowed_Rounded_Cylinder1( Length, R_out, R_border, BorderScale, Merge)Length in x, of the outer radius R_out, with round ends.
The borders have a minor radius R_border with the scale in y BorderScale.R_out - R_border.Half_Hollowed_Rounded_Cylinder2( Length, R_out, R_corner, R_border, BorderScale, Merge)Length in x, of the outer radius R_out, with flat ends.
The corners have a minor radius of R_corner,
the borders have a minor radius of R_border with the scale in y BorderScale.R_out - R_border, the inner lenght is Length - 2*R_border.Round_N_Tube_Polygon (N, Tube_R, R_incircle, Edge_R, Filled, Merge)N edges (or corners) with incircle radius R_incircle,
formed by a tube with the minor radius Tube_R.
The corners are formed by torus segments with the major radius Edge_R.BicornCrossed_TroughCubic_CylinderCubic_Saddle_1Devils_CurveFoliumGlob_5Twin_GlobHelix, Helix_1Hyperbolic_TorusLemniscateQuartic_Loop_1Monkey_Saddlez = c (x^3 - 3 x y^2)Parabolic_Torus_40_12PiriformQuartic_ParaboloidQuartic_CylinderSteiner_SurfaceTorus_40_12Witch_HatSinsurfThese files contain some predefined skies for you to use in your scenes.
skies.inc: There are textures and pigment definitions in this file.
Pigments:
P_Cloud1P_Cloud2P_Cloud3Sky Spheres:
S_Cloud1S_Cloud2S_Cloud3S_Cloud4S_Cloud5Textures:
T_Cloud1T_Cloud2T_Cloud3Objects:
O_Cloud1O_Cloud2stars.inc: This file contains predefined starfield textures. The starfields become denser and more colorful with the number, with Starfield6 being the densest and most colorful.
Starfield1Starfield2Starfield3Starfield4Starfield5Starfield6The file stones.inc simply includes both stones1.inc and stones2.inc, and the file stoneold.inc provides backwards compatability for old scenes, the user is advised to use the textures in stones1.inc instead.
The two files stones1.inc and stones2.inc contain lists of predefined stone textures.
The file stones1.inc contains texture definitions for:
The T_GrntXX, T_GrntXXa, and CrackX textures are building blocks that are used to create the final usable T_StoneX textures (and other textures that *you* design, of course!)
The T_GrntXX textures generally contain no transparency, but the T_GrntXXa textures DO contain transparency. The CrackX textures are clear with thin opaque bands, simulating cracks.
The file stones2.inc provides additional stone textures, and contains texture definitions for T_Stone25 to T_Stone44.
This file simply includes the most commonly used include files, so you can get all of them with a single #include. The files included are:
This include contains macros for manipulating and generating text strings.
CRGBStr(C, MinLen, Padding) and CRGBFTStr(C, MinLen, Padding): These macros convert a color to a string. The format of the output string is "rgb < R, G, B>" or "rgbft < R, G, B, F, T>", depending on the macro being called.
Parameters:
C = The color to be turned into a string.MinLen = The minimum length of the individual components, analogous to the second parameter of str().Padding = The padding to use for the components, see the third parameter of the str() function for details.Str(A): This macro creates a string containing a float with the systems default precision. It is a shortcut for using the str() function.
Parameters:
A = The float to be converted to a string.VStr2D(V), VStr(V): These macros create strings containing vectors using POV syntax (<X,Y,Z>) with the default system precision. VStr2D() works with 2D vectors, VStr() with 3D vectors. They are shortcuts for using the vstr() function.
Parameters:
V = The vector to be converted to a string.Vstr2D(V,L,P), Vstr(V,L,P): These macros create strings containing vectors using POV syntax (<X,Y,Z>) with user specified precision. Vstr2D() works with 2D vectors, Vstr() with 3D vectors. They are shortcuts for using the vstr() function. The function of L and P is the same as in vstr specified in String Functions.
Parameters:
V = The vector to be converted to a string.L = Minimum length of the string and the type of left padding used if the string's representation is shorter than the minimum.P = Number of digits after the decimal point.Triangle_Str(A, B, C) and Smooth_Triangle_Str(A, NA, B, NB, C, NC): These macros take vertex and normal information and return a string representing a triangle in POV-Ray syntax. They are mainly useful for generating mesh files.
Parameters:
A, B, C = Triangle vertex points.NA, NB, NC = Triangle vertex normals (Smooth_Triangle_Str() only).Parse_String(String): This macro takes a string, writes it to a file, and then includes that file. This has the effect of parsing that string: "Parse_String("MyColor")" will be seen by POV-Ray as "MyColor".
Parameters:
String = The string to be parsed.This file only contains the sunpos() macro
sunpos(Year, Month, Day, Hour, Minute, Lstm, LAT, LONG): The macro returns the position of the sun, for a given date, time, and location on earth. The suns position is also globally declared as the vector SolarPosition. Two other declared vectors are the Az (Azimuth) and Al (Altitude), these can be useful for aligning an object (media container) with the sunlight. Assumption: in the scene north is in the +Z direction, south is -Z.
Parameters:
Year= The year in four digits.Month= The month number (1-12).Day= The day number (1-31).Hour= The hour of day in 24 hour format (0-23).Minute= The minutes (0-59). Lstm= Meridian of your local time zone in degrees (+1 hour = +15 deg, east = positive, west = negative)LAT= Lattitude in degrees.decimal, northern hemisphere = positive, southern = negativeLONG= Longitude in degrees.decimal, east = positive, west is negativeUsage:
#include "sunpos.inc"
light_source {
//Greenwich, noon on the longest day of 2000
SunPos(2000, 6, 21, 12, 2, 0, 51.4667, 0.00)
rgb 1
}
cylinder{
<-2,0,0>,<2,0,0>,0.1
rotate <0, Az-90, Al> //align cylinder with sun
texture {...}
}
Note: The default distance of the sun from the origin is 1e+9 units.
This file contains many predefined textures, including wood, glass, and metal textures, and a few texture/pattern generation macros.
Stone Pigments:
Jade_Map, JadeRed_Marble_Map, Red_MarbleWhite_Marble_Map, White_MarbleBlood_Marble_Map, Blood_MarbleBlue_Agate_Map, Blue_AgateSapphire_Agate_Map, Sapphire_AgateBrown_Agate_Map, Brown_AgatePink_Granite_Map, Pink_GraniteStone textures:
PinkAlabasterNote: This texture has very tiny dark blue specks that are often mistaken for rendering errors.
Sky pigments:
Blue_Sky_Map, Blue_SkyBright_Blue_SkyBlue_Sky2Blue_Sky3Blood_SkyApocalypseCloudsFBM_CloudsShadow_CloudsWood pigments:
Several wooden pigments by Tom Price:
Cherry_WoodPine_WoodDark_WoodTan_WoodWhite_WoodTom_WoodDMFWood1, DMFWood2, DMFWood3, DMFWood4, DMFWood5Note: These wood definitions are functionally equivalent to a log lying along the z axis. For best results, think like a woodcutter trying to extract the nicest board out of that log. A little tilt along the x axis will give elliptical rings of grain like you would expect to find on most boards.
Wood textures:
DMFWood6DMFLightOakDMFDarkOakEMBWood1Doug Otwell woods:
Yellow_PineRosewoodSandalwoodGlass_Finish is a generic glass finish, Glass_Interior is a generic glass interior, it just adds an ior of 1.5.
Glass materials:
M_GlassM_Glass2M_Glass3M_Green_GlassGlass textures contributed by Norm Bowler, of Richland WA. NBglass_finish is used by these materials.
M_NBglassM_NBoldglassM_NBwinebottleM_NBbeerbottleA few color variations on Norm's glass.
M_Ruby_GlassM_Dark_Green_GlassM_Yellow_GlassM_Orange_GlassM_Vicks_Bottle_GlassMetal finishes:
MetalSilverFinishMetallic_FinishMetal textures:
Chrome_Metal, Brass_Metal, Bronze_Metal, Gold_Metal, Silver_Metal, Copper_MetalPolished_ChromePolished_BrassNew_BrassSpun_BrassBrushed_AluminumSilver1Silver2Silver3Brass_ValleyRustRusty_IronSoft_SilverNew_PennyTinny_BrassGold_NuggetAluminumBright_BronzeCandy_CanePeelY_GradientX_GradientM_WaterWarning: Water texture has been changed to M_Water material, see explanation in the glass section of this file.
CorkLightning_CMap1, Lightning1, and Lightning_CMap2, Lightning2StarfieldIrregular_Bricks_Ptrn (Mortar Thickness, X-scaling, Variation, Roundness): This function pattern creates a pattern of bricks of varying lengths on the x-y plane. This can be useful in building walls that do not look like they were built by a computer. Note that mortar thickness between bricks can vary somewhat, too.
Parameters:
Mortar Thickness = Thickness of the mortar (0-1).X-scaling = The scaling of the bricks (but not the mortar) in the x direction.Variation = The amount by which brick lengths will vary (0=none, 1=100%).Roundness = The roundness of the bricks (0.01=almost rectangular, 1=very round).Tiles_Ptrn(): This macro creates a repeating box pattern on the x-y plane. It can be useful for creating grids. The cells shade continuously from the center to the edges.
Parameters: None.
Hex_Tiles_Ptrn(): This macro creates a pattern that is a sort of cross between the hexagon pattern and a repeating box pattern. The hexagonal cells shade continuously from the center to the edges.
Parameters: None.
Star_Ptrn (Radius, Points, Skip): This macro creates a pattern that resembles a star. The pattern is in the x-y plane, centered around the origin.
Parameters:
Radius = The radius of a circle drawn through the points of the star.Points = The number of points on the star.Skip = The number of points to skip when drawing lines between points to form the star.
A normal 5-pointed star skips 2 points. A Star of David also skips 2 points. Skip
must be less than Points/2 and greater than 0. Integers are preferred but not
required. Skipping 1 point makes a regular polygon with Points sides.Pigment = The pigment to be applied to the star.Background = The pigment to be applied to the background.Several useful transformation macros. All these macros produce transformations, you can use them anywhere you can use scale, rotate, etc. The descriptions will assume you are working with an object, but the macros will work fine for textures, etc.
Shear_Trans(A, B, C): This macro reorients and deforms an object so its original XYZ axes point along A, B, and C, resulting in a shearing effect when the vectors are not perpendicular. You can also use vectors of different lengths to affect scaling, or use perpendicular vectors to reorient the object.
Parameters:
A, B, C = Vectors representing the new XYZ axes for the transformation.Matrix_Trans(A, B, C, D): This macro provides a way to specify a matrix transform with 4 vectors. The effects are very similar to that of the Shear_Trans() macro, but the fourth parameter controls translation.
Parameters:
A, B, C, D = Vectors for each row of the resulting matrix.Axial_Scale_Trans(Axis, Amt): A kind of directional scale, this macro will stretch an object along a specified axis.
Parameters:
Axis = A vector indicating the direction to stretch along.Axis_Rotate_Trans(Axis, Angle): This is equivalent to the transformation done by the vaxis_rotate() function, it rotates around an arbitrary axis.
Parameters:
Axis = A vector representing the axis to rotate around.Angle = The amount to rotate by.Rotate_Around_Trans(Rotation, Point): Ordinary rotation operates around the origin, this macro rotates around a specific point.
Parameters:
Rotation = The rotation vector, the same as the parameter to the rotate keyword.Point = The point to rotate around.Reorient_Trans(Axis1, Axis2): This aligns Axis1 to Axis2 by rotating the object around a vector perpendicular to both axis1 and axis2.
Parameters:
Axis1 = Vector to be rotated.Axis2 = Vectors to be rotated towards.Point_At_Trans(YAxis): This macro is similar to Reorient_Trans(), but it points the y axis along Axis.
Parameters:
YAxis = The direction to point the y axis in.Center_Trans(Object, Axis): Calculates a transformation which will center an object along a specified axis. You indicate the axes you want to center along by adding "x", "y", and "z" together in the Axis parameter.
Note: This macro actually computes the transform to center the bounding box of the object, which may not be entirely accurate. There is no way to define the center of an arbitrary object.
Parameters:
Object = The object the center transform is being computed for.Axis = The axes to center the object on.Usage:
object {MyObj Center_Trans(MyObj, x)} //center along x axis
You can also center along multiple axes:
object {MyObj Center_Trans(MyObj, x+y)} //center along x and y axis
Align_Trans(Object, Axis, Pt): Calculates a transformation which will align the sides of the bounding box of an object to a point. Negative values on Axis will align to the sides facing the negative ends of the coordinate system, positive values will align to the opposite sides, 0 means not to do any alignment on that axis.
Parameters:
Object = The object being aligned.Axis = A combination of +x, +y, +z, -x, -y, and -z, or a vector where each component is -1, 0, or +1 specifying the faces of the bounding box to align to the point.Point = The point to which to align the bounding box of the object.Usage:
object {
MyObj
Align_Trans(MyObj, x, Pt) //Align right side of object to be
//coplanar with Pt
Align_Trans(MyObj,-y, Pt) //Align bottom of object to be
// coplanar with Pt
}
vtransform(Vect, Trans) and vinv_transform(Vect, Trans): The vtransform() macro takes a transformation (rotate, scale, translate, etc...) and a point, and returns the result of applying the transformation to the point. The vinv_transform() macro is similar, but applies the inverse of the transform, in effect undoing the transformation. You can combine transformations by enclosing them in a transform block.
Parameters:
Vect = The vector to which to apply the transformation.Trans = The transformation to apply to Vect.Spline_Trans(Spline, Time, SkyVector, ForeSight, Banking): This macro aligns an object to a spline for a given time value. The Z axis of the object will point in the forward direction of the spline and the Y axis of the object will point upwards.
Parameters:
Spline = The spline that the object is aligned to.Time = The time value to feed to the spline, for example clock.Sky = The vector that is upwards in your scene, usually y.Foresight = A positive value that controls how much in advance the object will turn and bank. Values close to 0 will give precise results, while higher values give smoother results. It will not affect parsing speed, so just find the value that looks best.Banking = How much the object tilts when turning. The amount of tilting is equally much controlled by the ForeSight value.Usage:
object {MyObj Spline_Trans(MySpline, clock, y, 0.1, 0.5)}
The file woods.inc contains predefined wood textures and pigments.
The pigments are prefixed with P_, and do not have color_maps, allowing you to specify a color map from woodmaps.inc or create your own. There are two groups, "A" and "B": the A series is designed to work better on the bottom texture layer, and the B series is designed for the upper layers, with semitransparent color maps. The pigments with the same number were designed to work well together, but you do not necessarily have to use them that way.
The textures are prefixed with T_, and are ready to use. They are designed with the major axis of the woodgrain cylinder aligned along the Z axis. With the exception of the few of the textures which have a small amount of rotation built-in, the textures will exhibit a very straight grain pattern unless you apply a small amount of x-axis rotation to them (generally 2 to 4 degrees seems to work well).
Pigments:
P_WoodGrain1A, ..., P_WoodGrainAP_WoodGrain1B, ..., P_WoodGrainBTextures:
T_Wood1T_Wood2T_Wood3T_Wood4T_Wood5T_Wood6T_Wood7T_Wood8T_Wood9T_Wood10T_Wood11T_Wood12T_Wood13T_Wood14T_Wood15T_Wood16T_Wood17T_Wood18T_Wood19, ..., T_Wood30T_Wood31T_Wood32T_Wood33T_Wood34T_Wood35The file woodmaps.inc contains color_maps designed for use in wood textures. The M_WoodXA maps are intended to be used in the first layer of a multilayer texture, but can be used in single-layer textures. The M_WoodXB maps contain transparent areas, and are intended to be used in upper texture layers.
Color maps:
M_Wood1A, ..., M_Wood19AM_Wood1B, ..., M_Wood19BThese files could be considered either obsolete or deprecated. They have been included for legacy reasons.
This file contains glass textures for POV-Ray versions 3.1 and earlier. These textures do not take advantage of the new features introduced with POV-Ray 3.5 and are included for backwards compatability, you will get better results with the materials in glass.inc.
Note: As of version 3.7 the definitions in glass_old.inc have been deprecated. To suppress warnings generated from using these textures you should consider converting them to materials.
Using the following example:
texture {T_Glass4} interior {I_Glass caustics 1}
should be rewritten as:
material {
texture {
pigment { color rgbf <0.98, 1.0, 0.99, 0.75> }
finish { F_Glass4 }
}
interior { I_Glass caustics 1 }
}
F_Glass1, ..., F_Glass4
T_Glass1T_Glass2T_Glass3T_Glass4T_Old_GlassT_Winebottle_GlassT_Beerbottle_GlassT_Ruby_GlassT_Green_GlassT_Dark_Green_GlassT_Yellow_GlassT_Orange_GlassT_Vicksbottle_GlassEllipsoid, SphereCylinder_X, Cylinder_Y, Cylinder_ZQCone_X, QCone_Y, QCone_ZCone_X, Cone_Y, Cone_ZPlane_YZ, Plane_XZ, Plane_XYParaboloid_X, Paraboloid_Y, Paraboloid_ZHyperboloid, Hyperboloid_YUnitBox, CubeDisk_X, Disk_Y, Disk_ZThis file simply contains a camera, a light_source, and a ground plane, and includes colors.inc, textures.inc, and shapes.inc.
This file simply contains a camera, a light_source, and a ground plane.
T_Grnt0T_Grnt1T_Grnt2T_Grnt3T_Grnt4T_Grnt5T_Grnt6T_Grnt7T_Grnt8T_Grnt9T_Grnt10T_Grnt11T_Grnt12T_Grnt13T_Grnt14T_Grnt15T_Grnt16T_Grnt17T_Grnt18T_Grnt19T_Grnt20T_Grnt21T_Grnt22T_Grnt23T_Grnt24T_Grnt25T_Grnt26T_Grnt27T_Grnt28T_Grnt29T_Grnt0aT_Grnt1aT_Grnt2aT_Grnt3aT_Grnt4aT_Grnt5aT_Grnt6aT_Grnt7aT_Grnt8aT_Grnt9aT_Grnt10aT_Grnt11aT_Grnt12aT_Grnt13aT_Grnt14aT_Grnt15aT_Grnt16aT_Grnt17aT_Grnt18aT_Grnt19aT_Grnt20aT_Grnt21aT_Grnt22aT_Grnt23aT_Grnt24aT_Crack1T_Crack2T_Crack3T_Crack4The StoneXX textures are the complete textures, ready to use.
T_Stone1T_Stone2T_Stone3T_Stone4T_Stone5T_Stone6T_Stone7T_Stone8T_Stone9T_Stone10T_Stone11T_Stone12T_Stone13T_Stone14T_Stone15T_Stone16T_Stone17T_Stone18T_Stone19T_Stone20T_Stone21T_Stone22T_Stone23T_Stone24T_Stone25, ..., T_Stone44
There are various other files in the include files collection. For example font files, color maps, and images for use in height fields or image maps.
The fonts cyrvetic.ttf and timrom.ttf were donated to the POV-Team by their creator, Ted Harrison (CompuServe:70220,344) and were built using his FontLab for Windows by SoftUnion, Ltd. of St. Petersburg, Russia.
The font crystal.ttf was donated courtesy of Jerry Fitzpatrick, Red Mountain Corporation, redmtn [at] ix.netcom.com
The font povlogo.ttf is created by Fabien Mosen and based on the POV-Ray logo design by Chris Colefax.
crystal.ttfcyrvetic.ttftimrom.ttfpovlogo.ttfNote: In version 3.7 these fonts were built-in to the application. See the text object for more details.
These are 255-color color_maps, and are in individual files because of their size.
ash.mapbenediti.mapbubinga.mapcedar.mapmarbteal.maporngwood.mappinkmarb.maprdgranit.mapteak.mapwhiteash.mapbumpmap_.pngfract003.pngmaze.pngmtmand.potmtmandj.pngplasma2.png, plasma3.pngpovmap.pngtest.pngspiral.df3