packages feed

HGamer3D-Data 0.1.5 → 0.1.7

raw patch · 8 files changed

+42/−581 lines, 8 filesdep +vectdep −Vecdep −Vec-Transform

Dependencies added: vect

Dependencies removed: Vec, Vec-Transform

Files

HGamer3D-Data.cabal view
@@ -1,17 +1,12 @@ Name:                HGamer3D-Data
-Version:             0.1.5
+Version:             0.1.7
 Synopsis:            Library to enable 3D game development for Haskell - Data
 Description:         
 	Library, to enable 3D game development for Haskell,
 	based on bindings to 3D Graphics, Audio and GUI libraries.
-	THIS MODULE: Basic Data Types
-    List of features and modules: 
-	  Data Module (Basic Data Types),
-      OGRE Binding (3D Graphics Engine), 
-      OIS Binding (Input System),
-      cAudio Binding (Audio),
-      CEGUI Binding (GUI System),
-      APIs (Haskell style APIs, different ways, to approach API)
+	
+	This module provides the basic data types.
+
     Platform: Windows only
 	License: Apache License, Version 2.0
 	Install: see http://www.althainz.de/HGamer3D/Download-and-Installation.html
@@ -27,9 +22,9 @@ Extra-source-files:  Setup.hs 
 
 Library
-  Build-Depends:     base >= 3 && < 5, Vec == 0.9.7, Vec-Transform == 1.0.4
+  Build-Depends:     base >= 3 && < 5, vect >= 0.4.7
 
-  Exposed-modules:   HGamer3D.Data.Vector2,HGamer3D.Data.Vector3,HGamer3D.Data.Vector4,HGamer3D.Data.Matrix4,HGamer3D.Data.Colour,HGamer3D.Data.Quaternion,HGamer3D.Data.HG3DClass,HGamer3D.Data.Angle
+  Exposed-modules:   HGamer3D.Data.Vector,HGamer3D.Data.Colour,HGamer3D.Data.HG3DClass,HGamer3D.Data.Angle
   Other-modules:     
 
   c-sources:
HGamer3D/Data/HG3DClass.hs view
@@ -51,6 +51,8 @@   poke p (HG3DClass ptr fptr) = do
     (\ptr val -> do {pokeByteOff ptr 0 (val::(Ptr ()))}) p (ptr)
     (\ptr val -> do {pokeByteOff ptr 4 (val::(Ptr ()))}) p (fptr)
+    
+
− HGamer3D/Data/Matrix4.hs 
@@ -1,115 +0,0 @@--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- (c) 2011 Peter Althainz
---
--- Licensed under the Apache License, Version 2.0 (the "License");
--- you may not use this file except in compliance with the License.
--- You may obtain a copy of the License at
---
---     http://www.apache.org/licenses/LICENSE-2.0
---
--- Unless required by applicable law or agreed to in writing, software
--- distributed under the License is distributed on an "AS IS" BASIS,
--- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--- See the License for the specific language governing permissions and
--- limitations under the License.
-
--- Matrix4.hs, the 4x4 matrix type 
-
-module HGamer3D.Data.Matrix4 
-
-(
-	Matrix4,
-	HGamer3D.Data.Matrix4.matToLists,
-	HGamer3D.Data.Matrix4.matFromLists,
-	extendV3,
-	oneV3,
-	zeroV3,
-	toV3,
-	HGamer3D.Data.Matrix4.multvm,
-	HGamer3D.Data.Matrix4.multmv,
-	HGamer3D.Data.Matrix4.multmm,
-	HGamer3D.Data.Matrix4.transpose,
-	
-	HGamer3D.Data.Matrix4.translation,
-	HGamer3D.Data.Matrix4.rotationX,
-	HGamer3D.Data.Matrix4.rotationY,
-	HGamer3D.Data.Matrix4.rotationZ,
-	HGamer3D.Data.Matrix4.rotationVec,
-	HGamer3D.Data.Matrix4.rotationEuler,
-	HGamer3D.Data.Matrix4.rotationQuat
-)
-
-where
-
-import Data.Vec.Base
-import Data.Vec.Nat
-import Data.Vec.Packed
-import Data.Vec.LinAlg
-import Data.Vec.LinAlg.Transform3D
-import HGamer3D.Data.Vector3
-import HGamer3D.Data.Vector4
-import HGamer3D.Data.Quaternion
-
-newtype Matrix4 = Matrix4 (Mat44 Float)
-
-matToLists :: Matrix4 -> [[Float]]
-matToLists (Matrix4 mat) = Data.Vec.Base.matToLists mat
-
-matFromLists :: [[Float]] -> Matrix4
-matFromLists lists = Matrix4 $ Data.Vec.Base.matFromLists lists
-
-extendV3 :: Vector3 -> Float -> Vector4
-extendV3 v3 f = vector4 (v3X v3) (v3X v3) (v3Z v3) f
-
-oneV3 :: Vector3 -> Vector4
-oneV3 v3 = extendV3 v3 1.0
-
-zeroV3 :: Vector3 -> Vector4
-zeroV3 v3 = extendV3 v3 0.0
-
-toV3 :: Vector4 -> Vector3
-toV3 v4 = vector3 (v4X v4) (v4Y v4) (v4Z v4)
-
-multvm :: Vector4 -> Matrix4 -> Vector4
-multvm (Vector4 v) (Matrix4 m) = Vector4 $ pack (Data.Vec.LinAlg.multvm (unpack v) m)
-
-multmv :: Matrix4 -> Vector4 -> Vector4
-multmv (Matrix4 m) (Vector4 v) = Vector4 $ pack (Data.Vec.LinAlg.multmv m (unpack v))
-
-multmm :: Matrix4 -> Matrix4 -> Matrix4
-multmm (Matrix4 m1) (Matrix4 m2) = Matrix4 (Data.Vec.LinAlg.multmm m1 m2)
-
-transpose :: Matrix4 -> Matrix4
-transpose (Matrix4 m) = Matrix4 (Data.Vec.LinAlg.transpose m)
-
-translation :: Vector3 -> Matrix4
-translation (Vector3 v)  = Matrix4 (Data.Vec.LinAlg.Transform3D.translation (unpack v) )
-
-rotationX :: Float -> Matrix4
-rotationX f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationX f )
-
-rotationY :: Float -> Matrix4
-rotationY f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationY f )
-
-rotationZ :: Float -> Matrix4
-rotationZ f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationZ f )
-
-rotationVec :: Vector3 -> Float -> Matrix4
-rotationVec (Vector3 v) f  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationVec (unpack v) f )
-
-rotationEuler :: Vector3 -> Matrix4
-rotationEuler (Vector3 v)  = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationEuler (unpack v) )
-
-rotationQuat :: Quaternion -> Matrix4
-rotationQuat q = Matrix4 (Data.Vec.LinAlg.Transform3D.rotationQuat v4 ) where
-	w = qW q
-	v = qV q
-	x = v3X v
-	y = v3Y v
-	z = v3Z v
-	v4 = x :. y :. z :. w :. ()
-
-
− HGamer3D/Data/Quaternion.hs 
@@ -1,87 +0,0 @@--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- (c) 2011 Peter Althainz
---
--- Licensed under the Apache License, Version 2.0 (the "License");
--- you may not use this file except in compliance with the License.
--- You may obtain a copy of the License at
---
---     http://www.apache.org/licenses/LICENSE-2.0
---
--- Unless required by applicable law or agreed to in writing, software
--- distributed under the License is distributed on an "AS IS" BASIS,
--- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--- See the License for the specific language governing permissions and
--- limitations under the License.
-
--- Quaternion.hs
-
-module HGamer3D.Data.Quaternion 
-
-(
-	-- export Quaternion Type again
-	Quaternion (Quaternion, qW, qV),
-	quaternion,
-	mulQ,
-	conjQ,
-	normQ,
-	normalizeQ,
-	dotQ,
-	rotateVQ,
-	fromRotationQ
-	
-	-- export all functions
-)
-
-where
-
-import HGamer3D.Data.Vector3
-import HGamer3D.Data.Vector4 (Vector4, vector4)
-
-data Quaternion = Quaternion {
-  qW :: Float,
-  qV :: Vector3
-} deriving (Eq, Show)
-
-quaternion w x y z = Quaternion w (vector3 x y z)
-
-mulQ :: Quaternion -> Quaternion -> Quaternion
-mulQ q1 q2 = Quaternion ((w1 * w2) - (v1 `dotV3` v2)) ( (scaleV3 w1 v2) + (scaleV3 w2 v1) + (v1 `crossV3` v2) )  where
-	w1 = qW q1
-	w2 = qW q2
-	v1 = qV q1
-	v2 = qV q2 
-
-conjQ :: Quaternion -> Quaternion
-conjQ q = Quaternion (qW q) (scaleV3 (-1.0) (qV q)) 
-
-normQ :: Quaternion -> Float 
-normQ q = sqrt $ dotQ q (conjQ q)
-
-normalizeQ :: Quaternion -> Quaternion
-normalizeQ q = Quaternion ( (qW q) / n ) ( (scaleV3 (1/n)) (qV q) ) where
-	n = normQ q
-
-dotQ :: Quaternion -> Quaternion -> Float
-dotQ q1 q2 = (w1 * w2) + (v1 `dotV3` v2) where
-	w1 = qW q1
-	w2 = qW q2
-	v1 = qV q1
-	v2 = qV q2 
- 
-fromRotationQ :: Float -> Vector3 -> Quaternion
-fromRotationQ a v = Quaternion (cos h) (scaleV3 s v) where
-					h = a/2.0
-					s = sin h
-
-rotateVQ :: Vector3 -> Quaternion -> Vector3
-rotateVQ v q = qV (mulQ q (mulQ v' q')) where 
-	v' = Quaternion 0.0 v
-	q' = conjQ q
-
-toVector4 :: Quaternion -> Vector4
-toVector4 q = vector4 (v3X v) (v3Y v) (v3Z v) w where
-	v = qV q
-	w = qW q
+ HGamer3D/Data/Vector.hs view
@@ -0,0 +1,34 @@+-- This source file is part of HGamer3D
+-- (A project to enable 3D game development in Haskell)
+-- For the latest info, see http://www.althainz.de/HGamer3D.html
+--
+-- (c) 2011 Peter Althainz
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+
+-- Vector2.hs
+
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module HGamer3D.Data.Vector
+
+(
+		module Data.Vect.Float,
+		module Data.Vect.Float.Util.Quaternion
+)
+
+where
+
+import Data.Vect.Float
+import Data.Vect.Float.Util.Quaternion
+
− HGamer3D/Data/Vector2.hs 
@@ -1,118 +0,0 @@--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- (c) 2011 Peter Althainz
---
--- Licensed under the Apache License, Version 2.0 (the "License");
--- you may not use this file except in compliance with the License.
--- You may obtain a copy of the License at
---
---     http://www.apache.org/licenses/LICENSE-2.0
---
--- Unless required by applicable law or agreed to in writing, software
--- distributed under the License is distributed on an "AS IS" BASIS,
--- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--- See the License for the specific language governing permissions and
--- limitations under the License.
-
--- Vector2.hs
-
-module HGamer3D.Data.Vector2 
-
-(
-	-- export Vector2 Type and its functions again
-	
-	Vector2 (Vector2),
-	vector2,
-	uniV2,
-	v2X,v2Y,
-	HGamer3D.Data.Vector2.dotV2,
-	HGamer3D.Data.Vector2.normSqV2,
-	HGamer3D.Data.Vector2.normV2,
-	HGamer3D.Data.Vector2.normalizeV2,
-	HGamer3D.Data.Vector2.scaleV2
-	
-)
-
-where
-
-import Data.Vec.Base
-import Data.Vec.Nat
-import Data.Vec.Packed
-import Data.Vec.LinAlg
-
-newtype Vector2 = Vector2 Vec2F
-
-vector2 :: Float -> Float -> Vector2
-vector2 a b = Vector2 ( pack (a :. b :. ()) )
-
-uniV2 :: Float -> Vector2
-uniV2 f = Vector2 (pack (vec f))
-
-v2X :: Vector2 -> Float
-v2X (Vector2 v2) = get n0 v2
-
-v2Y :: Vector2 -> Float
-v2Y (Vector2 v2) = get n1 v2
-
-
-
-liftv :: (a -> Vec2F) -> (a -> Vector2)
-liftv f = f1 where
-	f1 a1 = (Vector2 (f a1)) 
-
-
-lift1 :: (Vec2F -> a) -> (Vector2 -> a)
-lift1 f = f1 where
-	f1 (Vector2 a1) = f a1 
-
-lift1v :: (Vec2F -> Vec2F) -> (Vector2 -> Vector2)
-lift1v f = f2 where
-	f2 a = (Vector2 (f1 a))
-	f1 (Vector2 a1) = f a1 
-
-lift2 :: (Vec2F -> Vec2F -> a) -> (Vector2 -> Vector2 -> a)
-lift2 f = f1 where
-	f1 (Vector2 a1) (Vector2 b1) = f a1 b1 
-
-lift2v :: (Vec2F -> Vec2F -> Vec2F) -> (Vector2 -> Vector2 -> Vector2)
-lift2v f = f2 where
-	f2 a b = (Vector2 (f1 a b))
-	f1 (Vector2 a1) (Vector2 b1) = f a1 b1 
-
-lift2vp :: (Vec2 Float -> Vec2 Float -> Vec2 Float) -> (Vector2 -> Vector2 -> Vector2)
-lift2vp f = f2 where
-	f2 a b = (Vector2 (pack (f1 a b)))
-	f1 (Vector2 (Vec2F a1 a2)) (Vector2 (Vec2F b1 b2)) = f (a1 :. a2 :.  ()) (b1 :. b2 :. ()) 
-
-instance Show Vector2 where
-	show = lift1 (Prelude.show)
-	
-instance Eq Vector2 where
-	(==) = lift2 (Prelude.==)
-	 
-instance Num Vector2 where
-	abs = lift1v (Prelude.abs)
-	signum = lift1v (Prelude.signum)
-	fromInteger = liftv (Prelude.fromInteger)
-
-	(+) = lift2v (Prelude.+)
-	(-) = lift2v (Prelude.-)
-	(*) = lift2v (Prelude.*)
-
-dotV2 :: Vector2 -> Vector2 -> Float
-dotV2 = lift2 Data.Vec.LinAlg.dot
-
-normSqV2 :: Vector2 -> Float
-normSqV2 = lift1 Data.Vec.LinAlg.normSq
-
-normV2 :: Vector2 -> Float
-normV2 = lift1 Data.Vec.LinAlg.norm
-
-normalizeV2 :: Vector2 -> Vector2
-normalizeV2 = lift1v Data.Vec.LinAlg.normalize
-
-scaleV2 :: Float -> Vector2 -> Vector2
-scaleV2 f (Vector2 v) = Vector2 (Data.Vec.Base.map (*f) v)
-
− HGamer3D/Data/Vector3.hs 
@@ -1,125 +0,0 @@--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- (c) 2011 Peter Althainz
---
--- Licensed under the Apache License, Version 2.0 (the "License");
--- you may not use this file except in compliance with the License.
--- You may obtain a copy of the License at
---
---     http://www.apache.org/licenses/LICENSE-2.0
---
--- Unless required by applicable law or agreed to in writing, software
--- distributed under the License is distributed on an "AS IS" BASIS,
--- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--- See the License for the specific language governing permissions and
--- limitations under the License.
-
--- Vector3.hs
-
-module HGamer3D.Data.Vector3 
-
-(
-	-- export Vector3 Type and its functions again
-	
-	Vector3 (Vector3),
-	vector3,
-	uniV3,
-	v3X,v3Y,v3Z,
-	HGamer3D.Data.Vector3.dotV3,
-	HGamer3D.Data.Vector3.normSqV3,
-	HGamer3D.Data.Vector3.normV3,
-	HGamer3D.Data.Vector3.normalizeV3,
-	HGamer3D.Data.Vector3.crossV3,
-	HGamer3D.Data.Vector3.scaleV3
-	
-)
-
-where
-
-import Data.Vec.Base
-import Data.Vec.Nat
-import Data.Vec.Packed
-import Data.Vec.LinAlg
-
-newtype Vector3 = Vector3 Vec3F
-
-vector3 :: Float -> Float -> Float -> Vector3
-vector3 a b c = Vector3 ( pack (a :. b :. c :. ()) )
-
-uniV3 :: Float -> Vector3
-uniV3 f = Vector3 (pack (vec f))
-
-v3X :: Vector3 -> Float
-v3X (Vector3 v3) = get n0 v3
-
-v3Y :: Vector3 -> Float
-v3Y (Vector3 v3) = get n1 v3
-
-v3Z :: Vector3 -> Float
-v3Z (Vector3 v3) = get n2 v3
-
-
-
-liftv :: (a -> Vec3F) -> (a -> Vector3)
-liftv f = f1 where
-	f1 a1 = (Vector3 (f a1)) 
-
-
-lift1 :: (Vec3F -> a) -> (Vector3 -> a)
-lift1 f = f1 where
-	f1 (Vector3 a1) = f a1 
-
-lift1v :: (Vec3F -> Vec3F) -> (Vector3 -> Vector3)
-lift1v f = f2 where
-	f2 a = (Vector3 (f1 a))
-	f1 (Vector3 a1) = f a1 
-
-lift2 :: (Vec3F -> Vec3F -> a) -> (Vector3 -> Vector3 -> a)
-lift2 f = f1 where
-	f1 (Vector3 a1) (Vector3 b1) = f a1 b1 
-
-lift2v :: (Vec3F -> Vec3F -> Vec3F) -> (Vector3 -> Vector3 -> Vector3)
-lift2v f = f2 where
-	f2 a b = (Vector3 (f1 a b))
-	f1 (Vector3 a1) (Vector3 b1) = f a1 b1 
-
-lift2vp :: (Vec3 Float -> Vec3 Float -> Vec3 Float) -> (Vector3 -> Vector3 -> Vector3)
-lift2vp f = f2 where
-	f2 a b = (Vector3 (pack (f1 a b)))
-	f1 (Vector3 (Vec3F a1 a2 a3)) (Vector3 (Vec3F b1 b2 b3)) = f (a1 :. a2 :. a3 :. ()) (b1 :. b2 :. b3 :. ()) 
-
-instance Show Vector3 where
-	show = lift1 (Prelude.show)
-	
-instance Eq Vector3 where
-	(==) = lift2 (Prelude.==)
-	 
-instance Num Vector3 where
-	abs = lift1v (Prelude.abs)
-	signum = lift1v (Prelude.signum)
-	fromInteger = liftv (Prelude.fromInteger)
-
-	(+) = lift2v (Prelude.+)
-	(-) = lift2v (Prelude.-)
-	(*) = lift2v (Prelude.*)
-
-dotV3 :: Vector3 -> Vector3 -> Float
-dotV3 = lift2 Data.Vec.LinAlg.dot
-
-normSqV3 :: Vector3 -> Float
-normSqV3 = lift1 Data.Vec.LinAlg.normSq
-
-normV3 :: Vector3 -> Float
-normV3 = lift1 Data.Vec.LinAlg.norm
-
-normalizeV3 :: Vector3 -> Vector3
-normalizeV3 = lift1v Data.Vec.LinAlg.normalize
-
-crossV3 :: Vector3 -> Vector3 -> Vector3
-crossV3 = lift2vp Data.Vec.LinAlg.cross
-
-scaleV3 :: Float -> Vector3 -> Vector3
-scaleV3 f (Vector3 v) = Vector3 (Data.Vec.Base.map (*f) v)
-
− HGamer3D/Data/Vector4.hs 
@@ -1,125 +0,0 @@--- This source file is part of HGamer3D
--- (A project to enable 3D game development in Haskell)
--- For the latest info, see http://www.althainz.de/HGamer3D.html
---
--- (c) 2011 Peter Althainz
---
--- Licensed under the Apache License, Version 2.0 (the "License");
--- you may not use this file except in compliance with the License.
--- You may obtain a copy of the License at
---
---     http://www.apache.org/licenses/LICENSE-2.0
---
--- Unless required by applicable law or agreed to in writing, software
--- distributed under the License is distributed on an "AS IS" BASIS,
--- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--- See the License for the specific language governing permissions and
--- limitations under the License.
-
--- Vector4.hs
-
-module HGamer3D.Data.Vector4 
-
-(
-	-- export Vector4 Type and its functions again
-	
-	Vector4 (Vector4),
-	vector4,
-	uniV4,
-	v4X,v4Y,v4Z,v4W,
-	HGamer3D.Data.Vector4.dotV4,
-	HGamer3D.Data.Vector4.normSqV4,
-	HGamer3D.Data.Vector4.normV4,
-	HGamer3D.Data.Vector4.normalizeV4,
-	HGamer3D.Data.Vector4.scaleV4
-	
-)
-
-where
-
-import Data.Vec.Base
-import Data.Vec.Nat
-import Data.Vec.Packed
-import Data.Vec.LinAlg
-
-
-newtype Vector4 = Vector4 Vec4F
-
-vector4 :: Float -> Float -> Float -> Float -> Vector4
-vector4 a b c d = Vector4 ( pack (a :. b :. c :. d :. ()) )
-
-uniV4 :: Float -> Vector4
-uniV4 f = Vector4 (pack (vec f))
-
-v4X :: Vector4 -> Float
-v4X (Vector4 v4) = get n0 v4
-
-v4Y :: Vector4 -> Float
-v4Y (Vector4 v4) = get n1 v4
-
-v4Z :: Vector4 -> Float
-v4Z (Vector4 v4) = get n2 v4
-
-v4W :: Vector4 -> Float
-v4W (Vector4 v4) = get n3 v4
-
-
-
-liftv :: (a -> Vec4F) -> (a -> Vector4)
-liftv f = f1 where
-	f1 a1 = (Vector4 (f a1)) 
-
-
-lift1 :: (Vec4F -> a) -> (Vector4 -> a)
-lift1 f = f1 where
-	f1 (Vector4 a1) = f a1 
-
-lift1v :: (Vec4F -> Vec4F) -> (Vector4 -> Vector4)
-lift1v f = f2 where
-	f2 a = (Vector4 (f1 a))
-	f1 (Vector4 a1) = f a1 
-
-lift2 :: (Vec4F -> Vec4F -> a) -> (Vector4 -> Vector4 -> a)
-lift2 f = f1 where
-	f1 (Vector4 a1) (Vector4 b1) = f a1 b1 
-
-lift2v :: (Vec4F -> Vec4F -> Vec4F) -> (Vector4 -> Vector4 -> Vector4)
-lift2v f = f2 where
-	f2 a b = (Vector4 (f1 a b))
-	f1 (Vector4 a1) (Vector4 b1) = f a1 b1 
-
-lift2vp :: (Vec4 Float -> Vec4 Float -> Vec4 Float) -> (Vector4 -> Vector4 -> Vector4)
-lift2vp f = f2 where
-	f2 a b = (Vector4 (pack (f1 a b)))
-	f1 (Vector4 (Vec4F a1 a2 a3 a4)) (Vector4 (Vec4F b1 b2 b3 b4)) = f (a1 :. a2 :. a3 :. a4 :. ()) (b1 :. b2 :. b3 :. b4 :. ()) 
-
-instance Show Vector4 where
-	show = lift1 (Prelude.show)
-	
-instance Eq Vector4 where
-	(==) = lift2 (Prelude.==)
-	 
-instance Num Vector4 where
-	abs = lift1v (Prelude.abs)
-	signum = lift1v (Prelude.signum)
-	fromInteger = liftv (Prelude.fromInteger)
-
-	(+) = lift2v (Prelude.+)
-	(-) = lift2v (Prelude.-)
-	(*) = lift2v (Prelude.*)
-
-dotV4 :: Vector4 -> Vector4 -> Float
-dotV4 = lift2 Data.Vec.LinAlg.dot
-
-normSqV4 :: Vector4 -> Float
-normSqV4 = lift1 Data.Vec.LinAlg.normSq
-
-normV4 :: Vector4 -> Float
-normV4 = lift1 Data.Vec.LinAlg.norm
-
-normalizeV4 :: Vector4 -> Vector4
-normalizeV4 = lift1v Data.Vec.LinAlg.normalize
-
-scaleV4 :: Float -> Vector4 -> Vector4
-scaleV4 f (Vector4 v) = Vector4 (Data.Vec.Base.map (*f) v)
-