// ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 // POV-Ray SDL file with macros for working with perspective cameras // Copyright 2016 by Tor Olav Kristensen // Email: t o r . o l a v . k [_A_T_] g m a i l . c o m // http://subcube.com // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #include "transforms.inc" #include "math.inc" #declare NrOfDecimalsToPrint = 6; // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #declare R_ColorMap = color_map { [ 0 color rgb <1, 1, 1> ] [ 1 color red 10 ] } #declare G_ColorMap = color_map { [ 0 color rgb <1, 1, 1> ] [ 1 color green 10 ] } #declare B_ColorMap = color_map { [ 0 color rgb <1, 1, 1> ] [ 1 color blue 10 ] } // (LowLimit < A < HighLimit) #macro Interval_Function(LowLimit, HighLimit, InsideValue, OutsideValue) function(A) { select(LowLimit - A, select(A - HighLimit, InsideValue, OutsideValue), OutsideValue) } #end // macro Interval_Function /* // (LowLimit <= A < HighLimit) #macro Interval_L_Function(LowLimit, HighLimit, InsideValue, OutsideValue) function(A) { select(A - LowLimit, OutsideValue, select(A - HighLimit, InsideValue, OutsideValue)) } #end // macro Interval_L_Function // (LowLimit < A <= HighLimit) #macro Interval_H_Function(LowLimit, HighLimit, InsideValue, OutsideValue) function(A) { select(LowLimit - A, select(HighLimit - A, OutsideValue, InsideValue), OutsideValue) } #end // macro Interval_H_Function // (LowLimit <= A <= HighLimit) #macro Interval_LH_Function(LowLimit, HighLimit, InsideValue, OutsideValue) function(A) { select(A - LowLimit, OutsideValue, select(HighLimit - A, OutsideValue, InsideValue)) } #end // macro Interval_LH_Function */ #declare NotFn = function(A) { select(A, 0, 1, 0) } #declare SignFn = function(A) { select(A, -1, 0, 1) } #declare FractFn = function(A) { A - int(A) } #declare IntervalPositionFn = function(A, I) { FractFn(A/I + SignFn(A)/2) - SignFn(A)/2 } #declare RoundFn = function(A, I) { int(A/pow(10, I) + SignFn(A)/2)*pow(10, I) } #macro NextDecimal(Level, MaxLevel) #if (Level >= MaxLevel) MaxLevel #else select(AbsFractFn(A*pow(10, Level)), -1, Level, NextDecimal(Level + 1, MaxLevel)) #end // if #end // macro NextDecimal #macro LastDecimalFunction(MaxLevel) #local AbsFractFn = function(A) { abs(FractFn(A)) } #local NextDecFn = function(A) { NextDecimal(0, MaxLevel) } function(A) { NextDecFn(RoundFn(A, -MaxLevel)) } // function(A) { NextDecimal(0, MaxLevel) } #end // macro LastDecimalFunction #declare LastDecimalFn = LastDecimalFunction(NrOfDecimalsToPrint) #macro NumberString(Number) str(Number, 0, LastDecimalFn(Number)) #end // macro NumberString #macro PrintNumber(Number) #debug NumberString(Number) #end // macro PrintNumber #macro VectorStringM2D(v0) concat(NumberString(v0.u), ", " NumberString(v0.v)) #end // macro VectorStringM2D #macro VectorStringM(v0) concat(NumberString(v0.x), ", " NumberString(v0.y), ", " NumberString(v0.z)) #end // macro VectorStringM #macro VectorString2D(v0) concat("<", VectorStringM2D(v0), ">") #end // macro VectorString2D #macro VectorString(v0) concat("<", VectorStringM(v0), ">") #end // macro VectorString /* #macro PrintVector2D(v0) #debug concat("<", vstr(2, v0, ", ", 0, -1), ">") #end // macro PrintVector2D */ /* #macro PrintVector(v0) #debug concat("<", vstr(3, v0, ", ", 0, -1), ">") #end // macro PrintVector */ #macro PrintVector2D(v0) #debug VectorString2D(v0) #end // macro PrintVector2D #macro PrintVector(v0) #debug VectorString(v0) #end // macro PrintVector #macro GetTransform(Transform) #local vT = vtransform(<0, 0, 0>, Transform); array[4] { (vtransform(x, Transform) - vT), (vtransform(y, Transform) - vT), (vtransform(z, Transform) - vT), vT } #end // macro GetTransform /* #macro PrintTransform(Transform) #local TransVectors = GetTransform(Transform) #debug "\ntransform {\n " #debug vstr(3, TransVectors[0], ", ", 0, -1) #debug ",\n " #debug vstr(3, TransVectors[1], ", ", 0, -1) #debug ",\n " #debug vstr(3, TransVectors[2], ", ", 0, -1) #debug ",\n " #debug vstr(3, TransVectors[3], ", ", 0, -1) #debug "\n}\n" #end // macro PrintTransform */ #macro PrintTransform(Transform) #local TransformVectors = GetTransform(Transform) #debug "\ntransform {\n " #debug VectorStringM(TransformVectors[0]) #debug "\n " #debug VectorStringM(TransformVectors[1]) #debug "\n " #debug VectorStringM(TransformVectors[2]) #debug "\n " #debug VectorStringM(TransformVectors[3]) #debug "\n}\n" #end // macro PrintTransform #macro TransformFunction(Fn, Transform) #local TT = function { transform { Transform inverse } } function { Fn(TT(x, y, z).x, TT(x, y, z).y, TT(x, y, z).z) } #end // macro TransformFunction #macro CosRatio(v1, v2) (vdot(v1, v2)/vdot(v2, v2)) #end // macro CosRatio #macro Vector2Vector(v1, v2) (CosRatio(v1, v2)*v2) #end // macro Vector2Vector #macro Line2Plane(pLine, vLine, pPlane, vPlane) (pLine + vLine*vdot(pPlane - pLine, vPlane)/vdot(vLine, vPlane)) #end // macro Line2Plane #macro AxisRotateAtPoint_Trans(p0, vAxis, Angle) transform { translate -p0 Axis_Rotate_Trans(vAxis, Angle) translate p0 } #end // macro AxisRotateAtPoint_Trans #macro ReorientAtPoint_Trans(p0, vFrom, vTo) transform { translate -p0 Reorient_Trans(vFrom, vTo) translate p0 } #end // macro ReorientAtPoint_Trans #macro TransformPoints(Points, Transform) #local NrOfPoints = dimension_size(Points, 1); #local NewPoints = array[NrOfPoints] #local Cnt = 0; #while (Cnt < NrOfPoints) #local NewPoints[Cnt] = vtransform(Points[Cnt], Transform); #local Cnt = Cnt + 1; #end // while NewPoints #end // macro TransformPoints #macro PlotPoints(Points, Radius) #local NrOfPoints = dimension_size(Points,1 ); union { #local Cnt = 0; #while (Cnt < NrOfPoints) sphere { Points[Cnt], Radius } #local Cnt = Cnt + 1; #end // while } #end // macro PlotPoints #macro DrawLines(Points, Lines, Radius) #local NrOfLines = dimension_size(Lines, 1); union { #local Cnt = 0; #while (Cnt < NrOfLines) #if (vlength(Points[Lines[Cnt][1]] - Points[Lines[Cnt][0]]) > 0) cylinder { Points[Lines[Cnt][0]], Points[Lines[Cnt][1]], Radius } #end // if #local Cnt = Cnt + 1; #end // while } #end // macro DrawLines #macro DrawShape(Points, Lines, Radius) union { PlotPoints(Points, Radius*2) DrawLines(Points, Lines, Radius) } #end // macro DrawShape #macro DrawBox(BoxPoints, Radius) #local BoxLines = array[12][2] { { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 0 }, { 4, 5 }, { 5, 6 }, { 6, 7 }, { 7, 4 }, { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 } } DrawShape(BoxPoints, BoxLines, Radius) #end // macro DrawBox #macro Arrow(pStart, pEnd, Radius) #local A = Radius*3; #local B = Radius*2; #local C = Radius; #local vDirection = vnormalize(pEnd - pStart); union { difference { cone { <0, 0, 0>, 0, -(A + B)*vDirection, Radius + C } cone { -A*vDirection, Radius, -(A + 2*B)*vDirection, Radius + 2*C } translate pEnd } cylinder { pStart, pEnd - A*vDirection, Radius } } #end // macro Arrow #macro TickFunction(Scale, TickWidth) #if (Scale = 0) #local ReturnFn = function(A) { 0 } #else #local ReturnFn = function(A) { select(abs(IntervalPositionFn(A, Scale)) - TickWidth/2, 1, 0) } #end // if function(A) { ReturnFn(A) } #end // macro TickFunction #macro XYZ_Pigment(vScale, vTickWidth, ColorMapX, ColorMapY, ColorMapZ) #local X_TickFn = TickFunction(vScale.x, vTickWidth.x) #local Y_TickFn = TickFunction(vScale.y, vTickWidth.y) #local Z_TickFn = TickFunction(vScale.z, vTickWidth.z) #local X_Pigment = pigment { function { X_TickFn(x) } color_map { ColorMapX } } #local Y_Pigment = pigment { function { Y_TickFn(y) } color_map { ColorMapY } } #local Z_Pigment = pigment { function { Z_TickFn(z) } color_map { ColorMapZ } } pigment { average pigment_map { [ X_Pigment ] [ Y_Pigment ] [ Z_Pigment ] } } #end // macro XYZ_Pigment #macro DrawAxes(Length, Scale, Radius) #local TickFn = TickFunction(Scale, 0.05) #local R_Pigment = pigment { function { TickFn(x) } color_map { R_ColorMap } } #local G_Pigment = pigment { function { TickFn(y) } color_map { G_ColorMap } } #local B_Pigment = pigment { function { TickFn(z) } color_map { B_ColorMap } } union { object { Arrow(-Length*x, Length*x, Radius) pigment { R_Pigment } } object { Arrow(-Length*y, Length*y, Radius) pigment { G_Pigment } } object { Arrow(-Length*z, Length*z, Radius) pigment { B_Pigment } } } #end // macro DrawAxes // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 // The camera macros: #macro UnInitializedCamera() array[6] #end // macro UnInitialized #macro DefaultCamera() #local pLocation = <0, 0, 0>; #local vDirection = z; #local vRight = 1.33*x; #local vUp = y; #local vSky = y; #local pLookAt = z; array[6] { pLocation, vDirection, vRight, vUp, vSky, pLookAt } #end // macro DefaultCamera #macro CameraLocation(Camera) Camera[0] #end // macro CameraLocation #macro CameraDirection(Camera) Camera[1] #end // macro CameraDirection #macro CameraRight(Camera) Camera[2] #end // macro CameraRight #macro CameraUp(Camera) Camera[3] #end // macro CameraUp #macro CameraSky(Camera) Camera[4] #end // macro CameraSky #macro CameraLookAt(Camera) Camera[5] #end // macro CameraLookAt #macro CameraPlaneOrigo(Camera) (CameraLocation(Camera) + CameraDirection(Camera)) #end // macro CameraPlaneOrigo // Remember to fix this one to function correctly with non orthogonal cameravectors #macro CameraAspectRatio(Camera) (vlength(CameraRight(Camera))/vlength(CameraUp(Camera))) #end // macro CameraAspectRatio #macro HorizontalCameraAngle(Camera) #local vDirection = CameraDirection(Camera); #local vRight = CameraRight(Camera); (2*VAngleD(vDirection, vDirection + vRight/2)) #end // macro HorizontalCameraAngle #macro VerticalCameraAngle(Camera) #local vDirection = CameraDirection(Camera); #local vUp = CameraUp(Camera); (2*VAngleD(vDirection, vDirection + vUp/2)) #end // macro VerticalCameraAngle #macro CameraAngle(Camera) HorizontalCameraAngle(Camera) #end // macro CameraAngle #macro PerspCamera(Camera) camera { perspective location CameraLocation(Camera) direction CameraDirection(Camera) right CameraRight(Camera) up CameraUp(Camera) sky CameraSky(Camera) //look_at CameraLookAt(Camera) } #end // macro PerspCamera #macro SetCameraLocation(Camera, pLocation) #declare Camera[0] = pLocation; #end // macro SetCameraLocation #macro SetCameraDirection(Camera, vDirection) #if (vlength(vDirection) = 0) #local vDirection = CameraDirection(DefaultCamera()); #end // if #declare Camera[1] = vDirection; #end // macro SetCameraDirection #macro SetCameraRight(Camera, vRight) #if (vlength(vRight) = 0) #local vRight = CameraRight(DefaultCamera()); #end // if #declare Camera[2] = vRight; #end // macro SetCameraRight #macro SetCameraUp(Camera, vUp) #if (vlength(vUp) = 0) #local vUp = CameraUp(DefaultCamera()); #end // if #declare Camera[3] = vUp; #end // macro SetCameraUp #macro SetCameraSky(Camera, vSky) #if (vlength(vSky) = 0) #local vSky = CameraSky(DefaultCamera()); #end // if #declare Camera[4] = vSky; #end // macro SetCameraSky #macro SetCameraLookAt(Camera, pLookAt) #declare Camera[5] = pLookAt; #end // macro SetCameraLookAt #macro ChangeCameraAngle(Camera, Angle) #if (0 < Angle & Angle < 180) #local vDirection = CameraDirection(Camera); #local vRight = CameraRight(Camera); #local NewLength = vlength(vRight)/2/tan(radians(Angle)/2); SetCameraDirection(Camera, NewLength*vnormalize(vDirection)) #end // if #end // macro ChangeCameraAngle /* #macro ChangeVerticalCameraAngle(Camera, Angle) #end // macro ChangeVerticalCameraAngle */ #macro ChangeCameraAspectRatio(Camera, Ratio) #if (Ratio = 0) #local Ratio = image_width/image_height; #end // if SetCameraUp(Camera, vlength(CameraRight(Camera))/Ratio*vnormalize(CameraUp(Camera))) #end // macro ChangeCameraAspectRatio #macro IsRightHandCamera(Camera) (vdot(vcross(CameraDirection(Camera), CameraRight(Camera)), CameraUp(Camera)) < 0) #end //macro IsRightHandCamera #macro IsLeftHandCamera(Camera) (vdot(vcross(CameraDirection(Camera), CameraRight(Camera)), CameraUp(Camera)) > 0) #end //macro IsLeftHandCamera #macro SwapHandednessForCamera(Camera) SetCameraRight(Camera, -CameraRight(Camera)) #end // macro SwapHandednessForCamera #macro SetLeftHandCamera(Camera) #if (IsRightHandCamera(Camera)) SwapHandednessForCamera(Camera) #end // if #end // macro SetLeftHandCamera #macro SetRightHandCamera(Camera) #if (IsLeftHandCamera(Camera)) SwapHandednessForCamera(Camera) #end // if #end // macro SetRightHandCamera #macro UnRollCamera(Camera) #local vDirection = CameraDirection(Camera); #local vRight = CameraRight(Camera); #local vUp = CameraUp(Camera); #local vSky = CameraSky(Camera); #local RightHandCamera = IsRightHandCamera(Camera); #local vRight = vlength(vRight)*vnormalize(vcross(vSky, vDirection)); #local vUp = vlength(vUp)*vnormalize(vcross(vDirection, vRight)); SetCameraRight(Camera, vRight) SetCameraUp(Camera, vUp) #if (RightHandCamera) SwapHandednessForCamera(Camera) #end // if #end // macro UnRollCamera /* #macro UnTiltCamera(Camera) #end // macro UnTiltCamera */ #macro ApplyCameraLookAt(Camera) #local pLocation = CameraLocation(Camera); #local vDirection = CameraDirection(Camera); #local pLookAt = CameraLookAt(Camera); #local vLookAt = pLookAt - pLocation; #if (vlength(vLookAt) != 0) SetCameraDirection(Camera, vlength(vDirection)*vnormalize(vLookAt)) UnRollCamera(Camera) #end // if #end // macro ApplyCameraLookAt #macro ChangeCameraLookAt(Camera, pLookAt) SetCameraLookAt(Camera, pLookAt) ApplyCameraLookAt(Camera) #end // macro ChangeCameraLookAt #macro MakeCamera(pLocation, vDirection, vRight, vUp, Angle, vSky, pLookAt) #local Camera = UnInitializedCamera() SetCameraLocation(Camera, pLocation) SetCameraDirection(Camera, vDirection) SetCameraRight(Camera, vRight) SetCameraUp(Camera, vUp) SetCameraSky(Camera, vSky) SetCameraLookAt(Camera, pLookAt) ChangeCameraAngle(Camera, Angle) ApplyCameraLookAt(Camera) Camera #end // macro MakeCamera #macro PrintCamera(Camera) #debug "\ncamera {" #debug "\n perspective" #debug "\n location " PrintVector(CameraLocation(Camera)) #debug "\n direction " PrintVector(CameraDirection(Camera)) #debug "\n right " PrintVector(CameraRight(Camera)) #debug "\n up " PrintVector(CameraUp(Camera)) #debug "\n sky " PrintVector(CameraSky(Camera)) #debug "\n look_at " PrintVector(CameraLookAt(Camera)) #debug "\n}" #end // macro PrintCamera // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #macro TransformCamera(Camera, Transform) #local vT = vtransform(<0, 0, 0>, Transform); SetCameraLocation(Camera, vtransform(CameraLocation(Camera), Transform)) SetCameraDirection(Camera, vtransform(CameraDirection(Camera), Transform) - vT) SetCameraRight(Camera, vtransform(CameraRight(Camera), Transform) - vT) SetCameraUp(Camera, vtransform(CameraUp(Camera), Transform) - vT) SetCameraLookAt(Camera, vtransform(CameraLookAt(Camera), Transform)) // ? #end // macro TransformCamera #macro RotateCamera(Camera, vAngle, PreserveLookAt, PreserveSize) #local pLocation = CameraLocation(Camera); #local pLookAt = CameraLookAt(Camera); #local pNewLocation = vrotate(pLocation, vAngle); #if (PreserveSize) #local R = vlength(pLookAt - pNewLocation)/vlength(pLookAt - pLocation); SetCameraDirection(Camera, R*CameraDirection(Camera)) #end // if SetCameraLocation(Camera, pNewLocation) #if (PreserveLookAt) #local vFrom = vnormalize(pLookAt - pLocation); #local vTo = vnormalize(pLookAt - pNewLocation); #if (vlength(vTo - vFrom) != 0) // Because of bug in Reorient_Trans() TransformCamera( Camera, transform { translate -pNewLocation Reorient_Trans(vFrom, vTo) translate pNewLocation } ) #end // if SetCameraLookAt(Camera, pLookAt) #else TransformCamera(Camera, transform { rotate vAngle }) #end // if #end // macro RotateCamera #macro TranslateCamera(Camera, vTranslate, PreserveLookAt, PreserveSize) #local pLocation = CameraLocation(Camera); #local pLookAt = CameraLookAt(Camera); #local pNewLocation = pLocation + vTranslate; #if (PreserveSize) #local R = vlength(pLookAt - pNewLocation)/vlength(pLookAt - pLocation); SetCameraDirection(Camera, R*CameraDirection(Camera)) #end // if SetCameraLocation(Camera, pNewLocation) #if (PreserveLookAt) #local vFrom = vnormalize(pLookAt - pLocation); #local vTo = vnormalize(pLookAt - pNewLocation); #if (vlength(vTo - vFrom) != 0) // Because of bug in Reorient_Trans() TransformCamera( Camera, transform { translate -pNewLocation Reorient_Trans(vFrom, vTo) translate pNewLocation } ) #end // if SetCameraLookAt(Camera, pLookAt) #else SetCameraLookAt(Camera, pLookAt + vTranslate) #end // if #end // macro TranslateCamera #macro ScaleCamera(Camera, vScale) TransformCamera(Camera, transform { scale vScale }) #end // macro ScaleCamera #macro PanCameraRight(Camera, Angle) TransformCamera(Camera, AxisRotateAtPoint_Trans(CameraLocation(Camera), CameraUp(Camera), Angle)) #end // macro PanCameraRight #macro PanCameraLeft(Camera, Angle) PanCameraRight(Camera, -Angle) #end // macro PanCameraLeft #macro TiltCameraForward(Camera, Angle) TransformCamera(Camera, AxisRotateAtPoint_Trans(CameraLocation(Camera), CameraRight(Camera), Angle)) #end // macro TiltCameraForward #macro TiltCameraBackward(Camera, Angle) TiltCameraForward(Camera, -Angle) #end // macro TiltCameraBackward #macro RollCameraRight(Camera, Angle) TransformCamera(Camera, AxisRotateAtPoint_Trans(CameraLocation(Camera), CameraDirection(Camera), -Angle)) #end // macro RollCameraRight #macro RollCameraLeft(Camera, Angle) RollCameraRight(Camera, -Angle) #end // macro RollCameraLeft #macro RotateCameraRight(Camera, Angle) TransformCamera(Camera, AxisRotateAtPoint_Trans(CameraLookAt(Camera), CameraUp(Camera), Angle)) #end // macro RotateCameraRight #macro RotateCameraLeft(Camera, Angle) RotateCameraRight(Camera, -Angle) #end // macro RotateCameraLeft #macro RotateCameraUp(Camera, Angle) TransformCamera(Camera, AxisRotateAtPoint_Trans(CameraLookAt(Camera), CameraRight(Camera), Angle)) #end // macro RotateCameraUp #macro RotateCameraDown(Camera, Angle) RotateCameraUp(Camera, -Angle) #end // macro RotateCameraDown #macro TranslateCameraForward(Camera, Distance, PreserveLookAt, PreserveSize) TranslateCamera(Camera, Distance*vnormalize(CameraDirection(Camera)), PreserveLookAt, PreserveSize) #end // macro TranslateCameraForward #macro TranslateCameraBackward(Camera, Distance, PreserveLookAt, PreserveSize) TranslateCameraForward(Camera, -Distance, PreserveLookAt, PreserveSize) #end // macro TranslateCameraBackward #macro TranslateCameraRight(Camera, Distance, PreserveLookAt, PreserveSize) TranslateCamera(Camera, Distance*vnormalize(CameraRight(Camera)), PreserveLookAt, PreserveSize) #end // macro TranslateCameraRight #macro TranslateCameraLeft(Camera, Distance, PreserveLookAt, PreserveSize) TranslateCameraRight(Camera, -Distance, PreserveLookAt, PreserveSize) #end // macro TranslateCameraLeft #macro TranslateCameraUp(Camera, Distance, PreserveLookAt, PreserveSize) TranslateCamera(Camera, Distance*vnormalize(CameraUp(Camera)), PreserveLookAt, PreserveSize) #end // macro TranslateCameraUp #macro TranslateCameraDown(Camera, Distance, PreserveLookAt, PreserveSize) TranslateCameraUp(Camera, -Distance, PreserveLookAt, PreserveSize) #end // macro TranslateCameraDown #macro TranslateCameraRUF(Camera, vDirection, PreserveLookAt, PreserveSize) #local vTranslate = vDirection.x*vnormalize(CameraRight(Camera)) + vDirection.y*vnormalize(CameraUp(Camera)) + vDirection.z*vnormalize(CameraForward(Camera)); TranslateCamera(Camera, vTranslate, PreserveLookAt, PreserveSize) #end // macro TranslateCameraRUF #macro StraightenUpCamera(Camera) UnRollCamera(Camera) #local vFrom = vnormalize(CameraUp(Camera)); #local vTo = vnormalize(CameraSky(Camera)); #if (vlength(vTo - vFrom) != 0) TransformCamera(Camera, ReorientAtPoint_Trans(CameraLocation(Camera), vFrom, vTo)) #end // if #end // macro StraightenUpCamera // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #macro ScaleCameraVectors(Camera, Factor) SetCameraDirection(Camera, Factor*CameraDirection(Camera)) SetCameraRight(Camera, Factor*CameraRight(Camera)) SetCameraUp(Camera, Factor*CameraUp(Camera)) SetCameraSky(Camera, Factor*CameraSky(Camera)) #end // macro ScaleCameraVectors #macro ExtendCameraVectors(Camera) #local vLookAt = CameraLookAt(Camera) - CameraLocation(Camera); #local Ratio = vlength(vLookAt)/vlength(CameraDirection(Camera)); ScaleCameraVectors(Camera, Ratio) #end // macro ExtendCameraVectors #macro CameraLines(Camera, Extend, Radius) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pLocation = CameraLocation(CameraCopy); #local pOrigo = CameraPlaneOrigo(CameraCopy); #local vHalfRight = CameraRight(CameraCopy)/2; #local vHalfUp = CameraUp(CameraCopy)/2; #local pRU = pOrigo + vHalfRight + vHalfUp; #local pRD = pOrigo + vHalfRight - vHalfUp; #local pLU = pOrigo - vHalfRight + vHalfUp; #local pLD = pOrigo - vHalfRight - vHalfUp; union { sphere { pLocation, Radius*2 } cylinder { pLocation, pRU, Radius } cylinder { pLocation, pRD, Radius } cylinder { pLocation, pLD, Radius } cylinder { pLocation, pLU, Radius } } #end // macro CameraLines #macro CameraPlane(Camera, Extend) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pOrigo = CameraPlaneOrigo(CameraCopy); #local vHalfRight = CameraRight(CameraCopy)/2; #local vHalfUp = CameraUp(CameraCopy)/2; #local pRU = vHalfRight +vHalfUp; #local pRD = vHalfRight -vHalfUp; #local pLU = -vHalfRight +vHalfUp; #local pLD = -vHalfRight -vHalfUp; union { triangle { pRU, pRD, pLD } triangle { pLD, pLU, pRU } translate pOrigo } #end // macro CameraPlane #macro CameraPlaneFrame(Camera, Extend, Radius) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pOrigo = CameraPlaneOrigo(CameraCopy); #local vHalfRight = CameraRight(CameraCopy)/2; #local vHalfUp = CameraUp(CameraCopy)/2; #local pRU = vHalfRight +vHalfUp; #local pRD = vHalfRight -vHalfUp; #local pLU = -vHalfRight +vHalfUp; #local pLD = -vHalfRight -vHalfUp; union { sphere { pRU, Radius*2 } sphere { pRD, Radius*2 } sphere { pLU, Radius*2 } sphere { pLD, Radius*2 } cylinder { pRU, pRD, Radius } cylinder { pRD, pLD, Radius } cylinder { pLD, pLU, Radius } cylinder { pLU, pRU, Radius } translate pOrigo } #end // macro CameraPlaneFrame #macro CameraWalls(Camera, Extend) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pLocation = CameraLocation(CameraCopy); #local pOrigo = CameraPlaneOrigo(CameraCopy); #local vHalfRight = CameraRight(CameraCopy)/2; #local vHalfUp = CameraUp(CameraCopy)/2; #local pRU = pOrigo + vHalfRight + vHalfUp; #local pRD = pOrigo + vHalfRight - vHalfUp; #local pLU = pOrigo - vHalfRight + vHalfUp; #local pLD = pOrigo - vHalfRight - vHalfUp; union { triangle { pLocation, pRD, pRU } triangle { pLocation, pRU, pLU } triangle { pLocation, pLU, pLD } triangle { pLocation, pLD, pRD } } #end // macro CameraWalls #macro CameraVectors(Camera, Extend, Radius) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pLocation = CameraLocation(CameraCopy); // #local pLookAt = CameraLookAt(CameraCopy); #local pOrigo = CameraPlaneOrigo(CameraCopy); #local pRight = pOrigo + CameraRight(CameraCopy); #local pUp = pOrigo + CameraUp(CameraCopy); #local pSky = pLocation + CameraSky(CameraCopy); union { Arrow(pLocation, pOrigo, Radius) Arrow(pOrigo, pRight, Radius) Arrow(pOrigo, pUp, Radius) Arrow(pLocation, pSky, Radius) sphere { pLocation, Radius } sphere { pOrigo, Radius } // sphere { pLookAt, Radius } } #end // macro CameraVectors // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #macro ShowCameraCyls(Camera, Extend, FrameOn, LinesOn, Radius) #if (FrameOn) object { CameraPlaneFrame(Camera, Extend, Radius) pigment { color rgb <2, 2, 1> } no_shadow } #end // if #if (LinesOn) object { CameraLines(Camera, Extend, Radius) pigment { color rgb <1, 2, 1> } no_shadow } #end // if #end // macro ShowCameraCyls #macro ShowCameraPlanes(Camera, Extend, PlaneOn, WallsOn) #if (PlaneOn) object { CameraPlane(Camera, Extend) pigment { color rgbt <1, 1, 1, 0.4> } no_shadow } #end // if #if (WallsOn) object { CameraWalls(Camera, Extend) pigment { color rgbt <1, 1, 1, 0.6> } no_shadow } #end // if #end // macro ShowCameraPlanes #macro ShowCameraVectors(Camera, Extend, Radius) object { CameraVectors(Camera, Extend, Radius) pigment { color rgb <2, 1, 1> } no_shadow } #end // macro ShowCameraVectors #macro ShowCamera(Camera, Extend, Radius) union { ShowCameraCyls(Camera, Extend, on, on, Radius) ShowCameraPlanes(Camera, Extend, on, on) ShowCameraVectors(Camera, Extend, Radius) } #end // macro ShowCamera // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #macro PointToCameraPlane(Camera, Extend, p0) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pLocation = CameraLocation(CameraCopy); #local vDirection = CameraDirection(CameraCopy); Line2Plane(pLocation, p0 - pLocation, pLocation + vDirection, -vDirection) #end // macro PointToCameraPlane #macro PointToCameraCoords(Camera, p0) #local v0Camera = PointToCameraPlane(Camera, no, p0) - CameraPlaneOrigo(Camera); #end // macro PointToCameraCoords #macro CameraCoordsToPoint(Camera, Extend, pCamera) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if (CameraPlaneOrigo(CameraCopy) + pCamera.u*CameraRight(CameraCopy) + pCamera.v*CameraUp(CameraCopy)) #end // macro CameraCoordsToPoint #macro ScreenResolution(ScreenWidth, ScreenHeight) #if (ScreenWidth = 0) #local ScreenWidth = image_width; #end // if #if (ScreenHeight = 0) #local ScreenHeight = image_height; #end // if #end // macro ScreenResolution #macro PointToScreenCoords(Camera, p0, ScreenWidth, ScreenHeight) (PointToCameraCoords(Camera, p0)*ScreenResolution(ScreenWidth, ScreenHeight)) #end // macro PointToScreenCoords #macro ScreenCoordsToPoint(Camera, Extend, pScreen, ScreenWidth, ScreenHeight) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if CameraCoordsToPoint(CameraCopy, no, pScreen/ScreenResolution(ScreenWidth, ScreenHeight)) #end // macro ScreenCoordsToPoint // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 #macro MiddleOfPoints(Points) #local NrOfPoints = dimension_size(Points, 1); #local pSum = Points[0]; #local Cnt = 1; #while (Cnt < NrOfPoints) #local pSum = pSum + Points[Cnt]; #local Cnt = Cnt + 1; #end // while (pSum/NrOfPoints) #end // macro MiddleOfPoints #macro CalcFactor(Camera, p0) #local v0 = PointToCameraCoords(Camera, p0); (2*max(abs(v0.u), abs(v0.v))) #end // macro CalcFactor #macro ZoomCameraToIncludePoint(Camera, pZoomTo) #local Factor = CalcFactor(Camera, pZoomTo); #if (Factor != 0) SetCameraDirection(Camera, CameraDirection(Camera)/Factor) #end // if #end // macro ZoomCameraToIncludePoint #macro FindMaxFactor(Camera, Points) #local NrOfPoints = dimension_size(Points, 1); #local Factor = 0; #local Cnt = 0; #while (Cnt < NrOfPoints) #local NewFactor = CalcFactor(Camera, Points[Cnt]); #if (NewFactor > Factor) #local Factor = NewFactor; #end // if #local Cnt = Cnt + 1; #end // while Factor #end // macro FindMaxFactor #macro AdjustCameraVectors(Camera) #local RightHandCamera = IsRightHandCamera(Camera); #local RightLength = vlength(CameraRight(Camera)); #local UpLength = vlength(CameraUp(Camera)); #local DirectionLength = vlength(CameraDirection(Camera)); #local vLookAt = CameraLookAt(Camera) - CameraLocation(Camera); #local vDirection = vnormalize(vLookAt); #local vRight = vnormalize(vcross(CameraSky(Camera), vDirection)); #local vUp = vcross(vDirection, vRight); SetCameraDirection(Camera, DirectionLength*vDirection) SetCameraRight(Camera, RightLength*vRight) SetCameraUp(Camera, UpLength*vUp) #if (RightHandCamera) SwapHandednessForCamera(Camera) #end // if #end // AdjustCameraVectors #macro ZoomCameraToPoints(Camera, Points) SetCameraLookAt(Camera, MiddleOfPoints(Points)) AdjustCameraVectors(Camera) #local pCameraLocation = CameraLocation(Camera); #local vDirection = CameraDirection(Camera); #local vRight = CameraRight(Camera); #local vUp = CameraUp(Camera); #local MinVerticalAngle = 0; #local MaxVerticalAngle = 0; #local MinHorizontalAngle = 0; #local MaxHorizontalAngle = 0; #local NrOfPoints = dimension_size(Points, 1); #local Cnt = 0; #while (Cnt < NrOfPoints) #local pCnt = Points[Cnt]; #local vCnt = pCnt - pCameraLocation; #local pCntV = pCnt - Vector2Vector(vCnt, vRight); #local pCntH = pCnt - Vector2Vector(vCnt, vUp); #local vCntV = pCntV - pCameraLocation; #local vCntH = pCntH - pCameraLocation; #local VerticalAngle = VAngleD(vCntV, vDirection); #local HorizontalAngle = VAngleD(vCntH, vDirection); #if (vdot(vCntV, vUp) < 0) #local VerticalAngle = -VerticalAngle; #end // if #if (vdot(vCntH, vRight) < 0) #local HorizontalAngle = -HorizontalAngle; #end // if #if (VerticalAngle < MinVerticalAngle) #local MinVerticalAngle = VerticalAngle; #end // if #if (VerticalAngle > MaxVerticalAngle) #local MaxVerticalAngle = VerticalAngle; #end // if #if (HorizontalAngle < MinHorizontalAngle) #local MinHorizontalAngle = HorizontalAngle; #end // if #if (HorizontalAngle > MaxHorizontalAngle) #local MaxHorizontalAngle = HorizontalAngle; #end // if #local Cnt = Cnt + 1; #end // while TiltCameraBackward(Camera, (MinVerticalAngle + MaxVerticalAngle)/2) PanCameraRight(Camera, (MinHorizontalAngle + MaxHorizontalAngle)/2) #local Factor = FindMaxFactor(Camera, Points); #if (Factor != 0) SetCameraDirection(Camera, CameraDirection(Camera)/Factor) #end // if #end // macro ZoomCameraToPoints #macro ZoomCameraIn(Camera, Percent) #local Scale = 1 + Percent/100; #if (Scale > 0) SetCameraDirection(Camera, Scale*CameraDirection(Camera)) #end // if #end // macro ZoomCameraIn #macro ZoomCameraOut(Camera, Percent) ZoomCameraIn(Camera, -Percent) #end // macro ZoomCameraOut #macro MinMaxPointsToBoxPoints(pMin, pMax) array[8] { , , , , , , , } #end // macro MinMaxPointsToBoxPoints #macro ZoomCameraToMaxMinExtents(Camera, pMin, pMax) ZoomCameraToPoints(Camera, MinMaxPointsToBoxPoints(pMin, pMax)) #end // macro ZoomCameraToMaxMinExtents // Does not function well when the camera is close to the object. // Perhaps a warning should be issued. TOK 2003-10-23 #macro ZoomCameraToObject(Camera, Object) ZoomCameraToMaxMinExtents(Camera, min_extent(Object), max_extent(Object)) #end // macro ZoomCameraToObject #macro IsPointInCameraView(Camera, p0) #local v0 = PointToCameraCoords(Camera, p0); (max(abs(v0.u), abs(v0.v)) <= 0.5) #end // macro IsPointInCameraView #macro DrawMinMaxBox(pMin, pMax, Radius) DrawBox(MinMaxPointsToBoxPoints(pMin, pMax), Radius) #end // macro DrawMinMaxBox #macro DrawBoundingBox(Object, Radius) DrawMinMaxBox(min_extent(Object), max_extent(Object), Radius) #end // macro DrawBoundingBox #macro ShowBoundingBox(Object, Radius) object { DrawBoundingBox(Object, Radius) pigment { color rgb <2, 2, 0> } } #end // macro ShowBoundingBox /* #macro SaveVectorCameraToFile(Camera, FileName) #end // macro SaveVectorCameraToFile */ /* #macro SaveLookAtCameraToFile(Camera, FileName) #end // macro SaveLookAtCameraToFile */ // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #macro PointsToPlane(pOrigin, pPlane, vPlane, Points) #local NrOfPoints = dimension_size(Points,1 ); #local NewPoints = array[NrOfPoints] #local Cnt = 0; #while (Cnt < NrOfPoints) #declare NewPoints[Cnt] = Line2Plane(pOrigin, Points[Cnt] - pOrigin, pPlane, vPlane) #local Cnt = Cnt + 1; #end // while NewPoints #end // macro PointsToPlane #macro PointsToCameraPlane(Camera, Extend, Points) #local NrOfPoints = dimension_size(Points,1 ); #local NewPoints = array[NrOfPoints] #local Cnt = 0; #while (Cnt < NrOfPoints) #declare NewPoints[Cnt] = PointToCameraPlane(Camera, Extend, Points[Cnt]); #local Cnt = Cnt + 1; #end // while NewPoints #end // macro PointsToCameraPlane #macro PointsToCameraCoords(Camera, Points) #local NrOfPoints = dimension_size(Points,1 ); #local NewPoints = array[NrOfPoints] #local Cnt = 0; #while (Cnt < NrOfPoints) #declare NewPoints[Cnt] = PointToCameraCoords(Camera, Points[Cnt]); #local Cnt = Cnt + 1; #end // while NewPoints #end // macro PointsToCameraCoords #macro ScreenCoordsToPoints(Camera, Extend, Points, ScreenWidth, ScreenHeight) #local NrOfPoints = dimension_size(Points, 1); #local NewPoints = array[NrOfPoints] #local Cnt = 0; #while (Cnt < NrOfPoints) #declare NewPoints[Cnt] = ScreenCoordsToPoint(Camera, Extend, Points[Cnt], ScreenWidth, ScreenHeight); #local Cnt = Cnt + 1; #end // while NewPoints #end // macro ScreenCoordsToPoints #macro ScreenCoordsToPixelCoords(pScreen, ScreenWidth, ScreenHeight) ((ScreenResolution(ScreenWidth, ScreenHeight) - <1, 1>)/2 + pScreen*<1, -1>) #end // macro PixelCoordsToCameraCoords #macro PixelCoordsToScreenCoords(pPixel, ScreenWidth, ScreenHeight) ((ScreenResolution(ScreenWidth, ScreenHeight)*<-1, 1> + <1, -1>)/2 + pPixel*<1, -1>) #end // macro PixelCoordsToScreenCoords /* #macro SetPixel(Camera, Extend, Pixel, Color, ScreenWidth, ScreenHeight) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pCameraPlaneOrigo = CameraPlaneOrigo(CameraCopy); #local vCameraRight = CameraRight(CameraCopy); #local vCameraUp = CameraUp(CameraCopy); #local vScreenRes = ScreenResolution(ScreenWidth, ScreenHeight); #local vRight = vCameraRight/vScreenRes.u; #local vUp = vCameraUp/vScreenRes.v; #local p00 = Pixel.u*vRight - Pixel.v*vUp; #local p10 = p00 + vRight; #local p01 = p00 - vUp; #local p11 = p01 + vRight; union { triangle { p00, p10, p11 } triangle { p11, p01, p00 } pigment { color Color } translate pCameraPlaneOrigo + (vCameraUp - vCameraRight)/2 } #end // macro SetPixel */ #macro SetPixel(Camera, Extend, pPixel, Color, ScreenWidth, ScreenHeight) #local vPixel = PixelCoordsToScreenCoords(pPixel, ScreenWidth, ScreenHeight); #local p00 = ScreenCoordsToPoint(Camera, Extend, vPixel + <-0.5, 0.5>, ScreenWidth, ScreenHeight); #local p10 = ScreenCoordsToPoint(Camera, Extend, vPixel + < 0.5, 0.5>, ScreenWidth, ScreenHeight); #local p01 = ScreenCoordsToPoint(Camera, Extend, vPixel + <-0.5, -0.5>, ScreenWidth, ScreenHeight); #local p11 = ScreenCoordsToPoint(Camera, Extend, vPixel + < 0.5, -0.5>, ScreenWidth, ScreenHeight); union { triangle { p00, p10, p11 } triangle { p11, p01, p00 } pigment { color Color } } #end // macro SetPixel #macro SetPixels(Camera, Extend, Pixels, Colors, ScreenWidth, ScreenHeight) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local pCameraPlaneOrigo = CameraPlaneOrigo(CameraCopy); #local vCameraRight = CameraRight(CameraCopy); #local vCameraUp = CameraUp(CameraCopy); #local vScreenRes = ScreenResolution(ScreenWidth, ScreenHeight); #local vRight = vCameraRight/vScreenRes.u; #local vUp = vCameraUp/vScreenRes.v; #local NrOfPixels = dimension_size(Pixels, 1); #local pOrigo = pCameraPlaneOrigo + (vCameraUp - vCameraRight)/2; // union { #local Cnt = 0; #while (Cnt < NrOfPixels) #local p00 = pOrigo + Pixels[Cnt].u*vRight - Pixels[Cnt].v*vUp; // #local p00 = Pixels[Cnt].u*vRight - Pixels[Cnt].v*vUp; #local p10 = p00 + vRight; #local p01 = p00 - vUp; #local p11 = p01 + vRight; // union { triangle { p00, p10, p11 pigment { color Colors[Cnt] } } triangle { p11, p01, p00 pigment { color Colors[Cnt] } } // pigment { color Colors[Cnt] } // } #local Cnt = Cnt + 1; #end // while // translate pCameraPlaneOrigo + (vCameraUp - vCameraRight)/2 // } #end // macro SetPixels #macro MinPointOnScreen(Camera, Points) #local NrOfPoints = dimension_size(Points, 1); #local pMin = PointToCameraCoords(Camera, Points[0]); #local Cnt = 1; #while (Cnt < NrOfPoints) #local pCnt = PointToCameraCoords(Camera, Points[Cnt]); #if (pCnt.u < pMin.u) #local pMin = ; #end // if #if (pCnt.v < pMin.v) #local pMin = ; #end // if #local Cnt = Cnt + 1; #end // while pMin #end // macro MinPointOnScreen #macro MaxPointOnScreen(Camera, Points) #local NrOfPoints = dimension_size(Points, 1); #local pMax = PointToCameraCoords(Camera, Points[0]); #local Cnt = 1; #while (Cnt < NrOfPoints) #local pCnt = PointToCameraCoords(Camera, Points[Cnt]); #if (pCnt.u > pMax.u) #local pMax = ; #end // if #if (pCnt.v > pMax.v) #local pMax = ; #end // if #local Cnt = Cnt + 1; #end // while pMax #end // macro MaxPointOnScreen /* #macro MinPointOnScreenOfObject(Camera, Object) MinPointOnScreen(Camera, MinMaxPointsToBoxPoints(min_extent(Object), max_extent(Object))) #end // macro MinPointOnScreenOfObject #macro MaxPointOnScreenOfObject(Camera, Object) MaxPointOnScreen(Camera, MinMaxPointsToBoxPoints(min_extent(Object), max_extent(Object))) #end // macro MaxPointOnScreenOfObject */ #macro Text(FontName, TextString) text { ttf FontName TextString 1 <0, 0, 0> } #end // macro Text(FontName, TextString) #macro SizeOfObject(Object) (max_extent(Object) - min_extent(Object)) #end // macro SizeOfObject #macro MiddleOfObject(Object) ((max_extent(Object) + min_extent(Object))/2) #end // macro MiddleOfObject #macro SizeOfText(FontName, TextString) SizeOfObject(Text(FontName, TextString)) #end // macro SizeOfText // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 #macro StepCameraRight(Camera, Amount, PreserveLookAt, PreserveSize) #local CameraCopy = Camera ExtendCameraVectors(CameraCopy) TranslateCamera(Camera, Amount*CameraRight(CameraCopy), PreserveLookAt, PreserveSize) #end // macro StepCameraRight #macro StepCameraLeft(Camera, Amount, PreserveLookAt, PreserveSize) StepCameraRight(Camera, -Amount, PreserveLookAt, PreserveSize) #end // macro StepCameraLeft #macro StepCameraUp(Camera, Amount, PreserveLookAt, PreserveSize) #local CameraCopy = Camera ExtendCameraVectors(CameraCopy) TranslateCamera(Camera, Amount*CameraUp(CameraCopy), PreserveLookAt, PreserveSize) #end // macro StepCameraUp #macro StepCameraDown(Camera, Amount, PreserveLookAt, PreserveSize) StepCameraUp(Camera, -Amount, PreserveLookAt, PreserveSize) #end // macro StepCameraDown #macro StepCameraForward(Camera, Amount, PreserveLookAt, PreserveSize) #local CameraCopy = Camera ExtendCameraVectors(CameraCopy) TranslateCamera(Camera, Amount*CameraDirection(CameraCopy), PreserveLookAt, PreserveSize) #end // macro StepCameraForward #macro StepCameraBackward(Camera, Amount, PreserveLookAt, PreserveSize) StepCameraForward(Camera, -Amount, PreserveLookAt, PreserveSize) #end // macro StepCameraBackward #macro ChangeCameraLookAtToObject(Camera, Object) ChangeCameraLookAt(Camera, MiddleOfObject(Object)) #end // macro ChangeCameraLookAtToObject #macro RotateRight_Trans(Camera, Angle) AxisRotateAtPoint_Trans(CameraLocation(Camera), CameraUp(Camera), Angle) #end // macro RotateRight_Trans #macro RotateLeft_Trans(Camera, Angle) RotateRight_Trans(Camera, -Angle) #end // macro RotateLeft_Trans #macro RotateUp_Trans(Camera, Angle) AxisRotateAtPoint_Trans(CameraLocation(Camera), CameraRight(Camera), Angle) #end // macro RotateUp_Trans #macro RotateDown_Trans(Camera, Angle) RotateUp_Trans(Camera, -Angle) #end // macro RotateDown_Trans #macro PanRight_Trans(Camera, Angle) AxisRotateAtPoint_Trans(CameraLookAt(Camera), CameraUp(Camera), Angle) #end // macro PantRight_Trans #macro PanLeft_Trans(Camera, Angle) PanRight_Trans(Camera, -Angle) #end // macro PanLeft_Trans #macro TiltForward_Trans(Camera, Angle) AxisRotateAtPoint_Trans(CameraLookAt(Camera), CameraRight(Camera), Angle) #end // macro TiltForward_Trans #macro TiltBackward_Trans(Camera, Angle) TiltForward_Trans(Camera, -Angle) #end // macro TiltBackward_Trans #macro RollRight_Trans(Camera, Angle) AxisRotateAtPoint_Trans(CameraLookAt(Camera), CameraDirection(Camera), Angle) #end // macro RollRight_Trans #macro RollLeft_Trans(Camera, Angle) RollRight_Trans(Camera, -Angle) #end // macro RollLeft_Trans #macro TranslateUp_Trans(Camera, Distance) transform { translate Distance*vnormalize(CameraUp(Camera)) } #end // macro TranslateUp_Trans #macro TranslateDown_Trans(Camera, Distance) TranslateUp_Trans(Camera, -Distance) #end // macro TranslateDown_Trans #macro TranslateRight_Trans(Camera, Distance) transform { translate Distance*vnormalize(CameraRight(Camera)) } #end // macro TranslateRight_Trans #macro TranslateLeft_Trans(Camera, Distance) TranslateRight_Trans(Camera, -Distance) #end // macro TranslateLeft_Trans #macro TranslateForward_Trans(Camera, Distance) transform { translate Distance*vnormalize(CameraDirection(Camera)) } #end // macro TranslateForward_Trans #macro TranslateBackward_Trans(Camera, Distance) TranslateForward_Trans(Camera, -Distance) #end // macro TranslateBackward_Trans #macro Camera_Trans(Camera, Extend) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if Matrix_Trans( CameraRight(CameraCopy), CameraUp(CameraCopy), CameraDirection(CameraCopy), CameraPlaneOrigo(CameraCopy) ) #end // macro Camera_Trans #macro OrientToCamera_Trans(Camera, vTranslate) #local vR = vnormalize(CameraRight(Camera)); #local vU = vnormalize(CameraUp(Camera)); #local vD = vnormalize(CameraDirection(Camera)); #if (vlength(vTranslate) = 0) #local Transform = Shear_Trans(vR, vU, vD) #else #local Transform = Matrix_Trans(vR, vU, vD, vTranslate) #end // if transform { Transform } #end // macro OrientToCamera_Trans #macro CameraLocation_Trans(Camera) OrientToCamera_Trans(Camera, CameraLocation(Camera)) #end // CameraLocation_Trans #macro CameraLookAt_Trans(Camera) OrientToCamera_Trans(Camera, CameraLookAt(Camera)) #end // CameraLookAt_Trans #macro CameraPlaneOrigo_Trans(Camera) OrientToCamera_Trans(Camera, CameraPlaneOrigo(Camera)) #end // CameraPlaneOrigo_Trans #macro InCameraViewFunction(Camera) #local H_Angle = radians(HorizontalCameraAngle(Camera)/2); #local V_Angle = radians(VerticalCameraAngle(Camera)/2); #local H_Fn = Interval_Function(-H_Angle, H_Angle, 1, 0) #local V_Fn = Interval_Function(-V_Angle, V_Angle, 1, 0) #local HalfPi = pi/2; #local InViewFn = function { H_Fn(f_th(x, y, z)) & V_Fn(HalfPi - f_ph(0, y, z)) } TransformFunction(InViewFn, CameraLocation_Trans(Camera)) // #local H_InViewFn = function { H_Fn(f_th(x, y, z)) } // #local V_InViewFn = function { V_Fn(HalfPi - f_ph(0, y, z)) } // TransformFunction(function { H_InViewFn(x, y, z) & V_InViewFn(x, y, z) }, CameraLocation_Trans(Camera)) #end // macro InCameraViewFunction #macro VerticalStripesFn(Camera, Interval) #if (Interval = 0) #local VS_Fn = function { 0 } #else #local I = radians(Interval); #local Limit = I/50; #local VS_IntervalFn = Interval_Function(Limit, I - Limit, 0, 1) #local VS_AngleModFn = function { mod(f_th(x, y, z), I) } #local VS_StripesFn = function { VS_IntervalFn(abs(VS_AngleModFn(x, y, z))) } #local VS_Fn = TransformFunction(VS_StripesFn, CameraLocation_Trans(Camera)) #end // if function { VS_Fn(x, y, z) } #end // macro VerticalStripesFn #macro HorizontalStripesFn(Camera, Interval) #if (Interval = 0) #local HS_Fn = function { 0 } #else #local I = radians(Interval); #local Limit = I/50; #local HalfPi = pi/2; #local HS_IntervalFn = Interval_Function(Limit, I - Limit, 0, 1) #local HS_AngleModFn = function { mod(HalfPi - f_ph(0, y, z), I) } #local HS_StripesFn = function { HS_IntervalFn(abs(HS_AngleModFn(x, y, z))) } #local HS_Fn = TransformFunction(HS_StripesFn, CameraLocation_Trans(Camera)) #end // if function { HS_Fn(x, y, z) } #end // macro HorizontalStripesFn #macro RadialStripesFunction(Camera, Interval) #if (Interval = 0) #local RS_Fn = function { 0 } #else #local I = radians(Interval); #local Limit = I/50; #local RS_IntervalFn = Interval_Function(Limit, I - Limit, 0, 1) #local RS_AngleModFn = function { mod(f_th(x, 0, y), I) } #local RS_StripesFn = function { RS_IntervalFn(abs(RS_AngleModFn(x, y, z))) } #local RS_Fn = TransformFunction(RS_StripesFn, CameraLocation_Trans(Camera)) #end // if function { RS_Fn(x, y, z) } #end // macro RadialStripesFunction #macro CameraAnglePigment(Camera, HorizontalStep, VerticalStep, RadialStep) #local H_StripesFn = VerticalStripesFn(Camera, HorizontalStep) #local V_StripesFn = HorizontalStripesFn(Camera, VerticalStep) #local R_StripesFn = RadialStripesFunction(Camera, RadialStep) #local AllStripesFn = function { H_StripesFn(x, y, z) | V_StripesFn(x, y, z) | R_StripesFn(x, y, z) } #local InCameraViewFn = InCameraViewFunction(Camera) #local MaskFn = function { (1 + InCameraViewFn(x, y, z))/2 } #local H_Pigment = pigment { function { H_StripesFn(x, y, z)*MaskFn(x, y, z) } color_map { [ 0 color red 0 ] [ 1 color red 6 ] } } #local V_Pigment = pigment { function { V_StripesFn(x, y, z)*MaskFn(x, y, z) } color_map { [ 0 color green 0 ] [ 1 color green 6 ] } } #local R_Pigment = pigment { function { R_StripesFn(x, y, z)*MaskFn(x, y, z) } color_map { [ 0 color blue 0 ] [ 1 color blue 6 ] } } #local MaskPigment = pigment { function { MaskFn(x, y, z)*NotFn(AllStripesFn(x, y, z)) } color_map { [ 0.0 color rgb <1, 1, 1>*0 ] [ 0.5 color rgb <1, 1, 1>*3 ] [ 1.0 color rgb <1, 1, 1>*5 ] } } pigment { average pigment_map { [ MaskPigment ] [ H_Pigment ] [ V_Pigment ] [ R_Pigment ] } } #end // macro CameraAnglePigment #macro InViewOfCameraPigment(Camera) #local InCameraViewFn = InCameraViewFunction(Camera) #local MaskFn = function { (1 + InCameraViewFn(x, y, z))/2 } pigment { function { MaskFn(x, y, z) } color_map { [ 0 color rgb <1, 1, 1>*0.5 ] [ 1 color rgb <1, 1, 1>*2.0 ] } } #end // macro InViewOfCameraPigment #macro CameraUnitsPigment(Camera, vScale) #local Pigment = XYZ_Pigment(vScale, <2, 1, 1>*0.05, R_ColorMap, G_ColorMap, B_ColorMap) pigment { Pigment Camera_Trans(Camera, yes) } #end // macro CameraUnitsPigment /* #macro FindCameraScaleFactor(Camera, Extend, FitWidth, FitHeight) #end // macro FindCameraScaleFactor */ #macro ImageToCameraPlane(Camera, Extend, FileName, Angle, FitWidth, FitHeight) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if #local AspectRatio = CameraAspectRatio(CameraCopy); #if (FitWidth) #local WidthScale = vlength(CameraRight(CameraCopy)); #if (!FitHeight) #local HeightScale = WidthScale; #end // if #end // if #if (FitHeight) #local HeightScale = vlength(CameraUp(CameraCopy)); #if (!FitWidth) #local WidthScale = HeightScale; #end // if #end // if #if (!FitWidth & !FitHeight) #local SkyLength = vlength(CameraSky(CameraCopy)); // ? #local WidthScale = SkyLength; // ? #local HeightScale = SkyLength; // ? // #local DirectionLength = vlength(CameraDirection(CameraCopy)); // ? // #local WidthScale = DirectionLength; // ? // #local HeightScale = DirectionLength; // ? #end // if #local vScale = ; // PrintVector(vScale) object { CameraPlane(CameraCopy, no) pigment { image_map { png FileName map_type 0 interpolate 2 once } translate -<0.5, 0.5, 0> rotate -Angle*z scale vScale // scale <1, 1, 1>*0.05 // scale <0.005, 0.05, 1> // Hmmm... Bug in image_map scaling ? CameraPlaneOrigo_Trans(CameraCopy) } } #end // macro ImageToCameraPlane // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 // Macros that uses ABX' camera_view patch /* #macro PerspCameraViewToCameraPlane(Camera, Extend) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if object { CameraPlane(CameraCopy, no) pigment { image_map { camera_view { perspective location CameraLocation(CameraCopy) direction CameraDirection(CameraCopy) right CameraRight(CameraCopy) up CameraUp(CameraCopy) } } translate -<0.5, 0.5, 0> scale CameraPlaneOrigo_Trans(CameraCopy) } } #end // macro PerspCameraViewToCameraPlane */ // Preferred implementation: #macro PerspCameraViewToCameraPlane(Camera, Extend) #local CameraCopy = Camera #if (Extend) ExtendCameraVectors(CameraCopy) #end // if object { CameraPlane(CameraCopy, no) pigment { image_map { camera_view { PerspCamera(CameraCopy) } } translate -<0.5, 0.5, 0> scale CameraPlaneOrigo_Trans(CameraCopy) } } #end // macro PerspCameraViewToCameraPlane // ===== 1 ======= 2 ======= 3 ======= 4 ======= 5 ======= 6 ======= 7 ======= 8 ======= 9 ======= 10 // Remember to check if more of the macros changes handedness