diff --git a/shaders/map/tessControl.shader b/shaders/map/tessControl.shader index e7a5d25..a6f81b1 100644 --- a/shaders/map/tessControl.shader +++ b/shaders/map/tessControl.shader @@ -10,6 +10,9 @@ out vec4 tcColor[]; out vec3 tcNormal[]; uniform float TessLevelInner = 1.0; // controlled by keyboard buttons uniform float TessLevelOuter = 1.0; // controlled by keyboard buttons +uniform mat4 ProjectionMatrix; +uniform mat4 ViewMatrix; +uniform mat3 NormalMatrix; #define ID gl_InvocationID @@ -18,10 +21,28 @@ void main() tcPosition[ID] = vPosition[ID]; tcColor[ID] = vColor[ID]; tcNormal[ID] = vNormal[ID]; + float dist = (ProjectionMatrix * ViewMatrix * vec4(vPosition[ID], 1)).z; if (ID == 0) { - gl_TessLevelInner[0] = TessLevelInner; - gl_TessLevelOuter[0] = TessLevelOuter; - gl_TessLevelOuter[1] = TessLevelOuter; - gl_TessLevelOuter[2] = TessLevelOuter; + if (dist < 30) { + gl_TessLevelInner[0] = TessLevelInner; + gl_TessLevelOuter[0] = TessLevelOuter; + gl_TessLevelOuter[1] = TessLevelOuter; + gl_TessLevelOuter[2] = TessLevelOuter; + } else if (dist < 50) { + gl_TessLevelInner[0] = max(TessLevelInner-1.0,1.0); + gl_TessLevelOuter[0] = max(TessLevelOuter-1.0,1.0); + gl_TessLevelOuter[1] = max(TessLevelOuter-1.0,1.0); + gl_TessLevelOuter[2] = max(TessLevelOuter-1.0,1.0); + } else if (dist < 100) { + gl_TessLevelInner[0] = max(TessLevelInner-2.0,1.0); + gl_TessLevelOuter[0] = max(TessLevelOuter-2.0,1.0); + gl_TessLevelOuter[1] = max(TessLevelOuter-2.0,1.0); + gl_TessLevelOuter[2] = max(TessLevelOuter-2.0,1.0); + } else { + gl_TessLevelInner[0] = 1.0; + gl_TessLevelOuter[0] = 1.0; + gl_TessLevelOuter[1] = 1.0; + gl_TessLevelOuter[2] = 1.0; + } } -} \ No newline at end of file +} diff --git a/shaders/map/tessEval.shader b/shaders/map/tessEval.shader index 51cc5b3..513df69 100644 --- a/shaders/map/tessEval.shader +++ b/shaders/map/tessEval.shader @@ -133,7 +133,8 @@ void main() float i2 = (1-gl_TessCoord.z)*gl_TessCoord.z * length(cross(tcNormal[2],tessNormal)); float standout = i0+i1+i2; tePosition = tePosition+tessNormal*standout; - tePosition = tePosition+0.05*snoise(tePosition); + vec3 tmp = tePosition;//+clamp(tePosition,0,0.05)*snoise(tePosition/2); + tePosition = vec3(tePosition.x, tmp.y, tePosition.z); gl_Position = ProjectionMatrix * ViewMatrix * vec4(tePosition, 1); fogDist = gl_Position.z; diff --git a/shaders/mapobjects/fragment.shader b/shaders/mapobjects/fragment.shader new file mode 100644 index 0000000..ec6ac9f --- /dev/null +++ b/shaders/mapobjects/fragment.shader @@ -0,0 +1,157 @@ +#version 330 + +//#include "3rdParty/noise.glsl" + +vec3 mod289(vec3 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 mod289(vec4 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) { + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +float snoise(vec3 v) + { + const vec2 C = vec2(1.0/6.0, 1.0/3.0) ; + const vec4 D = vec4(0.0, 0.5, 1.0, 2.0); + +// First corner + vec3 i = floor(v + dot(v, C.yyy) ); + vec3 x0 = v - i + dot(i, C.xxx) ; + +// Other corners + vec3 g = step(x0.yzx, x0.xyz); + vec3 l = 1.0 - g; + vec3 i1 = min( g.xyz, l.zxy ); + vec3 i2 = max( g.xyz, l.zxy ); + + // x0 = x0 - 0.0 + 0.0 * C.xxx; + // x1 = x0 - i1 + 1.0 * C.xxx; + // x2 = x0 - i2 + 2.0 * C.xxx; + // x3 = x0 - 1.0 + 3.0 * C.xxx; + vec3 x1 = x0 - i1 + C.xxx; + vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y + vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y + +// Permutations + i = mod289(i); + vec4 p = permute( permute( permute( + i.z + vec4(0.0, i1.z, i2.z, 1.0 )) + + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) + + i.x + vec4(0.0, i1.x, i2.x, 1.0 )); + +// Gradients: 7x7 points over a square, mapped onto an octahedron. +// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294) + float n_ = 0.142857142857; // 1.0/7.0 + vec3 ns = n_ * D.wyz - D.xzx; + + vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7) + + vec4 x_ = floor(j * ns.z); + vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N) + + vec4 x = x_ *ns.x + ns.yyyy; + vec4 y = y_ *ns.x + ns.yyyy; + vec4 h = 1.0 - abs(x) - abs(y); + + vec4 b0 = vec4( x.xy, y.xy ); + vec4 b1 = vec4( x.zw, y.zw ); + + //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0; + //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0; + vec4 s0 = floor(b0)*2.0 + 1.0; + vec4 s1 = floor(b1)*2.0 + 1.0; + vec4 sh = -step(h, vec4(0.0)); + + vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ; + vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ; + + vec3 p0 = vec3(a0.xy,h.x); + vec3 p1 = vec3(a0.zw,h.y); + vec3 p2 = vec3(a1.xy,h.z); + vec3 p3 = vec3(a1.zw,h.w); + +//Normalise gradients + vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3))); + p0 *= norm.x; + p1 *= norm.y; + p2 *= norm.z; + p3 *= norm.w; + +// Mix final noise value + vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0); + m = m * m; + return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), + dot(p2,x2), dot(p3,x3) ) ); + } + +float fog(float dist) { + dist = max(0,dist - 50); + dist = dist * 0.05; +// dist = dist*dist; + return 1-exp(-dist); +} + +smooth in vec3 teNormal; +smooth in vec3 tePosition; +smooth in float fogDist; +smooth in float gmix; +in vec4 teColor; + +out vec4 fgColor; + +uniform mat4 ViewMatrix; +uniform mat4 ProjectionMatrix; + +void main(void) +{ + //fog color + vec4 fogColor = vec4(0.6,0.7,0.8,1.0); + + //heliospheric lighting + vec4 light = vec4(1.0,1.0,1.0,1.0); + vec4 dark = vec4(0.0,0.0,0.0,1.0); + //direction to sun from origin + vec3 lightDir = normalize(ViewMatrix * vec4(5.0,5.0,1.0,0.0)).xyz; + + float costheta = dot(teNormal, lightDir); + float a = costheta * 0.5 + 0.5; + + //create gravel-texel + vec3 uvw = tePosition; + // Six components of noise in a fractal sum + //float n = snoise(uvw * 10); + float n = 0; + n += 0.5 * snoise(uvw * 20.0); + //n += 0.25 * snoise(uvw * 40.0); + //n += 0.125 * snoise(uvw * 80.0); + //n += 0.0625 * snoise(uvw * 160.0); + //n += 0.03125 * snoise(uvw * 320.0); + n = abs(n*2);//[0,1] + + //dirt + float d = snoise(uvw); + d += 0.5 * snoise(uvw * 2); + d += 0.25 * snoise(uvw * 4); + d = d/3*2 +0.5; + + // base, dirt, noise-level*(above 0?)*(linear blend by y) + vec4 texBase = mix(teColor, vec4(0.45,0.27,0.1,1),d*d*step(0.01,tePosition.y)*clamp(tePosition.y/2,0,2)); + // stone highlights + vec4 texHighlights = mix(texBase, vec4(0.9*n,0.9*n,0.9*n,1),n*n*n); + //mix highlights into Color with inclination, if inclination^2 > 0.35 + vec4 texColor = mix(texBase,texHighlights, (gmix*(1-gmix))*4*(gmix*(1-gmix))*4); + vec4 Color = texColor; + + fgColor = Color * mix(dark, light, a); + fgColor = mix(fgColor,fogColor,fog(fogDist)); +} \ No newline at end of file diff --git a/shaders/mapobjects/tessControl.shader b/shaders/mapobjects/tessControl.shader new file mode 100644 index 0000000..e7a5d25 --- /dev/null +++ b/shaders/mapobjects/tessControl.shader @@ -0,0 +1,27 @@ +#version 330 +#extension GL_ARB_tessellation_shader : require + +layout(vertices = 3) out; +in vec3 vPosition[]; +in vec4 vColor[]; +in vec3 vNormal[]; +out vec3 tcPosition[]; +out vec4 tcColor[]; +out vec3 tcNormal[]; +uniform float TessLevelInner = 1.0; // controlled by keyboard buttons +uniform float TessLevelOuter = 1.0; // controlled by keyboard buttons + +#define ID gl_InvocationID + +void main() +{ + tcPosition[ID] = vPosition[ID]; + tcColor[ID] = vColor[ID]; + tcNormal[ID] = vNormal[ID]; + if (ID == 0) { + gl_TessLevelInner[0] = TessLevelInner; + gl_TessLevelOuter[0] = TessLevelOuter; + gl_TessLevelOuter[1] = TessLevelOuter; + gl_TessLevelOuter[2] = TessLevelOuter; + } +} \ No newline at end of file diff --git a/shaders/mapobjects/tessEval.shader b/shaders/mapobjects/tessEval.shader new file mode 100644 index 0000000..51cc5b3 --- /dev/null +++ b/shaders/mapobjects/tessEval.shader @@ -0,0 +1,149 @@ +#version 330 + +#extension GL_ARB_tessellation_shader : require + +//#include "shaders/3rdParty/noise.glsl" + +vec3 mod289(vec3 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 mod289(vec4 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) { + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +float snoise(vec3 v) + { + const vec2 C = vec2(1.0/6.0, 1.0/3.0) ; + const vec4 D = vec4(0.0, 0.5, 1.0, 2.0); + +// First corner + vec3 i = floor(v + dot(v, C.yyy) ); + vec3 x0 = v - i + dot(i, C.xxx) ; + +// Other corners + vec3 g = step(x0.yzx, x0.xyz); + vec3 l = 1.0 - g; + vec3 i1 = min( g.xyz, l.zxy ); + vec3 i2 = max( g.xyz, l.zxy ); + + // x0 = x0 - 0.0 + 0.0 * C.xxx; + // x1 = x0 - i1 + 1.0 * C.xxx; + // x2 = x0 - i2 + 2.0 * C.xxx; + // x3 = x0 - 1.0 + 3.0 * C.xxx; + vec3 x1 = x0 - i1 + C.xxx; + vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y + vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y + +// Permutations + i = mod289(i); + vec4 p = permute( permute( permute( + i.z + vec4(0.0, i1.z, i2.z, 1.0 )) + + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) + + i.x + vec4(0.0, i1.x, i2.x, 1.0 )); + +// Gradients: 7x7 points over a square, mapped onto an octahedron. +// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294) + float n_ = 0.142857142857; // 1.0/7.0 + vec3 ns = n_ * D.wyz - D.xzx; + + vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7) + + vec4 x_ = floor(j * ns.z); + vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N) + + vec4 x = x_ *ns.x + ns.yyyy; + vec4 y = y_ *ns.x + ns.yyyy; + vec4 h = 1.0 - abs(x) - abs(y); + + vec4 b0 = vec4( x.xy, y.xy ); + vec4 b1 = vec4( x.zw, y.zw ); + + //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0; + //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0; + vec4 s0 = floor(b0)*2.0 + 1.0; + vec4 s1 = floor(b1)*2.0 + 1.0; + vec4 sh = -step(h, vec4(0.0)); + + vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ; + vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ; + + vec3 p0 = vec3(a0.xy,h.x); + vec3 p1 = vec3(a0.zw,h.y); + vec3 p2 = vec3(a1.xy,h.z); + vec3 p3 = vec3(a1.zw,h.w); + +//Normalise gradients + vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3))); + p0 *= norm.x; + p1 *= norm.y; + p2 *= norm.z; + p3 *= norm.w; + +// Mix final noise value + vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0); + m = m * m; + return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), + dot(p2,x2), dot(p3,x3) ) ); + } + + +layout(triangles, equal_spacing, cw) in; +in vec3 tcPosition[]; +in vec4 tcColor[]; +in vec3 tcNormal[]; +out vec4 teColor; +smooth out vec3 tePosition; +smooth out vec3 teNormal; +smooth out float fogDist; +smooth out float gmix; //mixture of gravel +//out vec3 tePatchDistance; +//constant projection matrix +uniform mat4 ProjectionMatrix; +uniform mat4 ViewMatrix; +uniform mat3 NormalMatrix; + +void main() +{ + //NORMAL + vec3 n0 = gl_TessCoord.x * tcNormal[0]; + vec3 n1 = gl_TessCoord.y * tcNormal[1]; + vec3 n2 = gl_TessCoord.z * tcNormal[2]; + vec3 tessNormal = normalize(n0 + n1 + n2); + teNormal = NormalMatrix * tessNormal; + + //POSITION + vec3 p0 = gl_TessCoord.x * tcPosition[0]; + vec3 p1 = gl_TessCoord.y * tcPosition[1]; + vec3 p2 = gl_TessCoord.z * tcPosition[2]; + tePosition = p0 + p1 + p2; + + //sin(a,b) = length(cross(a,b)) + float i0 = (1-gl_TessCoord.x)*gl_TessCoord.x * length(cross(tcNormal[0],tessNormal)); + float i1 = (1-gl_TessCoord.y)*gl_TessCoord.y * length(cross(tcNormal[1],tessNormal)); + float i2 = (1-gl_TessCoord.z)*gl_TessCoord.z * length(cross(tcNormal[2],tessNormal)); + float standout = i0+i1+i2; + tePosition = tePosition+tessNormal*standout; + tePosition = tePosition+0.05*snoise(tePosition); + gl_Position = ProjectionMatrix * ViewMatrix * vec4(tePosition, 1); + fogDist = gl_Position.z; + + //COLOR-BLENDING + vec4 c0 = (1-exp(gl_TessCoord.x)) * tcColor[0]; + vec4 c1 = (1-exp(gl_TessCoord.y)) * tcColor[1]; + vec4 c2 = (1-exp(gl_TessCoord.z)) * tcColor[2]; + teColor = (c0 + c1 + c2)/((1-exp(gl_TessCoord.x))+(1-exp(gl_TessCoord.y))+(1-exp(gl_TessCoord.z))); + + //mix gravel based on incline (sin (normal,up)) + gmix = length(cross(tessNormal, vec3(0,1,0))); + +} diff --git a/shaders/mapobjects/vertex.shader b/shaders/mapobjects/vertex.shader new file mode 100644 index 0000000..c6e3c7c --- /dev/null +++ b/shaders/mapobjects/vertex.shader @@ -0,0 +1,18 @@ +#version 330 + +//vertex-data +in vec4 Color; +in vec3 Position; +in vec3 Normal; + +//output-data for later stages +out vec4 vColor; +out vec3 vPosition; +out vec3 vNormal; + +void main() +{ + vPosition = Position; + vNormal = Normal; + vColor = Color; +} \ No newline at end of file diff --git a/src/Main.hs b/src/Main.hs index 41c77dd..b4eb989 100644 --- a/src/Main.hs +++ b/src/Main.hs @@ -132,6 +132,7 @@ main = } , _io = IOState { _clock = now + , _tessClockFactor = 0 } , _mouse = MouseState { _isDown = False @@ -228,17 +229,30 @@ run = do } -} - mt <- liftIO $ do - let double = fromRational.toRational :: (Real a) => a -> Double + (mt,tc,sleepAmount) <- liftIO $ do + let double = fromRational.toRational :: (Real a) => a -> Double + targetFramerate = 40.0 + targetFrametime = 1.0/targetFramerate + targetFrametimeμs = targetFrametime * 1000000.0 now <- getCurrentTime - diff <- return $ diffUTCTime now (state ^. io.clock) -- get time-diffs - title <- return $ unwords ["Pioneers @ ",show ((round . double $ 1.0/diff)::Int),"fps"] + let diff = diffUTCTime now (state ^. io.clock) -- get time-diffs + title = unwords ["Pioneers @ ",show ((round . double $ 1.0/diff)::Int),"fps"] setWindowTitle (env ^. windowObject) title - sleepAmount <- return $ floor (max 0 (0.04 - diff))*1000000 -- get time until next frame in microseconds - threadDelay sleepAmount - return now + let sleepAmount = floor ((targetFrametime - double diff)*1000000) :: Int -- get time until next frame in microseconds + clockFactor = (state ^. io.tessClockFactor) + tessChange + | (clockFactor > (2*targetFrametimeμs)) && (state ^. gl.glMap.stateTessellationFactor < 5) = ((+)1 :: Int -> Int) + -- > factor < 5 & 10% of frame idle -> increase graphics + | sleepAmount < 0 && (state ^. gl.glMap.stateTessellationFactor > 1) = (flip (-) 1 :: Int -> Int) + -- frame used up completely -> decrease + | otherwise = ((+)0 :: Int -> Int) -- 0ms > x > 10% -> keep settings + when (sleepAmount > 0) $ threadDelay sleepAmount + return (now,tessChange,sleepAmount) -- set state with new clock-time - modify $ io.clock .~ mt + modify $ (io.clock .~ mt) + . (gl.glMap.stateTessellationFactor %~ tc) + . (io.tessClockFactor %~ (((+) (fromIntegral sleepAmount)).((*) 0.99))) + -- liftIO $ putStrLn $ concat $ ["TessFactor at: ",show (state ^. gl.glMap.stateTessellationFactor), " - slept for ",show sleepAmount, "μs."] shouldClose' <- return $ state ^. window.shouldClose unless shouldClose' run diff --git a/src/Render/Render.hs b/src/Render/Render.hs index 6b3e4d3..4878bc2 100644 --- a/src/Render/Render.hs +++ b/src/Render/Render.hs @@ -22,6 +22,8 @@ import Types import Render.Misc import Render.Types import Graphics.GLUtil.BufferObjects (makeBuffer) +import Importer.IQM.Parser +import Importer.IQM.Types mapVertexShaderFile :: String mapVertexShaderFile = "shaders/map/vertex.shader" @@ -32,6 +34,11 @@ mapTessEvalShaderFile = "shaders/map/tessEval.shader" mapFragmentShaderFile :: String mapFragmentShaderFile = "shaders/map/fragment.shader" +objectVertexShaderFile :: String +objectVertexShaderFile = "shaders/mapobjects/vertex.shader" +objectFragmentShaderFile :: String +objectFragmentShaderFile = "shaders/mapobjects/fragment.shader" + uiVertexShaderFile :: String uiVertexShaderFile = "shaders/ui/vertex.shader" uiFragmentShaderFile :: String @@ -113,6 +120,21 @@ initMapShader tessFac (buf, vertDes) = do texts <- genObjectNames 6 + testobj <- parseIQM "sample.iqm" + + let + objs = [MapObject testobj (L.V3 0 10 0) (MapObjectState ())] + + ! vertexSource' <- B.readFile objectVertexShaderFile + ! fragmentSource' <- B.readFile objectFragmentShaderFile + vertexShader' <- compileShaderSource VertexShader vertexSource' + checkError "compile Object-Vertex" + fragmentShader' <- compileShaderSource FragmentShader fragmentSource' + checkError "compile Object-Fragment" + objProgram <- createProgramUsing [vertexShader', fragmentShader'] + checkError "compile Object-Program" + + currentProgram $= Just objProgram checkError "initShader" return GLMapState @@ -132,6 +154,8 @@ initMapShader tessFac (buf, vertDes) = do , _mapVert = vertDes , _overviewTexture = overTex , _mapTextures = texts + , _mapObjects = objs + , _objectProgram = objProgram } initHud :: IO GLHud @@ -266,6 +290,16 @@ renderOverview = do -} +-- | renders an IQM-Model at Position with scaling +renderIQM :: IQM -> L.V3 CFloat -> L.V3 CFloat -> IO () +renderIQM m p@(L.V3 x y z) s@(L.V3 sx sy sz) = do + return () + +renderObject :: MapObject -> IO () +renderObject (MapObject model pos@(L.V3 x y z) _{-state-}) = + renderIQM model pos (L.V3 1 1 1) + + render :: Pioneers () render = do state <- RWS.get @@ -354,8 +388,19 @@ render = do cullFace $= Just Front glDrawArrays gl_PATCHES 0 (fromIntegral numVert) + + + currentProgram $= Just (state ^. gl.glMap.objectProgram) + + checkError "draw map" + ---- RENDER MAPOBJECTS -------------------------------------------- + + currentProgram $= Just (state ^. gl.glMap.objectProgram) + + mapM_ renderObject (state ^. gl.glMap.mapObjects) + -- set sample 1 as target in renderbuffer {-framebufferRenderbuffer DrawFramebuffer --write-only diff --git a/src/Types.hs b/src/Types.hs index 87726b7..8583f1a 100644 --- a/src/Types.hs +++ b/src/Types.hs @@ -8,12 +8,15 @@ import Foreign.C (CFloat) import qualified Data.HashMap.Strict as Map import Data.Time (UTCTime) import Linear.Matrix (M44) +import Linear (V3) import Control.Monad.RWS.Strict (RWST) import Control.Lens import Graphics.Rendering.OpenGL.GL.Texturing.Objects (TextureObject) import Render.Types +import Importer.IQM.Types import UI.UIBase +data Coord3D a = Coord3D a a a --Static Read-Only-State data Env = Env @@ -49,6 +52,7 @@ data CameraState = CameraState data IOState = IOState { _clock :: !UTCTime + , _tessClockFactor :: !Double } data GameState = GameState @@ -113,8 +117,16 @@ data GLMapState = GLMapState , _renderedMapTexture :: !TextureObject --TODO: Probably move to UI? , _overviewTexture :: !TextureObject , _mapTextures :: ![TextureObject] --TODO: Fix size on list? + , _objectProgram :: !GL.Program + , _mapObjects :: ![MapObject] } +data MapObject = MapObject !IQM !MapCoordinates !MapObjectState + +data MapObjectState = MapObjectState () + +type MapCoordinates = V3 CFloat + data GLHud = GLHud { _hudTexture :: !TextureObject -- ^ HUD-Texture itself , _hudTexIndex :: !GL.UniformLocation -- ^ Position of Overlay-Texture in Shader