diff --git a/Data/GlomeVec.hs b/Data/GlomeVec.hs --- a/Data/GlomeVec.hs +++ b/Data/GlomeVec.hs @@ -4,8 +4,8 @@ module Data.GlomeVec where --- Performance is pretty similar with Floats or Doubles --- best performance seems to be doubles with -fvia-C +-- | Performance is pretty similar with Floats or Doubles. +-- Todo: make separate Float and Double instances of this library. type Flt = Double -- maybe this is defined somewhere? @@ -13,40 +13,42 @@ --infinity = 1.0 / 0.0 infinity = 1000000.0 --- convert from degrees to native angle format (radians) +-- | Convert from degrees to native angle format (radians). deg :: Flt -> Flt deg !x = (x*3.1415926535897)/180 --- convert from radians (noop) +-- | Convert from radians to native format (noop). rad :: Flt -> Flt rad !x = x --- convert from rotations +-- | Convert from rotations to native format. (rot 1 == deg 360) rot :: Flt -> Flt rot !x = x*3.1415926535897*2 --- trig with degrees +-- | Trig with degrees instead of radians. dcos :: Flt -> Flt dcos d = cos $ deg d --- force a value to be within a range +-- | Force a value to be within a range. Usage: clamp min x max clamp :: Flt -> Flt -> Flt -> Flt clamp !min !x !max | x < min = min | x > max = max | otherwise = x --- delta = 0.00001 :: Flt +-- | Tuning parameter. delta = 0.0001 :: Flt --- non-polymorphic versions; this speeds --- things up in ocaml, not sure about haskell +-- | Non-polymorphic fmin; this speeds +-- things up in ocaml, not sure about haskell. fmin :: Flt -> Flt -> Flt fmin !a !b = if a > b then b else a +-- | Non-polymorphic fmax. fmax :: Flt -> Flt -> Flt fmax !a !b = if a > b then a else b +-- | Non-polymorphic min of 3 values. fmin3 :: Flt -> Flt -> Flt -> Flt fmin3 !a !b !c = if a > b then if b > c @@ -56,6 +58,7 @@ then c else a +-- | Non-polymorphic max of 3 values. fmax3 :: Flt -> Flt -> Flt -> Flt fmax3 !a !b !c = if a > b then if a > c @@ -65,25 +68,31 @@ then b else c +-- | Min of 4 values. fmin4 :: Flt -> Flt -> Flt -> Flt -> Flt fmin4 !a !b !c !d = fmin (fmin a b) (fmin c d) +-- | Max of 4 values. fmax4 :: Flt -> Flt -> Flt -> Flt -> Flt fmax4 !a !b !c !d = fmax (fmax a b) (fmax c d) +-- | Non-polymorphic absolute value. fabs :: Flt -> Flt fabs !a = if a < 0 then (-a) else a +-- | Non-polymorphic integer absolute value. iabs :: Int -> Int iabs !a = if a < 0 then (-a) else a +-- | Force user to use fabs or iabs, for performance reasons. Not sure if +-- this really helps, though. abs a = error "use non-polymorphic version, fabs" --- true if a and b are "almost" equal --- the (abs $ a-b) test doesn't work if --- a and b are large +-- | Approximate equality for Flt. True if a and b are "almost" equal. +-- The (abs $ a-b) test doesn't work if +-- a and b are large. about_equal :: Flt -> Flt -> Bool about_equal !a !b = if a > 1 @@ -92,33 +101,65 @@ else (fabs $ a - b) < (delta*10) - +-- | 3d type represented as a record of unboxed floats. data Vec = Vec !Flt !Flt !Flt deriving Show +-- | A Ray is made up of an origin and direction Vec. data Ray = Ray {origin, dir :: !Vec} deriving Show --data Plane = Plane {norm :: !Vec, offset :: !Flt} deriving Show +-- | Vec constructor. +vec :: Flt -> Flt -> Flt -> Vec vec !x !y !z = (Vec x y z) + +-- | Zero Vec. +vzero :: Vec vzero = Vec 0.0 0.0 0.0 --- for when we need a unit vector, but we --- don't care where it points +-- | For when we need a unit vector, but we +-- don't care where it points. +vunit :: Vec vunit = vx --- unit axis vectors +-- | Unit X vector. +vx :: Vec vx = Vec 1 0 0 + +-- | Unit y vector. +vy :: Vec vy = Vec 0 1 0 + +-- | Unit z vector. +vz :: Vec vz = Vec 0 0 1 + +-- | Negative x vector. +nvx :: Vec nvx = Vec (-1) 0 0 + +-- | Negative y vector. +nvy :: Vec nvy = Vec 0 (-1) 0 + +-- | Negative z vector. +nvz :: Vec nvz = Vec 0 0 (-1) +-- Extract x coordinate. +x :: Vec -> Flt x (Vec x_ _ _) = x_ + +-- Extract y coordinate. +y :: Vec -> Flt y (Vec _ y_ _) = y_ + +-- Extract z coordinate. +z :: Vec -> Flt z (Vec _ _ z_) = z_ --- this actually accounts for a --- noticeable amount of cpu time +-- | Access the Vec as if it were an array indexed from 0..2. +-- Note: this actually accounts for a noticeable amount of cpu +-- time in the Glome ray tracer. va :: Vec -> Int -> Flt va !(Vec x y z) !n = case n of @@ -126,6 +167,8 @@ 1 -> y 2 -> z +-- | Create a new Vec with the Nth field overwritten by new value. +-- I could have used record update syntax. vset :: Vec -> Int -> Flt -> Vec vset !(Vec x y z) !i !f = case i of @@ -133,10 +176,16 @@ 1 -> Vec x f z 2 -> Vec x y f +-- | Dot product of 2 vectors. We use this all the time. Dot product of 2 +-- normal vectors is the cosine of the angle between them. vdot :: Vec -> Vec -> Flt vdot !(Vec x1 y1 z1) !(Vec x2 y2 z2) = (x1*x2)+(y1*y2)+(z1*z2) +-- | Cross product of 2 vectors. Produces a vector perpendicular +-- to the given vectors. We use this for things like making the forward, +-- up, and right camera vectors orthogonal. If the input vectors are +-- normalized, the output vector will be as well. vcross :: Vec -> Vec -> Vec vcross !(Vec x1 y1 z1) !(Vec x2 y2 z2) = Vec @@ -144,74 +193,89 @@ ((z1 * x2) - (x1 * z2)) ((x1 * y2) - (y1 * x2)) +-- | Apply a unary Flt operator to each field of the Vec. vmap :: (Flt -> Flt) -> Vec -> Vec vmap f !v1 = Vec (f (x v1)) (f (y v1)) (f (z v1)) +-- | Apply a binary Flt operator to pairs of fields from 2 Vecs. vmap2 :: (Flt -> Flt -> Flt) -> Vec -> Vec -> Vec vmap2 f !v1 !v2 = Vec (f (x v1) (x v2)) (f (y v1) (y v2)) (f (z v1) (z v2)) +-- | Reverse the direction of a Vec. vinvert :: Vec -> Vec vinvert !(Vec x1 y1 z1) = Vec (-x1) (-y1) (-z1) +-- | Get the length of a Vec squared. We use this to avoid a slow sqrt. vlensqr :: Vec -> Flt vlensqr !v1 = vdot v1 v1 +-- | Get the length of a Vec. This is expensive because sqrt is slow. vlen :: Vec -> Flt vlen !v1 = sqrt (vdot v1 v1) +-- | Add 2 vectors. vadd :: Vec -> Vec -> Vec vadd !(Vec x1 y1 z1) !(Vec x2 y2 z2) = Vec (x1 + x2) (y1 + y2) (z1 + z2) +-- | Add 3 vectors. vadd3 :: Vec -> Vec -> Vec -> Vec vadd3 !(Vec x1 y1 z1) !(Vec x2 y2 z2) !(Vec x3 y3 z3) = Vec (x1 + x2 + x3) (y1 + y2 + y3) (z1 + z2 + z3) +-- | Subtract vectors. "vsub b a" is the vector from a to b. vsub :: Vec -> Vec -> Vec vsub !(Vec x1 y1 z1) !(Vec x2 y2 z2) = Vec (x1 - x2) (y1 - y2) (z1 - z2) +-- | Multiply corresponding fields. Rarely useful. vmul :: Vec -> Vec -> Vec vmul !(Vec x1 y1 z1) !(Vec x2 y2 z2) = Vec (x1 * x2) (y1 * y2) (z1 * z2) +-- | Add a value to all the fields of a Vec. Useful, for instance, to get +-- one corner of the bounding box around a sphere. vinc :: Vec -> Flt -> Vec vinc !(Vec x y z) !n = Vec (x + n) (y + n) (z + n) +-- | Subtract a value from all fields of a Vec. vdec :: Vec -> Flt -> Vec vdec !(Vec x y z) !n = Vec (x - n) (y - n) (z - n) +-- | Get the maximum of all corresponding fields between 2 Vecs. vmax :: Vec -> Vec -> Vec vmax !(Vec x1 y1 z1) !(Vec x2 y2 z2) = Vec (fmax x1 x2) (fmax y1 y2) (fmax z1 z2) +-- | Get the minimum of all corresponding fields between 2 Vecs. vmin :: Vec -> Vec -> Vec vmin !(Vec x1 y1 z1) !(Vec x2 y2 z2) = Vec (fmin x1 x2) (fmin y1 y2) (fmin z1 z2) +-- | Return the largest axis. Often used with "va". vmaxaxis :: Vec -> Int vmaxaxis !(Vec x y z) = if (x > y) @@ -222,27 +286,33 @@ then 1 else 2 +-- | Scale a Vec by some value. vscale :: Vec -> Flt -> Vec vscale !(Vec x y z) !fac = Vec (x * fac) (y * fac) (z * fac) +-- | Take the first Vec, and add to it the second Vec scaled by some amount. +-- This is used quite a lot in Glome. vscaleadd :: Vec -> Vec -> Flt -> Vec vscaleadd !(Vec x1 y1 z1) !(Vec x2 y2 z2) fac = Vec (x1 + (x2 * fac)) (y1 + (y2 * fac)) (z1 + (z2 * fac)) --- make the length just a little shorter +-- | Make the length of a Vec just a little shorter. vnudge :: Vec -> Vec vnudge x = vscale x (1-delta) +-- | Normalize a vector. Division is expensive, so we compute the reciprocol +-- of the length and multiply by that. The sqrt is also expensive. vnorm :: Vec -> Vec vnorm !(Vec x1 y1 z1) = let !invlen = 1.0 / (sqrt ((x1*x1)+(y1*y1)+(z1*z1))) in Vec (x1*invlen) (y1*invlen) (z1*invlen) +-- | Throw an exception if a vector hasn't been normalized. assert_norm :: Vec -> Vec assert_norm v = let l = vdot v v @@ -252,38 +322,44 @@ then error $ "vector too short: " ++ (show v) else v +-- | Get the victor bisecting two other vectors (which ought to be the same +-- length). bisect :: Vec -> Vec -> Vec bisect !v1 !v2 = vnorm (vadd v1 v2) +-- | Distance between 2 vectors. vdist :: Vec -> Vec -> Flt vdist v1 v2 = let d = vsub v2 v1 in vlen d +-- | Reflect a vector "v" off of a surface with normal "norm". reflect :: Vec -> Vec -> Vec reflect !v !norm = -- vadd v $ vscale norm $ (-2) * (vdot v norm) vscaleadd v norm $ (-2) * (vdot v norm) +-- | Reciprocol of all fields of a Vec. vrcp :: Vec -> Vec vrcp !(Vec x y z) = Vec (1/x) (1/y) (1/z) --- test for equality +-- | Test Vecs for approximate equality veq :: Vec -> Vec -> Bool veq !(Vec ax ay az) !(Vec bx by bz) = (about_equal ax bx) && (about_equal ay by) && (about_equal az bz) ---returns false on zero value +-- | Test Vecs for matching sign on all fields. Returns false if any value is +-- zero. Used by packet tracing. veqsign :: Vec -> Vec -> Bool veqsign !(Vec ax ay az) !(Vec bx by bz) = ax*bx > 0 && ay*by > 0 && az*bz > 0 --- translate a ray's origin in ray's direction by d amount +-- | Translate a ray's origin in ray's direction by d amount. ray_move :: Ray -> Flt -> Ray ray_move !(Ray orig dir) !d = (Ray (vscaleadd orig dir d) dir) --- find orthogonal vectors +-- | Find a pair of orthogonal vectors to the one given. orth :: Vec -> (Vec,Vec) orth v1 = if about_equal (vdot v1 v1) 1 @@ -298,15 +374,17 @@ in (v2,v3) else error $ "orth: unnormalized vector" ++ (show v1) --- intersect a ray with a plane --- defined by a point and a normal --- (ray need not be normalized) +-- | Intersect a ray with a plane +-- defined by a point "p" and a normal "norm". +-- (Ray does not need to be normalized.) plane_int :: Ray -> Vec -> Vec -> Vec plane_int !(Ray orig dir) !p !norm = let newo = vsub orig p dist = -(vdot norm newo) / (vdot norm dir) in vscaleadd orig dir dist +-- | Find the distance along a ray until it intersects with a plane defined +-- by a point "p" and normal "norm". plane_int_dist :: Ray -> Vec -> Vec -> Flt plane_int_dist !(Ray orig dir) !p !norm = let newo = vsub orig p @@ -322,16 +400,26 @@ -- TRANSFORMATIONS -- +-- | 3x4 Transformation matrix. These are described in most graphics texts. data Matrix = Matrix !Flt !Flt !Flt !Flt !Flt !Flt !Flt !Flt !Flt !Flt !Flt !Flt deriving Show --- this is a little faster if the matricies are non-strict +-- | A transformation. Inverting a matrix is expensive, so we keep a forward +-- transformation matrix and a reverse transformation matrix. +-- Note: This can be made a little faster if the matricies are non-strict. data Xfm = Xfm Matrix Matrix deriving Show +-- | Identity matrix. Transforming a vector by this matrix does nothing. +ident_matrix :: Matrix ident_matrix = (Matrix 1 0 0 0 0 1 0 0 0 0 1 0) + +-- | Identity transformation. +ident_xfm :: Xfm ident_xfm = Xfm ident_matrix ident_matrix +-- | Multiply two matricies. This is unrolled for efficiency, and it's also +-- a little bit easier (in my opinion) to see what's going on. mat_mult :: Matrix -> Matrix -> Matrix mat_mult (Matrix a00 a01 a02 a03 a10 a11 a12 a13 a20 a21 a22 a23) (Matrix b00 b01 b02 b03 b10 b11 b12 b13 b20 b21 b22 b23) = @@ -351,20 +439,27 @@ (a20*b02 + a21*b12 + a22*b22) (a20*b03 + a21*b13 + a22*b23 + a23) +-- | Multiply two tranformations. This just multiplies the forward and +-- reverse transformations. xfm_mult :: Xfm -> Xfm -> Xfm xfm_mult (Xfm a inva) (Xfm b invb) = Xfm (mat_mult a b) (mat_mult invb inva) -- TRANSFORM UTILITY FUNCTIONS -- --- If we multiply two transformation matricies, we get --- a transformation matrix equivalent to applying the --- second then the first. - --- By reversing the list, the transforms are applied in the expected order. +-- | There is a seemingly-magical property of transformation matricies, that +-- we can combine the effects of any number of transformations into a single +-- transformation just by multiplying them together in reverse order. For +-- instance, we could move a point, then rotate it about the origin by some +-- angle around some vector, then move it again, and this can all be done by +-- a single transformation. +-- This function combines transformations in this way, though it reverses the +-- list first so the transformations take effect in their expected order. compose :: [Xfm] -> Xfm compose xfms = check_xfm $ foldr xfm_mult ident_xfm (reverse xfms) +-- | Make sure a transformation is valid. Multipy the forward and reverse +-- matrix and verify that the result is the identity matrix. check_xfm :: Xfm -> Xfm check_xfm (Xfm m i) = let (Matrix m00 m01 m02 m03 @@ -378,7 +473,10 @@ then (Xfm m i) else error $ "corrupt matrix " ++ (show (Xfm m i)) ++ "\n" ++ (show (mat_mult m i)) --- rotate point (or vector) a about ray b by angle c +-- | Complex transformations: Rotate point (or vector) "pt" about ray by +-- angle c. The angle is in radians, +-- but using the angle conversion routines "deg", "rad" and "rot" is +-- recommended. vrotate :: Vec -> Ray -> Flt -> Vec vrotate pt (Ray orig axis_) angle = let axis = assert_norm axis_ @@ -397,7 +495,7 @@ -- TRANSFORM APPLICATION -- -- these need to be fast --- point is treated as (x y z 1) +-- | Transform a point. The point is treated as (x y z 1). xfm_point :: Xfm -> Vec -> Vec xfm_point !(Xfm (Matrix m00 m01 m02 m03 m10 m11 m12 m13 @@ -407,6 +505,7 @@ (m10*x + m11*y + m12*z + m13) (m20*x + m21*y + m22*z + m23) +-- | Inverse transform a point. invxfm_point :: Xfm -> Vec -> Vec invxfm_point !(Xfm fwd (Matrix i00 i01 i02 i03 i10 i11 i12 i13 @@ -416,7 +515,7 @@ (i10*x + i11*y + i12*z + i13) (i20*x + i21*y + i22*z + i23) --- vector is treated as (x y z 0) +-- | Transform a vector. The vector is treated as (x y z 0). xfm_vec :: Xfm -> Vec -> Vec xfm_vec !(Xfm (Matrix m00 m01 m02 m03 m10 m11 m12 m13 @@ -426,6 +525,7 @@ (m10*x + m11*y + m12*z) (m20*x + m21*y + m22*z) +-- | Inverse transform a vector. invxfm_vec :: Xfm -> Vec -> Vec invxfm_vec !(Xfm fwd (Matrix i00 i01 i02 i03 i10 i11 i12 i13 @@ -435,8 +535,8 @@ (i10*x + i11*y + i12*z) (i20*x + i21*y + i22*z) --- this one is tricky --- we transform by the inverse transpose +-- | Inverse transform a normal. This one is tricky: we need to transform +-- by the inverse transpose. invxfm_norm :: Xfm -> Vec -> Vec invxfm_norm !(Xfm fwd (Matrix i00 i01 i02 i03 i10 i11 i12 i13 @@ -446,27 +546,31 @@ (i01*x + i11*y + i21*z) (i02*x + i12*y + i22*z) +-- | Transform a Ray. xfm_ray :: Xfm -> Ray -> Ray xfm_ray !xfm !(Ray orig dir) = Ray (xfm_point xfm orig) (vnorm (xfm_vec xfm dir)) +-- | Inverse transform a Ray. +invxfm_ray :: Xfm -> Ray -> Ray invxfm_ray !xfm !(Ray orig dir) = Ray (invxfm_point xfm orig) (vnorm (invxfm_vec xfm dir)) -- BASIC TRANSFORMS -- --- move +-- | Basic transforms: move by some displacement vector. translate :: Vec -> Xfm translate (Vec x y z) = check_xfm $ Xfm (Matrix 1 0 0 x 0 1 0 y 0 0 1 z) (Matrix 1 0 0 (-x) 0 1 0 (-y) 0 0 1 (-z)) --- strectch along three axes (if x==y==z, then it's uniform scaling) +-- | Basic transforms: stretch along the three axes, by the amount +-- in the given vector. (If x==y==z, then it's uniform scaling.) scale :: Vec -> Xfm scale (Vec x y z) = check_xfm $ Xfm (Matrix x 0 0 0 0 y 0 0 0 0 z 0) (Matrix (1/x) 0 0 0 0 (1/y) 0 0 0 0 (1/z) 0) --- rotate about an arbitrary axis and angle +-- | Basic transforms: rotate about a given axis by some angle. rotate :: Vec -> Flt -> Xfm rotate v@(Vec x y z) angle = if not $ (vlen v) `about_equal` 1 @@ -490,7 +594,8 @@ check_xfm $ Xfm (Matrix m00 m01 m02 0 m10 m11 m12 0 m20 m21 m22 0) (Matrix m00 m10 m20 0 m01 m11 m21 0 m02 m12 m22 0) --- convert canonical coordinates to uvw coordinates +-- | Basic transforms: Convert coordinate system from canonical xyz +-- coordinates to uvw coordinates. xyz_to_uvw :: Vec -> Vec -> Vec -> Xfm xyz_to_uvw u v w = let Vec ux uy uz = u @@ -513,6 +618,8 @@ else error $ "unnormalized v " ++ (show v) else error $ "unnormalized u " ++ (show u) +-- | Basic transforms: Convert from uvw coordinates back to normal xyz +-- coordinates. uvw_to_xyz :: Vec -> Vec -> Vec -> Xfm uvw_to_xyz (Vec ux uy uz) (Vec vx vy vz) (Vec wx wy wz) = check_xfm $ Xfm (Matrix ux uy uz 0 vx vy vz 0 wx wy wz 0) @@ -522,7 +629,8 @@ -- TRIANGLE UTILITY FUNCTIONS -- --- given a side, angle, and side of a triangle, produce the length of the opposite side +-- | Given a side, angle, and side of a triangle, produce the length of the +-- opposite side. sas2s :: Flt -> Flt -> Flt -> Flt sas2s s1 a s2 = sqrt (((s1 * s1) + (s2 * s2)) - ((2 * s1 * s2 * (dcos a)))) @@ -530,24 +638,30 @@ -- BOUNDING BOXES -- +-- | Axis-aligned Bounding Box (AABB), defined by opposite corners. P1 is the +-- min values, p2 has the max values. data Bbox = Bbox {p1 :: !Vec, p2 :: !Vec} deriving Show + +-- | A near-far pair of distances. Basically just a tuple. data Interval = Interval !Flt !Flt deriving Show -- used instead of a tuple ---union of two bounding boxes +-- | Bounding box that encloses two bounding boxes. bbjoin :: Bbox -> Bbox -> Bbox bbjoin (Bbox p1a p2a) (Bbox p1b p2b) = (Bbox (vmin p1a p1b) (vmax p2a p2b)) ---overlap of two bounding boxes +-- | Find the overlap of two bounding boxes. bboverlap :: Bbox -> Bbox -> Bbox bboverlap (Bbox p1a p2a) (Bbox p1b p2b) = (Bbox (vmax p1a p1b) (vmin p2a p2b)) +-- | Test if a Vec is inside the bounding box. bbinside :: Bbox -> Vec -> Bool bbinside (Bbox (Vec p1x p1y p1z) (Vec p2x p2y p2z)) (Vec x y z) = p1x <= x && x <= p2x && p1y <= y && y <= p2y && p1z <= z && z <= p2z ---split a bounding box into two +-- | Split a bounding box into two, given an axis and offset. Throw exception +-- if the offset isn't inside the bounding box. bbsplit :: Bbox -> Int -> Flt -> (Bbox,Bbox) bbsplit (Bbox p1 p2) axis offset = if (offset < (va p1 axis)) || (offset > (va p2 axis)) @@ -555,7 +669,7 @@ else ((Bbox p1 (vset p2 axis offset)), (Bbox (vset p1 axis offset) p2)) --- generate a bounding box from a list of points +-- | Generate a minimum bounding box that encloses a list of points. bbpts :: [Vec] -> Bbox bbpts [] = empty_bbox bbpts ((Vec x y z):[]) = @@ -572,26 +686,33 @@ maxz = fmax (z+delta) p2z in Bbox (Vec minx miny minz) (Vec maxx maxy maxz) --- surface area, volume of bounding boxes +-- | Surface area of a bounding box. Useful for cost heuristics when attempting +-- to build optimal bounding box heirarchies. Undefined for degenerate bounding +-- boxes. bbsa :: Bbox -> Flt bbsa (Bbox p1 p2) = let Vec dx dy dz = vsub p2 p1 in dx*dy + dx*dz + dy*dz +-- | Volume of a bounding box. Undefined for degenerate bounding boxes. bbvol :: Bbox -> Flt bbvol (Bbox p1 p2) = let (Vec dx dy dz) = vsub p2 p1 in dx*dy*dz +-- | Degenerate bounding box that contains an empty volume. +empty_bbox :: Bbox empty_bbox = Bbox (Vec infinity infinity infinity) (Vec (-infinity) (-infinity) (-infinity)) +-- | "Infinite" bounding box. +everything_bbox :: Bbox everything_bbox = Bbox (Vec (-infinity) (-infinity) (-infinity)) (Vec infinity infinity infinity) --- Find a ray's entrance and exit from a bounding +-- | Find a ray's entrance and exit from a bounding -- box. If last entrance is before the first exit, -- we hit. Otherwise, we miss. (It's up to the -- caller to figure that out.) diff --git a/GlomeVec.cabal b/GlomeVec.cabal --- a/GlomeVec.cabal +++ b/GlomeVec.cabal @@ -1,5 +1,5 @@ Name: GlomeVec -Version: 0.1 +Version: 0.1.1 Synopsis: Simple 3D vector library Description: A simple library for dealing with 3D vectors, suitable for graphics projects. A small texture library with Perlin noise is included as well. License: GPL