Skip to content

STMatrix added #2

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Mar 8, 2015
Merged

STMatrix added #2

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
e6957d9
initial commit for STMatrix
mgmeier Mar 5, 2015
37d9665
some ST functions for Mat4
mgmeier Mar 6, 2015
dcafc8c
nicer test case
mgmeier Mar 6, 2015
48225eb
remove stack from datatype
mgmeier Mar 8, 2015
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
remove stack from datatype
  • Loading branch information
@mgmeier
mgmeier committed Mar 8, 2015
commit 48225eb44e771be4582b09c6ca7afe3b4a1d7f89
188 changes: 27 additions & 161 deletions docs/Module.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -358,8 +358,8 @@ Creates a transform from a basis consisting of 3 linearly independent V.Vectors.
#### `STMat`

``` purescript
data STMat s h a
= STMat [[a]] (STArray h a)
newtype STMat s h a
= STMat (STArray h a)
```


Expand All @@ -376,19 +376,20 @@ unsafeThaw :: forall a h. [a] -> STArray h a
```


#### `STMat4`
#### `cloneSTMat`

``` purescript
type STMat4 h = STMat Four h Number
cloneSTMat :: forall s h a r. STMat s h a -> Eff (st :: ST h | r) (STMat s h a)
```


#### `identityST`

``` purescript
identityST :: forall s h r. (M.Matrix (M.Mat s) Number) => STMat s h Number -> Eff (st :: ST h | r) (STMat s h Number)
identityST :: forall s h r. (M.Matrix (M.Mat s) Number) => Eff (st :: ST h | r) (STMat s h Number)
```


#### `transposeST`

``` purescript
Expand All @@ -399,7 +400,7 @@ transposeST :: forall s h r a. (M.Matrix (M.Mat s) a) => STMat s h a -> Eff (st
#### `scaleSTMatrixInt`

``` purescript
scaleSTMatrixInt :: forall a h r. (Num a) => Fn2 a (STArray h a) (Eff (st :: ST h | r) (STArray h a))
scaleSTMatrixInt :: forall a h r. (Num a) => a -> STArray h a -> Eff (st :: ST h | r) Unit
```

#### `scaleSTMatrix`
Expand All @@ -415,20 +416,6 @@ scaleSTMatrix :: forall s a h r. (Num a) => a -> STMat s h a -> Eff (st :: ST h
fromMatrix :: forall s h r a. M.Mat s a -> Eff (st :: ST h | r) (STMat s h a)
```

#### `stackPush`

``` purescript
stackPush :: forall s h r a. STMat s h a -> Eff (st :: ST h | r) (STMat s h a)
```


#### `stackPop`

``` purescript
stackPop :: forall s h r a. STMat s h a -> Eff (st :: ST h | r) (STMat s h a)
```


#### `runSTMatrixInt`

``` purescript
Expand All @@ -444,189 +431,68 @@ runSTMatrix :: forall s a r. (forall h. Eff (st :: ST h | r) (STMat s h a)) -> E



## Module Data.ST.Matrix3

#### `Mat3`

``` purescript
type Mat3 = Mat Three Number
```


#### `mat3`

``` purescript
mat3 :: [Number] -> Mat3
```


#### `normalFromMat4`

``` purescript
normalFromMat4 :: Mat Four Number -> Maybe Mat3
```



## Module Data.ST.Matrix4

#### `Vec3N`

``` purescript
type Vec3N = V3.Vec3 Number
```


#### `Mat4`

``` purescript
type Mat4 = Mat Four Number
```


#### `mat4`

``` purescript
mat4 :: [Number] -> Mat4
```


#### `transform`

``` purescript
transform :: Mat4 -> Vec3N -> Vec3N
```

Multiply a V.Vector by a 4x4 matrix: m * v

#### `inverseOrthonormal`

``` purescript
inverseOrthonormal :: Mat4 -> Mat4
```

#### `makeFrustum`

``` purescript
makeFrustum :: Number -> Number -> Number -> Number -> Number -> Number -> Mat4
```

#### `makePerspective`
#### `STMat4`

``` purescript
makePerspective :: Number -> Number -> Number -> Number -> Mat4
type STMat4 h = STMat Four h Number
```

#### `makeOrtho`

``` purescript
makeOrtho :: Number -> Number -> Number -> Number -> Number -> Number -> Mat4
```

#### `makeOrtho2D`
#### `rotateSTInt`

``` purescript
makeOrtho2D :: Number -> Number -> Number -> Number -> Mat4
rotateSTInt :: forall h r. Number -> [Number] -> STArray h Number -> Eff (st :: ST h | r) Unit
```

#### `mul`
#### `rotateST`

``` purescript
mul :: Mat4 -> Mat4 -> Mat4
rotateST :: forall h r. Number -> Vec3N -> STMat4 h -> Eff (st :: ST h | r) (STMat4 h)
```

Matrix multiplcation: a * b

#### `mulAffine`
#### `translate3STInt`

``` purescript
mulAffine :: Mat4 -> Mat4 -> Mat4
translate3STInt :: forall h r. [Number] -> STArray h Number -> Eff (st :: ST h | r) Unit
```

Matrix multiplication, assuming a and b are affine: a * b

#### `makeRotate`
#### `translateST`

``` purescript
makeRotate :: Number -> Vec3N -> Mat4
translateST :: forall h r. Vec3N -> STMat4 h -> Eff (st :: ST h | r) (STMat4 h)
```

Creates a transformation matrix for rotation in radians about the 3-element V.Vector axis.

#### `rotate`

``` purescript
rotate :: Number -> Vec3N -> Mat4 -> Mat4
```

Concatenates a rotation in radians about an axis to the given matrix.
## Module Test

#### `makeScale3`
#### `ble`

``` purescript
makeScale3 :: Number -> Number -> Number -> Mat4
ble :: forall h r. Eff (st :: ST h | r) (M.STMat4 h)
```

#### `makeScale`

``` purescript
makeScale :: Vec3N -> Mat4
```

#### `scale3`
#### `meh`

``` purescript
scale3 :: Number -> Number -> Number -> Mat4 -> Mat4
meh :: M.Vec3N
```

Concatenates a scaling to the given matrix.

#### `scale`
#### `ys`

``` purescript
scale :: Vec3N -> Mat4 -> Mat4
ys :: M.Mat4
```

Concatenates a scaling to the given matrix.

#### `makeTranslate3`

``` purescript
makeTranslate3 :: Number -> Number -> Number -> Mat4
```

#### `makeTranslate`

``` purescript
makeTranslate :: Vec3N -> Mat4
```

#### `translate3`

``` purescript
translate3 :: Number -> Number -> Number -> Mat4 -> Mat4
```

Concatenates a translation to the given matrix.

#### `translate`

``` purescript
translate :: Vec3N -> Mat4 -> Mat4
```

Concatenates a translation to the given matrix.

#### `makeLookAt`
#### `zs`

``` purescript
makeLookAt :: Vec3N -> Vec3N -> Vec3N -> Mat4
```

#### `makeBasis`

``` purescript
makeBasis :: Vec3N -> Vec3N -> Vec3N -> Mat4
```

Creates a transform from a basis consisting of 3 linearly independent V.Vectors.
zs :: M.Mat4
```
35 changes: 9 additions & 26 deletions src/Data/ST/Matrix.purs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,7 +34,7 @@ import Prelude.Unsafe
import Math


data STMat s h a = STMat [[a]] (STArray h a)
newtype STMat s h a = STMat (STArray h a)
{-
instance sstm2 :: Sized (STMat Two h a) where
sized v = 2
Expand Down Expand Up @@ -82,25 +82,22 @@ foreign import unsafeThaw """
return arr;
}""" :: forall a h. [a] -> STArray h a

cloneSTMat :: forall s h a r. (STMat s h a) -> Eff (st :: ST h | r) (STMat s h a)
cloneSTMat (STMat arr) = STMat <<< unsafeThaw <$> freeze arr


-- TODO unify slicing by splitting function in Data.Matrix


-- careful, clears stack!
identityST :: forall s h r. (M.Matrix (M.Mat s) Number) => Eff (st :: ST h | r) (STMat s h Number)
identityST =
let m = M.identity :: M.Mat s Number
in STMat [] <$> thaw (M.toArray m)
in STMat <$> thaw (M.toArray m)

transposeST :: forall s h r a. (M.Matrix (M.Mat s) a) => (STMat s h a) -> Eff (st :: ST h | r) (STMat s h a)
transposeST (STMat st arr) =
transposeST (STMat arr) =
let
x = unsafeFreeze arr
m = M.fromArray x :: M.Mat s a
m' = M.transpose m
ar' = unsafeThaw $ M.toArray $ m'
in return (STMat st ar') -- TODO needs testing!
in return (STMat ar') -- TODO needs testing!

{-
instance eqMat :: (Eq a) => Eq (Mat s a) where
Expand Down Expand Up @@ -140,29 +137,15 @@ foreign import scaleSTMatrixInt """
}""" :: forall a h r. (Num a) => a -> STArray h a -> Eff (st :: ST h | r) Unit

scaleSTMatrix :: forall s a h r. (Num a) => a -> (STMat s h a) -> Eff (st :: ST h | r) (STMat s h a)
scaleSTMatrix x v@(STMat _ arr) = scaleSTMatrixInt x arr *> return v
scaleSTMatrix x v@(STMat arr) = scaleSTMatrixInt x arr *> return v

-- empties stack, careful!
fromMatrix :: forall s h r a. M.Mat s a -> Eff (st :: ST h | r) (STMat s h a)
fromMatrix (M.Mat m) = STMat [] <$> thaw m

stackPush :: forall s h r a. STMat s h a -> Eff (st :: ST h | r) (STMat s h a)
stackPush (STMat st arr) = do
n <- freeze arr
return (STMat (n:st) arr)

stackPop :: forall s h r a. STMat s h a -> Eff (st :: ST h | r) (STMat s h a)
stackPop v@(STMat st _) = case st of
[] -> return v
(x:xs) -> let arr = unsafeThaw x in return (STMat xs arr)

fromMatrix (M.Mat m) = STMat <$> thaw m

foreign import runSTMatrixInt """
function runSTMatrixInt(f) {
return function(){
var res = f();
return (res.value1);
};
return (f);
}""" :: forall s a r. (forall h. Eff (st :: ST h | r) (STMat s h a)) -> Eff r [a]

runSTMatrix :: forall s a r. (forall h. Eff (st :: ST h | r) (STMat s h a)) -> Eff r (M.Mat s a)
Expand Down
4 changes: 2 additions & 2 deletions src/Data/ST/Matrix4.purs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -212,7 +212,7 @@ foreign import rotateSTInt """


rotateST :: forall h r. Number -> Vec3N -> STMat4 h -> Eff (st :: ST h | r) (STMat4 h)
rotateST angle (V.Vec a) v@(STMat _ arr) = rotateSTInt angle a arr *> return v
rotateST angle (V.Vec a) v@(STMat arr) = rotateSTInt angle a arr *> return v

foreign import translate3STInt """
function translate3STInt(a) {
Expand All @@ -226,7 +226,7 @@ foreign import translate3STInt """
}""" :: forall h r. [Number] -> STArray h Number -> Eff (st :: ST h | r) Unit

translateST :: forall h r. Vec3N -> STMat4 h -> Eff (st :: ST h | r) (STMat4 h)
translateST (V.Vec a) v@(STMat _ arr) =
translateST (V.Vec a) v@(STMat arr) =
translate3STInt a arr *> return v

{-
Expand Down