Main.hs

{-# LANGUAGE PatternGuards #-}

import World
import Data
import State
import Cell
import Graphics.Gloss.Interface.Pure.Game
import Graphics.Gloss.Data.QuadTree
import Graphics.Gloss.Data.Extent
import System.Environment
import Data.Maybe
import Data.List
import Data.Function

main 
 = do   args    <- getArgs
        case args of
         [fileName]     
          -> do world   <- loadWorld fileName
                mainWithWorld world
                
         _ -> do
                let world = readWorld worldData
                mainWithWorld world
        
        
mainWithWorld world
 = play (InWindow "Occlusion"
                 (windowSizeOfWorld world) (10, 10))
        black 
        10
        (initState world)
        drawState
        (handleInput world)
        (\_ -> id)
                                
                                
-- | Convert the state to a picture.
drawState :: State -> Picture
drawState state
 = let  world           = stateWorld state

        -- The ray cast by the user.
        p1              = stateLineStart state
        p2              = stateLineEnd   state
        picRay          = drawRay world p1 p2

        -- The cell hit by the ray (if any)
        mHitCell        = castSegIntoWorld world p1 p2
        hitCells        = maybeToList mHitCell
        picCellsHit     = Pictures $ map (drawHitCell world) hitCells

        -- All the cells in the world.
        cellsAll        = flattenQuadTree (worldExtent world) (worldTree world)
        picCellsAll     = Pictures $ map (uncurry (drawCell False world)) cellsAll

        -- The cells visible from the designated point.
        cellsVisible    
          = [ (coord, cell)
                | (coord, cell) <- flattenQuadTree (worldExtent world) (worldTree world)
                , cellAtCoordIsVisibleFromPoint world p1 coord ]

        picCellsVisible = Pictures $ map (uncurry (drawCell True world)) cellsVisible

        -- How big to draw the cells.
        scale           = fromIntegral $ worldCellSize world

        (windowSizeX, windowSizeY)      
                = windowSizeOfWorld
                $ stateWorld state
                
        -- Shift the cells so they are centered in the window.
        offsetX = - (fromIntegral $ windowSizeX `div` 2)
        offsetY = - (fromIntegral $ windowSizeY `div` 2)

   in   Translate offsetX offsetY
                $ Scale scale scale
                $ Pictures [ picCellsAll, picCellsVisible, picCellsHit, picRay ]


-- | Draw the cell hit by the ray defined by the user.
drawHitCell :: World -> (Point, Extent, Cell) -> Picture
drawHitCell world (pos@(px, py), extent, cell)
 = let  (n, s, e, w)    = takeExtent extent
        x               = w
        y               = s

        posX    = fromIntegral x 
        posY    = fromIntegral y
        
   in   Pictures [ Color blue $ cellShape 1 posX posY ]


-- | Draw the ray defined by the user.
drawRay :: World -> Point -> Point -> Picture 
drawRay world p1@(x, y) p2
 = Pictures
        [ Color red $ Line [p1, p2]
        , Color cyan 
                $ Translate x y 
                $ Pictures 
                        [ Line [(-0.3, -0.3), (0.3,  0.3)]
                        , Line [(-0.3,  0.3), (0.3, -0.3)] ] ]


-- | Draw a cell in the world.
drawCell :: Bool -> World -> Coord -> Cell -> Picture
drawCell visible world (x, y) cell 
 = let  cs      = fromIntegral (worldCellSize world)
        cp      = fromIntegral (worldCellSpace world)

        posX    = fromIntegral x 
        posY    = fromIntegral y

   in   if visible
          then pictureOfCell (worldCellSize world) posX posY cell
          else Color (greyN 0.4) (cellShape cs posX posY)