175 lines
6.6 KiB
Haskell
175 lines
6.6 KiB
Haskell
{-# LANGUAGE TemplateHaskell #-}
|
|
module Picture.Preload
|
|
( RenderData (..)
|
|
, preloadRender
|
|
, cleanUpRenderPreload
|
|
)
|
|
where
|
|
|
|
import Picture.Data
|
|
import Shader
|
|
import Geometry (Point2,Point3,Point4)
|
|
|
|
import Graphics.Rendering.OpenGL hiding (Point (..),translate,scale,imageHeight,imageWidth)
|
|
|
|
import Control.Lens
|
|
import Foreign
|
|
|
|
import qualified Control.Foldl as F
|
|
|
|
data RenderData = RenderData
|
|
{ _lightSourceShader :: FullShader (Float,Float,Float,Float)
|
|
, _wallShadowShader :: FullShader (Point2,Point2)
|
|
, _wallLightShader :: FullShader (Point2,Point2)
|
|
, _wallFaceShader :: FullShader ((Point2,Point2),Point4)
|
|
, _backgroundShader :: FullShader (Point2,Point2,Point2,Point2)
|
|
, _fullscreenShader :: FullShader ()
|
|
, _listShaders :: [FullShader RenderType]
|
|
, _spareFBO :: FramebufferObject
|
|
, _fboTexture :: TextureObject
|
|
, _fboRenderbufferObject :: RenderbufferObject
|
|
}
|
|
|
|
makeLenses ''RenderData
|
|
|
|
preloadRender :: IO RenderData
|
|
preloadRender = do
|
|
-- lighting shaders
|
|
lsShad <- makeShader "lighting/lightmapCircle" [vert,geom,frag] [(0,4)] Points
|
|
(return . return . flat4)
|
|
wsShad <- makeShader "lighting/wallShadow" [vert,geom,frag] [(0,4)] Points pokeWPStrat
|
|
>>= addUniforms ["lightPos","perpMat","facesToDraw"]
|
|
wlLightShad
|
|
<- makeShader "lighting/lightmapWall" [vert,geom,frag] [(0,4)] Points pokeWPStrat
|
|
>>= addUniforms ["lightPos","perpMat","radLum"]
|
|
|
|
-- 2D draw shaders
|
|
bslist <- makeShader "twoD/basic" [vert,frag] [(0,3),(1,4)] Triangles pokeTriStrat
|
|
lslist <- makeShader "twoD/basic" [vert,frag] [(0,3),(1,4)] Lines pokeLineStrat
|
|
aslist <- makeShader "twoD/arc" [vert,geom,frag] [(0,3),(1,4),(2,4)] Points pokeArcStrat
|
|
eslist <- makeShader "twoD/ellipse" [vert,geom,frag] [(0,3),(1,4)] Triangles pokeEllStrat
|
|
bezierQuadShader <- makeShader
|
|
"twoD/bezierQuad" [vert,frag] [(0,3),(1,4),(2,4)] TriangleStrip pokeBezQStrat
|
|
cslist <- makeShader "twoD/character" [vert,geom,frag]
|
|
[(0,3),(1,4),(2,3)] Points pokeCharStrat
|
|
>>= addTexture "data/texture/charMap.png"
|
|
|
|
-- fullscreen shader
|
|
fsShad <- makeShader "fullscreen" [vert,frag] [(0,2),(1,2)] TriangleStrip
|
|
(const [[[-1, 1],[0,1]]
|
|
,[[ 1, 1],[1,1]]
|
|
,[[-1,-1],[0,0]]
|
|
,[[ 1,-1],[1,0]]
|
|
]
|
|
)
|
|
n <- F.foldM (pokeShader fsShad) [()] -- fix fullscreen vertex positions now
|
|
|
|
-- background shader
|
|
bgShad <- makeShader "background" [vert,geom,frag] [(0,4),(1,2)] Points pokeBGStrat
|
|
>>= addTexture "data/texture/smudgedDirt.png"
|
|
|
|
-- wallShader
|
|
wlShad <- makeShader "wallFace" [vert,geom,frag] [(0,4),(1,4)] Points pokeWPColStrat
|
|
>>= addTexture "data/texture/grayscaleDirt.png"
|
|
>>= addUniforms ["perpMat"]
|
|
|
|
-- framebuffer for lighting
|
|
(fbo,fboTO,fboRBO) <- setupFramebuffer
|
|
|
|
-- reset to default framebuffer, ready for drawing direct to screen
|
|
bindFramebuffer Framebuffer $= defaultFramebufferObject
|
|
|
|
return $ RenderData
|
|
{ _listShaders = [bslist,lslist,cslist,aslist,eslist,bezierQuadShader]
|
|
, _lightSourceShader = lsShad
|
|
, _wallShadowShader = wsShad
|
|
, _wallLightShader = wlLightShad
|
|
, _wallFaceShader = wlShad
|
|
, _backgroundShader = bgShad
|
|
, _fullscreenShader = fsShad
|
|
, _spareFBO = fbo
|
|
, _fboTexture = fboTO
|
|
, _fboRenderbufferObject = fboRBO
|
|
}
|
|
|
|
-- potential drawing setup
|
|
---- swapInterval $= ImmediateUpdates
|
|
-- GL.blend $= GL.Enabled
|
|
---- GL.depthMask $= GL.Enabled
|
|
-- GL.blendEquation $= GL.FuncAdd
|
|
-- GL.blendFunc $= (GL.SrcAlpha,GL.OneMinusSrcAlpha)
|
|
-- GL.clearColor $= GL.Color4 0 0.5 0 1
|
|
-- GL.clearDepth $= (200)
|
|
-- swapInterval $= ImmediateUpdates
|
|
-- GL.lineSmooth $= GL.Enabled
|
|
|
|
--------------------end preloadRender
|
|
|
|
setupFramebuffer :: IO (FramebufferObject, TextureObject,RenderbufferObject)
|
|
setupFramebuffer = do
|
|
fboName <- genObjectName
|
|
bindFramebuffer Framebuffer $= fboName
|
|
|
|
fboTO <- genObjectName
|
|
textureBinding Texture2D $= Just fboTO
|
|
texImage2D Texture2D NoProxy 0 RGBA8 (TextureSize2D 800 600) 0 (PixelData RGBA UnsignedByte nullPtr)
|
|
textureFilter Texture2D $= ((Linear',Just Linear') , Nearest)
|
|
generateMipmap' Texture2D
|
|
framebufferTexture2D Framebuffer (ColorAttachment 0) Texture2D fboTO 0
|
|
|
|
fboRBO <- genObjectName
|
|
bindRenderbuffer Renderbuffer $= fboRBO
|
|
renderbufferStorage Renderbuffer Depth24Stencil8 (RenderbufferSize 800 600)
|
|
framebufferRenderbuffer Framebuffer DepthStencilAttachment Renderbuffer fboRBO
|
|
|
|
fboStatus <- framebufferStatus Framebuffer
|
|
print fboStatus
|
|
|
|
return (fboName, fboTO, fboRBO)
|
|
|
|
cleanUpRenderPreload :: RenderData -> IO ()
|
|
cleanUpRenderPreload pd = do
|
|
mapM_ freeShaderPointers $ _listShaders pd
|
|
freeShaderPointers $ _lightSourceShader pd
|
|
freeShaderPointers $ _wallShadowShader pd
|
|
freeShaderPointers $ _backgroundShader pd
|
|
freeShaderPointers $ _fullscreenShader pd
|
|
|
|
{-# INLINE pokeBezQStrat #-}
|
|
pokeBezQStrat :: RenderType -> [[[Float]]]
|
|
pokeBezQStrat (RenderBezQ vs) = fmap (\((x,y,z),(r,g,b,a),(s,t,u,v)) -> [[x,y,z],[r,g,b,a],[s,t,u,v]]
|
|
)
|
|
vs
|
|
pokeBezQStrat _ = []
|
|
|
|
{-# INLINE pokeTriStrat #-}
|
|
pokeTriStrat :: RenderType -> [[[Float]]]
|
|
pokeTriStrat (RenderPoly vs) = fmap (\((x,y,z),(r,g,b,a)) -> [[x,y,z],[r,g,b,a]]) vs
|
|
pokeTriStrat _ = []
|
|
|
|
pokeCharStrat (RenderText vs) = fmap (\(a,b,c) -> flat3 (flat3 a, flat4 b, flat3 c)) vs
|
|
pokeCharStrat _ = []
|
|
|
|
pokeArcStrat (RenderArc (a,b,c)) = [flat3 (flat3 a, flat4 b, flat4 c)]
|
|
pokeArcStrat _ = []
|
|
|
|
pokeLineStrat (RenderLine vs) = fmap (\((x,y,z),(r,g,b,a)) -> [[x,y,z],[r,g,b,a]]) vs
|
|
pokeLineStrat _ = []
|
|
|
|
pokeEllStrat (RenderEllipse vs) = fmap (\((x,y,z),(r,g,b,a)) -> [[x,y,z],[r,g,b,a]]) vs
|
|
pokeEllStrat _ = []
|
|
|
|
vert = VertexShader
|
|
geom = GeometryShader
|
|
frag = FragmentShader
|
|
|
|
pokeWPStrat :: (Point2,Point2) -> [[[Float]]]
|
|
pokeWPStrat ((x,y),(z,w)) = [[[x,y,z,w]]]
|
|
|
|
pokeWPColStrat :: ((Point2,Point2),Point4) -> [[[Float]]]
|
|
pokeWPColStrat (((x,y),(z,w)),(r,g,b,a)) = [[[x,y,z,w],[r,g,b,a]]]
|
|
|
|
pokeBGStrat :: a -> [[[Float]]]
|
|
pokeBGStrat = const []
|
|
|