|
 |
Below is the source code for an image I posted 4. June to the
povray.binaries.images news group.
The last macros may be a little non intuitive to use and I'm
working on them to make them easier to use.
Note that many of the macros below are "work in progress" and
therefore I haven't yet optimized them for speed or compactness.
Tor Olav
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
// Copyright 2000 by Tor Olav Kristensen
// mailto:tor### [at] hotmail com
// http://www.crosswinds.net/~tok/tokrays.html
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
#version 3.1;
#include "colors.inc"
global_settings { ambient_light 1.2 }
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
// First some "standard" geometry macros
// Returns projection of vector in direction of other vector
#macro vproject(UU, VV)
(VV*vdot(UU, VV)/vdot(VV, VV))
#end // macro vproject
// Point To Plane
// Returns projection of point to plane
#macro pt2pl(pPoint, pPlane, vPlane)
(pPoint - vproject(pPoint - pPlane, vPlane))
#end // macro pt2pl
// Point To Line
// Returns projection of point to line
#macro pt2ln(pPoint, pLine, vLine)
(pLine + vproject(pPoint - pLine, vLine))
#end // macro pt2ln
// Line To Plane
// Returns intersection of line and plane
#macro ln2pl(pLine, vLine, pPlane, vPlane)
(pLine + vLine*vdot(pPlane - pLine, vPlane)/vdot(vLine, vPlane))
#end // macro ln2pl
// Plane To Plane
// Calculates line in intersection of two planes
#macro pl2pl(pPlane1, vPlane1, pPlane2, vPlane2, pLine, vLine)
#declare vLine = vcross(vPlane1, vPlane2);
#local vInPlane2 = vcross(vLine, vPlane2);
#declare pLine = ln2pl(pPlane2, vInPlane2, pPlane1, vPlane1);
#end // macro pl2pl
// Returns object tilted in direction of vector
#macro Tilt(Thing, Vector)
#local xAngle = (Vector.z < 0 ? -1 : 1)*
degrees(acos(vnormalize((x + z)*Vector).x));
#local yAngle = degrees(acos(vnormalize(Vector).y));
object {
Thing
rotate xAngle*y
rotate -yAngle*z
rotate -xAngle*y
}
#end // macro Tilt
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
// Some macros to generate lathes from arrays of 2D-points
#macro InsertPoints(PointArray)
#local NrOfPoints = dimension_size(PointArray, 1);
#local PtCnt = 0;
#while (PtCnt < NrOfPoints)
PointArray[PtCnt],
#local PtCnt = PtCnt + 1;
#end // while
#end // macro InsertPoints
#macro LinearLathe(PointArray)
lathe {
linear_spline
dimension_size(PointArray, 1) + 1,
InsertPoints(PointArray)
PointArray[0]
}
#end // macro LinearLathe
#macro QuadraticLathe(PointArray)
lathe {
quadratic_spline
dimension_size(PointArray, 1) + 2,
InsertPoints(PointArray)
PointArray[0],
PointArray[1]
}
#end // macro QuadraticLathe
#macro CubicLathe(PointArray)
lathe {
cubic_spline
dimension_size(PointArray, 1) + 3,
InsertPoints(PointArray)
PointArray[0],
PointArray[1],
PointArray[2]
}
#end // macro CubicLathe
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
// A macro to generate array of 2D-points that can be used
// to make torus-like lathes where the minor radius varies
// according to a "wave function", which is declared later.
#macro CalcLatheTorus(PointArray, Angle,
MajorRadius, MinorRadius, ModRadius)
#local NrOfPts = dimension_size(PointArray, 1);
#local dPhi = 2*pi/NrOfPts;
#local PtCnt = 0;
#while (PtCnt < NrOfPts)
#local Phi = PtCnt*dPhi;
#local WaveRadius = ModRadius*WaveFunction(Phi);
#declare PointArray[PtCnt] = MajorRadius*u +
(MinorRadius + WaveRadius)*
<cos(Angle), sin(Angle)>;
#local PtCnt = PtCnt + 1;
#local Angle = Angle + dPhi;
#end
#end // macro CalcLatheTorus
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
// And then the macros that generates all the
// different lathe segments and assembles them.
#macro v2Dir(v2D, vBasis1, vBasis2)
(v2D.u*vnormalize(vBasis1) + v2D.v*vnormalize(vBasis2))
#end // macro v2Dir
#macro New3DCoord(LatheArray, PointArray, pRef, vSd, vFw)
#local NrOfPts = dimension_size(PointArray, 1);
#local Cnt = 0;
#while (Cnt < NrOfPts)
#declare PointArray[Cnt] = pRef + v2Dir(LatheArray[Cnt], vSd, vFw);
#local Cnt = Cnt + 1;
#end // while
#end // macro NewCoord
#macro Lathe2DCoord(pSwp, pLine, vLine)
#local pHit = pt2ln(pSwp, pLine, vLine);
#local vForw = pHit - pLine;
#local vSide = pSwp - pHit;
#local Sign = (vdot(vForw, vLine) < 0 ? -1 : 1);
<vlength(vSide), Sign*vlength(vForw)>
#end // macro Lathe2DCoord
#macro ShiftLathe(LatheType, PointArray, pRef,
pPlane1, vPlane1,
pPlane2, vPlane2)
#local pLine = <0, 0, 0>;
#local vLine = <0, 0, 0>;
pl2pl(pPlane1, vPlane1, pPlane2, vPlane2, pLine, vLine)
#declare pRef = pt2ln(pRef, pLine, vLine);
#local vFw = vnormalize(vLine);
#local vSd = vnormalize(vcross(vPlane2, vFw));
#local NrOfPts = dimension_size(PointArray, 1);
#local LatheArray = array[NrOfPts]
#local Cnt = 0;
#while (Cnt < NrOfPts)
#local LatheArray[Cnt] = Lathe2DCoord(PointArray[Cnt], pRef, vFw);
#declare PointArray[Cnt] = pRef + v2Dir(LatheArray[Cnt], vSd, vFw);
#local Cnt = Cnt + 1;
#end // while
New3DCoord(LatheArray, PointArray, pRef, vSd, vFw)
#switch (LatheType)
#case (1)
#local Lathe = LinearLathe(LatheArray)
#break
#case (2)
#local Lathe = QuadraticLathe(LatheArray)
#break
#case (3)
#local Lathe = CubicLathe(LatheArray)
#break
#else
#debug "Macro ShiftLathe: Wrong lathe type"
#end
intersection {
Tilt(Lathe, vFw)
plane { -vPlane1, 0 } // Look here to learn how to select "signs"
plane { vPlane2, 0 } // for the plane normals in the plane array.
translate pRef
}
#end // macro ShiftLathe
#macro LatheSway(LatheArray, pRef, PlaneArray, LatheType)
#local PointArray = array [dimension_size(LatheArray, 1)]
#local vFw = vnormalize(vcross(PlArray[0][1], PlArray[1][1]));
#local vSd = vnormalize(vcross(vFw, PlArray[0][1]));
New3DCoord(LatheArray, PointArray, pRef, vSd, vFw)
merge {
#declare PlCnt = 1;
#while (PlCnt < dimension_size(PlArray, 1))
ShiftLathe(LatheType, PointArray, pRef,
PlArray[PlCnt - 1][0], PlArray[PlCnt - 1][1],
PlArray[PlCnt - 0][0], PlArray[PlCnt - 0][1])
#declare PlCnt = PlCnt + 1;
#end // while
}
#end // macro LatheSway
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
// Now have fun.
#macro WaveFunction(Phi)
(2/3*cos(4*Phi) - 1/3*sin(6*Phi - pi/2))
#end // macro WaveFunction
#declare LathePoints = array[96]
CalcLatheTorus(LathePoints, pi/2, 12, 2, 8)
/*
#macro WaveFunction(Phi)
cos(6*Phi)
#end // macro WaveFunction
#declare LathePoints = array[72]
CalcLatheTorus(LathePoints, pi/12, 10, 6, 1)
*/
// The planes below:
// plane { PlArray[n][1], 0 translate PlArray[n][0] }
//
// Note: Changing the "sign" of each normal vector
// gives different CSG-results
#declare PlArray =
array[6][2] {
{ < 20, 0, 0>, <-2, 1, 0> },
{ < 0, 0, -10>, < 0, 1, 1> },
{ <-20, 0, 0>, <-2, -1, 0> },
{ < 0, 20, 0>, < 0, 1, 0> },
{ < 0, 24, 0>, < 0, 1, -3> },
{ < 0, 40, 0>, < 0, 1, 0> }
}
// Just a quick and dirty way to select a
// first reference point in the first plane
#declare pFirstRef = pt2pl(<2, 2, 2>, PlArray[0][0], PlArray[0][1]);
// Could also have written
//#declare pFirstRef = <17.2, -5.6, 2.0>;
#declare Sway = LatheSway(LathePoints, pFirstRef, PlArray, 3)
// Then use symmetry to cheat a little bit
union {
object {
Sway
translate -40*y
}
object {
Sway
translate -40*y
scale <1, -1, 1>
}
rotate 90*x
pigment { color Red }
}
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
/*
// A much simpler lathe shape in the XZ-plane
// Use other camera position to view
#macro WaveFunction(Phi)
0
#end // macro WaveFunction
#declare LathePoints = array[5]
CalcLatheTorus(LathePoints, pi/10, 24, 6, 0)
// Example of manually entered array of 2D-points for lathe:
//#declare LathePoints =
//array[4] {
// <24, 0> + 4*<1, 0>,
// <24, 0> + 4*<0, 1>,
// <24, 0> - 4*<1, 0>,
// <24, 0> - 4*<0, 1>
//}
#declare PlArray =
array[9][2] {
{ 20*x, x },
{ 20*z, z },
{ 20*x, -x },
{ 20*z, -z },
{ -20*x, -x },
{ -20*z, -z },
{ -20*x, x },
{ -20*z, z },
{ 20*x, x }
}
#declare pFirstRef = 18*(x + z);
#declare SimpleSway = LatheSway(LathePoints, pFirstRef, PlArray, 2)
object {
SimpleSway
// rotate 45*y
translate 20*y
pigment { color Cyan }
}
*/
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
sky_sphere { pigment { color Grey } }
#declare AreaLight =
light_source {
100*y,
color White
area_light 10*x, 10*z, 3, 3
jitter
}
Tilt(AreaLight, <-1, sqrt(2), 1>)
Tilt(AreaLight, -y)
#declare CameraPos = 60*<-2, 0.4, 0.6>;
//#declare CameraPos = 60*<-2, 1, 0.6>;
//#declare CameraPos = 70*<0, 2, -1/100>;
//light_source { CameraPos color 0.7*White }
camera {
location CameraPos
look_at <0, -10, 0>
}
// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7
Post a reply to this message
|
|
