packages feed

marionetta 0.1.0.1 → 0.1.0.3

raw patch · 13 files changed

+217/−112 lines, 13 filesdep +splinesdep +vectordep +vector-spacedep ~containersdep ~glossdep ~mtl

Dependencies added: splines, vector, vector-space

Dependency ranges changed: containers, gloss, mtl

Files

Controller.hs view
@@ -1,23 +1,25 @@ {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE GADTs #-} -module Controller (Evento (..), catchEvento, mkWorld, World (..), Lasso (..), Verso (..)) where+module Controller (Evento (..), catchEvento, mkWorld, World (..), Lasso (..), Verso (..), updateTime) where   import Data.Maybe (fromMaybe)+import Control.Arrow (first, second)   import Data.List.Zipper (mkZipper, Zipper , inserisci, elimina, destra, sinistra, modifica)-import Data.Tree.Missing (inspectTop , forward, backward)-import Model (Figura,  Punto)-import IFigura (IFigura(IFigura), traslazione, rotazione, movimentoCentroTop, modificaSelettori, ricentra, iselectors)--data MoveEffect = Ruotando Punto | Traslando Punto | SpostandoCentro Punto | Niente+import Data.Tree.Missing (inspectTop , forward, backward, topSelector)+import Model (Figura,  Punto(..), vicino, assolutizza, Tempo (..), Normalizzato)+import IFigura (IFigura(IFigura), ifigura , traslazione, rotazione, movimentoCentroTop, modificaSelettori, ricentra, iselectors)+import Movie -data World = World (Zipper IFigura) MoveEffect+data MoveEffect = Ruotando Punto | Traslando Punto | SpostandoCentro Punto | SpostandoFulcrum Punto| Niente +data World = World (Tempo Normalizzato) (Zipper (IFigura,Fulcrum)) MoveEffect  mkWorld :: Figura -> World  mkWorld fig = World -	(mkZipper $ IFigura fig [] (forward (inspectTop fig) fig) (backward (inspectTop fig) fig))+	(Tempo 0)+	(mkZipper $ (IFigura fig [] (forward (inspectTop fig) fig) (backward (inspectTop fig) fig),  Fulcrum (topSelector fig) $ Punto (0,0))) 	Niente  data Lasso = Inizio | Fine@@ -36,33 +38,43 @@ 	Seleziona :: Punto -> Evento  	Deseleziona :: Evento 	Silent :: Evento+	SpostamentoFulcrum :: Punto -> Lasso -> Evento+	RicentraFulcrum :: Punto -> Evento +modificaIFigura  f = modifica $ first f+modificaFulcrum f = modifica $ second f+ catchEvento :: Evento -> World -> World-catchEvento Refresh (World z _) = World z Niente-catchEvento (Puntatore p) (World z Niente) = World z Niente-catchEvento (Puntatore p) (World z (Traslando q)) = World (modifica (traslazione q p) z) $ Traslando p -catchEvento (Puntatore p) (World z (Ruotando q)) = World (modifica (rotazione q p) z) $ Ruotando p -catchEvento (Puntatore p) (World z (SpostandoCentro q)) = World (modifica (movimentoCentroTop q p) z) $ SpostandoCentro p -catchEvento (Rotazione p Inizio) (World z _) = World z (Ruotando p)-catchEvento (Rotazione p Fine) (World z (Ruotando _)) = World z Niente+catchEvento Refresh (World t z _) = World t z Niente+catchEvento (Puntatore p) (World t z Niente) = World t z Niente+catchEvento (Puntatore p) (World t z (Traslando q)) = World t (modificaIFigura  (traslazione q p) z) $ Traslando p +catchEvento (Puntatore p) (World t z (Ruotando q)) = World t (modificaIFigura  (rotazione q p) z) $ Ruotando p +catchEvento (Puntatore p) (World t z (SpostandoCentro q)) = World t (modificaIFigura  (movimentoCentroTop q p) z) $ SpostandoCentro p +catchEvento (Puntatore p) (World t z (SpostandoFulcrum q)) = World t (modificaFulcrum  (\ful -> ful {fulcrum = q}) z) $ SpostandoFulcrum p +catchEvento (Rotazione p Inizio) (World t z _) = World t z (Ruotando p)+catchEvento (Rotazione p Fine) (World t z (Ruotando _)) = World t z Niente catchEvento (Rotazione p Fine) w = w-catchEvento (Traslazione p Inizio) (World z _) = World z (Traslando p)-catchEvento (Traslazione p Fine) (World z (Traslando _)) = World z Niente+catchEvento (Traslazione p Inizio) (World t z _) = World t z (Traslando p)+catchEvento (Traslazione p Fine) (World t z (Traslando _)) = World t z Niente catchEvento (Traslazione p Fine) w = w-catchEvento (SpostamentoCentro p Inizio) (World z _) = World z (SpostandoCentro p)-catchEvento (SpostamentoCentro p Fine) (World z (SpostandoCentro _)) = World z Niente+catchEvento (SpostamentoCentro p Inizio) (World t z _) = World t z (SpostandoCentro p)+catchEvento (SpostamentoCentro p Fine) (World t z (SpostandoCentro _)) = World t z Niente catchEvento (SpostamentoCentro p Fine) w = w-catchEvento Cancella (World z m) = World (fromMaybe z $ elimina z) m-catchEvento Clona (World z m) = World (inserisci id z) m-catchEvento (Fuoco Destra) (World z m) = World (destra z) m-catchEvento (Fuoco Sinistra) (World z m) = World (sinistra z) m-catchEvento (Seleziona p) (World z m) = World (modifica (modificaSelettori p) z) m-catchEvento Deseleziona (World z m) = World (modifica f z) m where+catchEvento Cancella (World t z m) = World t (fromMaybe z $ elimina z) m+catchEvento Clona (World t z m) = World t (inserisci id z) m+catchEvento (Fuoco Destra) (World t z m) = World t (destra z) m+catchEvento (Fuoco Sinistra) (World t z m) = World t (sinistra z) m+catchEvento (Seleziona p) (World t z m) = World t (modificaIFigura  (modificaSelettori p) z) m+catchEvento Deseleziona (World t z m) = World t (modificaIFigura  f z) m where 	f ifig = ifig {iselectors = []}-catchEvento (Ricentra p) (World z m)  = World (modifica (ricentra p) z) m+catchEvento (Ricentra p) (World t z m)  = World t (modificaIFigura  (ricentra p) z) m catchEvento Silent w = w----+catchEvento (SpostamentoFulcrum p Inizio) (World t z _) = World t  z (SpostandoFulcrum p)+catchEvento (SpostamentoFulcrum p Fine) (World t z (SpostandoFulcrum _)) = World t z Niente+catchEvento (SpostamentoFulcrum p Fine) w = w+catchEvento (RicentraFulcrum p) (World t z m)  = World t (modifica f z) m where+	f (ifi, Fulcrum _ q) = (ifi, Fulcrum (vicino p (assolutizza $ ifigura ifi)) q) +updateTime :: Float -> World -> World+updateTime ((/3) -> t) (World (tempo -> t') z m) = World (Tempo t'') z m where+	t'' = if t + t' > 1 then 0 else t + t'
Data/List/Zipper.hs view
@@ -17,7 +17,9 @@  module Data.List.Zipper where -data Zipper a = Zipper [a] [a]+data Zipper a = Zipper [a] [a] +instance Functor Zipper where+	fmap f (Zipper xs ys) = Zipper (fmap f xs) (fmap f ys)  sinistra z@(Zipper [] _) = z sinistra (Zipper (x:xs) ys) = Zipper xs (x:ys)@@ -25,6 +27,9 @@ destra z@(Zipper _ [x]) = z destra (Zipper xs (y:ys)) = Zipper (y:xs) ys +isLast (Zipper [] _) = True+isLast _ = False+ mkZipper x = Zipper [] [x] valore (Zipper _ (x:_)) = x @@ -35,7 +40,7 @@ elimina (Zipper xs (y:ys)) = Just (Zipper xs ys)  modifica f (Zipper xs (y:ys)) = Zipper xs (f y : ys)-elementi (Zipper xs ys) = xs ++ ys+elementi (Zipper xs ys) = reverse xs ++ ys
Data/Tree/Missing.hs view
@@ -12,16 +12,16 @@  ----------------------------------------------------------------------------- -{-# LANGUAGE ScopedTypeVariables, NoMonomorphismRestriction #-}+{-# LANGUAGE ScopedTypeVariables, NoMonomorphismRestriction, Rank2Types, ImpredicativeTypes #-} -module Data.Tree.Missing (inspectTop, modifyTop, recurseTreeAccum, backward, forward, Routing, routingDumb) where+module Data.Tree.Missing (inspectTop, modifyTop, recurseTreeAccum, backward, forward, Routing, routingDumb, fromSelector, topSelector) where  import Prelude hiding (zipWith) import Control.Monad (msum) import Data.List (splitAt,inits,tails) import Data.Tree (Tree (Node)) -import Data.Zip (Zip (..))+import Data.Zip (Zip (..), labella, Selector , Label, mkSelector)   @@ -69,5 +69,14 @@  routingDumb :: Routing b -> Tree b -> Tree b routingDumb r = snd . r undefined (const id)++topSelector :: Tree a -> Selector Tree b+topSelector t = mkSelector (==0) $ labella t++fromSelector :: Tree a -> Selector Tree Label -> (forall c . Routing c, forall c . Routing c)+fromSelector ifig ir = let+	lifig = labella ifig+	r = head $ snd (ir lifig)+        in (forward r lifig, backward r lifig)
Data/Zip.hs view
@@ -38,12 +38,15 @@     ch f (x,y)    | t x  = f y                   | otherwise = y -labella :: Traversable t => [a] -> t b -> t a-labella xs = snd . mapAccumL (\(x:xs) _ -> (xs,x)) xs+type Label = Int  +labella :: Traversable t => t b -> t Label+labella = snd . mapAccumL (\(x:xs) _ -> (xs,x)) [0..]+ moveSelector :: (Functor t, Foldable t, Traversable t, Zip t)     => t a -> (forall a . t a -> t a) -> Selector t Bool  -> Selector t b moveSelector tr r s = mkSelector id . r $ fst (s . fmap (const False) $ tr) (const True)+  filterDuplicates :: forall t a b . (Functor t, Foldable t, Traversable t, Zip t)     => t a -> (forall b . [Selector t b])  -> [Selector t b]
Gloss.hs view
@@ -3,9 +3,9 @@  import Data.Monoid (mconcat) -import Graphics.Gloss.Interface.Game +import Graphics.Gloss.Interface.Pure.Game  	(Picture(..), translate, rotate, color-	, yellow, white, Event (..), gameInWindow+	, yellow, white, Event (..), play, Display (..) 	, scale, blue, makeColor, Key (..), MouseButton (..), SpecialKey (..), KeyState (..))  import View (RenderHelp, Colore, Render)@@ -51,4 +51,4 @@ gloss_implementazione = Implementazione renderPezzo colore renderHelp glCatch  gloss_run :: String -> (Int,Int) -> (Int,Int) -> Run Picture Event-gloss_run s c l w rew ce = gameInWindow s c l white 0 w rew ce (const id)+gloss_run s c l w rew ce up = play (InWindow s c l) white 100 w rew ce up
IFigura.hs view
@@ -1,12 +1,11 @@ {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE NoMonomorphismRestriction #-}-{-# LANGUAGE ImpredicativeTypes #-}  module IFigura where  import Data.Tree (Tree)-import Data.Tree.Missing (routingDumb, forward, backward,modifyTop, Routing)+import Data.Tree.Missing (routingDumb, forward, backward,modifyTop, Routing, fromSelector) import Data.Zip (Selector, moveSelector, filterDuplicates, labella) import Model (Figura, ruotaScelto, vicino, Punto (..), Pezzo (..), assolutizza, relativizza,rotazioneInOrigine, routingPezzi) @@ -22,11 +21,8 @@ ricentra l (IFigura ifig isels _ ibackw ) = let             ifig' = rotazioneInOrigine . routingPezzi undefined ibackw $ assolutizza ifig             isels' = map (moveSelector ifig $ routingDumb ibackw) isels-            ir = vicino l ifig'-            lifig = labella [0..] ifig'-            c = head $ snd (ir lifig)-            iforw =  forward c lifig-            ibackw' =  backward c lifig+            ir = vicino l ifig' +            (iforw , ibackw') = fromSelector ifig' ir              ifig'' = relativizza . rotazioneInOrigine . routingPezzi undefined iforw $ ifig'             isels'' = map (moveSelector ifig' $ routingDumb iforw) isels'             in  IFigura ifig'' isels'' iforw ibackw'
+ Math.hs view
@@ -0,0 +1,49 @@+{-# LANGUAGE TypeFamilies, GeneralizedNewtypeDeriving #-}+module Math where++import Data.VectorSpace++-- | un punto nel piano 2d ascissa e ordinata o anche un vettore+newtype Punto = Punto (Float,Float) deriving (Eq,Show, Read, AdditiveGroup)++-- | un angolo+type Angolo = Float++-- campo dei Punto+instance Num Punto where+	(+) (Punto (x,y)) (Punto (x1,y1)) = Punto (x+x1,y+y1)+	negate (Punto (x,y)) = Punto (negate x,negate y)+	(*) = error "Punto Num method undefined used"+	abs x = error $ "abs :" ++ show x ++  " Punto Num method undefined used"+	signum = error "signum : Punto Num method undefined used"+	fromInteger x = error $ "fromInteger " ++ show x ++ ": Punto Num method undefined used"+++instance VectorSpace Punto where+	type Scalar Punto = Float+	t *^ (Punto (x,y)) = Punto (x * t,y * t)+++type Ruota = Punto -> Punto++-- rotazione intorno all'origine+ruota :: Angolo -> Ruota+ruota alpha (Punto (x,y))= Punto (cos alpha * x - sin alpha * y, sin alpha * x + cos alpha * y)+++-- modulo di un vettore+modulus :: Punto -> Float+modulus (Punto (x,y)) = sqrt (x ^ 2 + y ^ 2)+++pointOfOnlyRotation :: (Punto,Angolo) -> (Punto,Angolo) -> Punto+pointOfOnlyRotation (p1,alpha1) (p2,alpha2) = let +	dp@(Punto (dpx,dpy)) = p2 - p1+	s = modulus (p2 - p1)+	x = Punto (s/2 , 0)+	y = Punto (0, s / 2 / tan (alpha / 2))+	alpha = alpha2 - alpha1+	beta = atan2 dpy dpx+	in ruota beta (y  - x) + p2 ++
Model.hs view
@@ -3,46 +3,22 @@ {-# LANGUAGE EmptyDataDecls #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -module Model where -- (Punto (..), Semiretta (..), Angolo , TreePath, Tree, Accelerazione, configura, film) where+module Model (Punto (..), Angolo, Pezzo (..), rotazioneInOrigine, routingPezzi+	, ruotaScelto, vicino, Figura , relativizza, assolutizza, Assoluto, Relativo, Normalizzato,  Tempo (..) , interpolazione) where  import Prelude hiding (zipWith)+import Data.VectorSpace ((*^)) import Data.Tree (Tree(..))-import Data.Tree.Missing ( recurseTreeAccum, Routing, modifyTop)+import Data.Tree.Missing ( recurseTreeAccum, Routing, modifyTop, inspectTop) import Control.Applicative ((<$>)) import Control.Monad (ap) import Data.Foldable (minimumBy, toList) import Data.List.Zipper import Data.Ord (comparing) import Control.Arrow (Arrow(..))-import Debug.Trace+import Math import Data.Zip---- | un punto nel piano 2d ascissa e ordinata o anche un vettore-newtype Punto = Punto (Float,Float) deriving (Eq,Show, Read)---- | un angolo-type Angolo = Float---- campo dei Punto-instance Num Punto where-	(+) (Punto (x,y)) (Punto (x1,y1)) = Punto (x+x1,y+y1)-	negate (Punto (x,y)) = Punto (negate x,negate y)-	(*) = error "Punto Num method undefined used"-	abs x = error $ "abs :" ++ show x ++  " Punto Num method undefined used"-	signum = error "signum : Punto Num method undefined used"-	fromInteger x = error $ "fromInteger " ++ show x ++ ": Punto Num method undefined used"---type Ruota = Punto -> Punto---- rotazione intorno all'origine-ruota :: Angolo -> Ruota-ruota alpha (Punto (x,y))= Punto (cos alpha * x - sin alpha * y, sin alpha * x + cos alpha * y)----- modulo di un vettore-modulus :: Punto -> Float-modulus (Punto (x,y)) = sqrt (x ^ 2 + y ^ 2)+import Debug.Trace  data Relativo data Assoluto@@ -54,9 +30,6 @@     } deriving (Show,Read,Eq)  --- assolutizza :: Tree (Pezzo Relativo) -> Tree (Pezzo Assoluto) assolutizza = recurseTreeAccum (Punto (0,0)) f    where     f q (Pezzo c o alpha) = (qc, Pezzo qc (o + qc) alpha ) where qc = q + c@@ -97,12 +70,19 @@ (.-.) :: Tempo Assoluto -> Tempo Assoluto -> Tempo Relativo (.-.) = tf (-) +normalizzaAngolo alpha+	| alpha < -pi = normalizzaAngolo $ alpha + 2 * pi+	| alpha > pi = normalizzaAngolo $ alpha - 2 * pi+	| otherwise = alpha interpolazione      :: Tree (Pezzo Relativo)                     -> Tree (Pezzo Relativo)                     -> Tempo Normalizzato                     -> Tree (Pezzo Relativo)-interpolazione t1 t2 t = aggiorna $ zipWith variazioneAngolo  t1 t2 where-    variazioneAngolo p p' = ((rotazionePezzo p' - rotazionePezzo p) /  tempo t, p)+interpolazione t1 t2 t = modifyTop (\(Pezzo _ r alpha) -> Pezzo (l t) r alpha) . aggiorna $ zipWith variazioneAngolo  t1 t2 where+    variazioneAngolo p p' = (tempo t * ((normalizzaAngolo $ rotazionePezzo p') - (normalizzaAngolo $ rotazionePezzo p)), p)+    l t = l0 + tempo t *^ (l1 - l0) +    l0 = fulcroPezzo (inspectTop t1)+    l1 = fulcroPezzo (inspectTop t2)  type Figura = Tree (Pezzo Relativo)
+ Movie.hs view
@@ -0,0 +1,52 @@+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE ImpredicativeTypes #-}+module Movie where++import Prelude hiding (foldr, zipWith)+import Data.Foldable+++import Math.Spline.BSpline+import Math.Spline.Knots (Knots)++import Data.Tree++import Data.Vector (fromList)++import Math ++import Model++import Data.List.Zipper++import Data.Tree.Missing++import Data.Zip++type Index = Int+++spline :: Knots Float -> [Pezzo Assoluto] -> BSpline Punto+spline x = bSpline x . fromList . map originePezzo +++type Movie = [Tree (Pezzo Assoluto)]++splines :: Knots Float -> Movie -> Tree (BSpline Punto)+splines x (y:ys) = fmap (spline x) . foldr (zipWith (:)) (fmap return y) $ ys+splines x [] = error "empty movie to spline"++generaPasso :: Tree (Pezzo Assoluto) -> Tree (Pezzo Assoluto)  -> Fulcrum -> Tempo Normalizzato -> Figura +generaPasso fp fa (Fulcrum s p) = let	+	(forw,_) = fromSelector fp s+	fp' = relativizza $ fp+	fa' = relativizza $ fa+	in interpolazione fp' fa'++data Fulcrum = Fulcrum +	  	{	legato :: Selector Tree Label+		,	fulcrum :: Punto+		}++
Run.hs view
@@ -5,7 +5,7 @@ import Model (Pezzo (Pezzo), Punto (Punto), Assoluto, relativizza)  import View (Render, Colore, RenderHelp, renderWorld)-import Controller (World(World), Evento, mkWorld, catchEvento)+import Controller (World(World), Evento, mkWorld, catchEvento, updateTime)   data Geometrici = Ge@@ -35,11 +35,11 @@ 	,	catturaEvento :: e -> Evento 	} -type Run b e = World -> (World -> b) -> (e -> World -> World) -> IO ()+type Run b e = World -> (World -> b) -> (e -> World -> World) -> (Float -> World -> World) -> IO ()  run :: Monoid b => Run b e -> Implementazione b e -> Descrizione -> IO ()-run f (Implementazione mks co mo ca) de = f w rew cat where-	rew = renderWorld co mo (fmap (mks . snd) de) . (\(World ifig _) -> ifig)+run f (Implementazione mks co mo ca) de = f w rew cat updateTime where+	rew = renderWorld co mo (fmap (mks . snd) de)  	cat = catchEvento . ca  	w = mkWorld (relativizza $ fmap (mkPezzo . fst) de)
View.hs view
@@ -1,17 +1,19 @@+{-# LANGUAGE ViewPatterns #-} module View (RenderHelp, Render, Colore, renderWorld) where  import Prelude hiding (zipWith) import Data.Tree (Tree)  import Data.Foldable (toList)-import Data.Monoid (mconcat,Monoid)+import Data.Monoid (mconcat,Monoid,mempty)   import Data.Zip (zipWith) import Data.Tree.Missing (modifyTop, routingDumb)-import Data.List.Zipper (Zipper, elementi, valore)-import Model (assolutizza , Pezzo , Assoluto, Figura)+import Data.List.Zipper (Zipper, elementi, valore, destra, sinistra, isLast)+import Model (assolutizza , Pezzo , Assoluto, Figura, Tempo, Normalizzato, routingPezzi, rotazioneInOrigine) import IFigura (IFigura(IFigura))-+import Controller (World (..))+import Movie  type Render b = Pezzo Assoluto -> b @@ -33,11 +35,21 @@  type RenderHelp b = [String] -> b -renderWorld :: Monoid b => Colore b -> RenderHelp b -> Tree (Render b) -> Zipper IFigura -> b-renderWorld co he re ca  = let-    ps =  mconcat . map (renderIFigura co re) $ elementi ca-    actual = renderIFigura co re . valore $ ca-    in mconcat [co text $ he help, co (0.5,0.5,0.5) ps, co (0.1,0.1,0.1) actual]++film = (0.7,0.7,0.7)++renderMovie :: Monoid b => Tree (Render b) -> Tempo Normalizzato -> ((IFigura, Fulcrum), (IFigura, Fulcrum)) -> b+renderMovie re t ((IFigura ifig _ _ back,fu), (IFigura ifig2 _ _ back2,_)) = let +	ifig' =  rotazioneInOrigine . routingPezzi undefined back $ assolutizza ifig+	ifig'' =  rotazioneInOrigine . routingPezzi undefined back2 $ assolutizza ifig2+	in   renderFigura re . generaPasso ifig' ifig'' fu $ t ++renderWorld :: Monoid b => Colore b -> RenderHelp b -> Tree (Render b) -> World  -> b+renderWorld co he re (World t z _) = let+    xs = elementi z+    ms = co film . mconcat . map (renderMovie re t) . zip xs $ tail xs+    actual = renderIFigura co re . fst . valore $ z+    in mconcat [co text $ he help,  actual, ms]  help =  [   "S: select/deselect nearest to pointer piece for rotation"         ,   "Space: deselect all pieces"
− gloss.patch 
@@ -1,13 +0,0 @@---- Graphics/Gloss/Internals/Interface/Backend/GLUT.hs	2011-11-16 09:58:40.359886120 +0100-+++ Graphics/Gloss/Internals/Interface/Backend/GLUT.patched.hs	2011-11-16 09:58:57.951886166 +0100-@@ -239,7 +239,9 @@-         -> IO ()- - installMotionCallbackGLUT ref callbacks--        = GLUT.motionCallback $= Just (callbackMotion ref callbacks)-+        = do GLUT.motionCallback $= Just (callbackMotion ref callbacks)-+             GLUT.passiveMotionCallback $= Just (callbackMotion ref callbacks)-+- - callbackMotion-         :: IORef GLUTState -> [Callback]
marionetta.cabal view
@@ -7,7 +7,7 @@ -- The package version. See the Haskell package versioning policy -- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for -- standards guiding when and how versions should be incremented.-Version:             0.1.0.1+Version:             0.1.0.3  -- A short (one-line) description of the package. Synopsis: A study of marionetta movements.@@ -40,7 +40,7 @@  -- Extra files to be distributed with the package, such as examples or -- a README.-Extra-source-files:  gloss.patch+Extra-source-files:    -- Constraint on the version of Cabal needed to build this package. Cabal-version:       >=1.2@@ -51,10 +51,10 @@   Main-is: marionetta.hs                   -- Packages needed in order to build this package.-  Build-depends: base >=4 && <5, mtl -any, containers -any , gloss -any+  Build-depends: base >=4 && <5, mtl >= 0.2.0.1, containers >= 0.4.2.1 , gloss == 1.7.4.1, splines == 0.3, vector-space == 0.8.0, vector == 0.9.1      -- Modules not exported by this package.-  Other-modules:  Controller Data.List.Zipper Data.Tree.Missing Data.Zip Gloss IFigura Model View Run+  Other-modules:  Controller Data.List.Zipper Data.Tree.Missing Data.Zip Gloss IFigura Model View Run Math Movie      -- Extra tools (e.g. alex, hsc2hs, ...) needed to build the source.   -- Build-tools: