Continue render refactor

src/Shader/AuxAddition.hs

@@ -62,8 +62,8 @@ addTexture2D nlev minfilt magfilt texpath shad = do
 -- | for transforming a 256x256 image containing 64 tiles of 16x16 pixels into
 -- an image that was directly readable by glTexSubImage3D, used the
 -- transformation tilesToLine 8 128 on the underlying pixels.
-addTextureArray :: String -> FullShader -> IO FullShader
-addTextureArray texturePath shad = do
+addTextureArray :: String -> (FullShader,VBO) -> IO (FullShader,VBO)
+addTextureArray texturePath (shad,vbo) = do
     err <- glGetError
     print err
     Right cmap <- readImage texturePath
@@ -75,8 +75,9 @@ addTextureArray texturePath shad = do
         glGenerateTextureMipmap texname
         glTextureParameteri texname GL_TEXTURE_MIN_FILTER (unsafeCoerce GL_LINEAR_MIPMAP_LINEAR)
         glTextureParameteri texname GL_TEXTURE_MAG_FILTER (unsafeCoerce GL_LINEAR)
-        return $ shad & shadTex' ?~ ShaderTexture 
+        return (shad & shadTex' ?~ ShaderTexture 
             { _textureObject = texname}
+            , vbo)
 
 -- I am completely unclear on why this works with its current parameters
 tilesToLine 

src/Shader/Bind.hs

@@ -22,11 +22,11 @@ bindArrayBuffers numVs theVBO = glNamedBufferSubData
         (fromIntegral $ floatSize * numVs * sum (_vboAttribSizes theVBO)) 
         (_vboPtr theVBO)
 
-bindShaderLayers :: MV.MVector (PrimState IO) FullShader -> UMV.MVector (PrimState IO) Int -> IO ()
+bindShaderLayers :: MV.MVector (PrimState IO) (FullShader, VBO) -> UMV.MVector (PrimState IO) Int -> IO ()
 bindShaderLayers shads counts = MV.imapM_ f shads
   where
     f i shad = do
-        let theVBO = _vaoVBO $ _shadVAO' shad
+        let theVBO = snd shad
             stride = sum $ _vboAttribSizes theVBO
         VFSM.mapM_ (g stride theVBO) $ VFSM.enumFromStepN 0 1 6 -- [0..5]
       where
@@ -41,12 +41,12 @@ bindShaderLayers shads counts = MV.imapM_ f shads
 glNamedBufferSubDataH :: GLuint -> GLintptr -> GLsizeiptr -> Ptr a -> IO ()
 glNamedBufferSubDataH = glNamedBufferSubData
 
-bindShader :: MV.MVector (PrimState IO) FullShader -> UMV.MVector (PrimState IO) Int -> IO ()
+bindShader :: MV.MVector (PrimState IO) (FullShader,VBO) -> UMV.MVector (PrimState IO) Int -> IO ()
 bindShader shads counts = MV.imapM_ f shads
   where
-    f i shad = UMV.read counts i >>= flip bindArrayBuffers (_vaoVBO . _shadVAO' $ shad)
+    f i shad = UMV.read counts i >>= flip bindArrayBuffers (snd shad)
 
-bindShaderBuffers :: [FullShader] -> [Int] -> IO ()
+bindShaderBuffers :: [VBO] -> [Int] -> IO ()
 bindShaderBuffers = zipWithM_ f
   where 
-    f fs i = bindArrayBuffers i $ _vaoVBO $ _shadVAO' fs
+    f fs i = bindArrayBuffers i fs

src/Shader/Compile.hs

@@ -29,18 +29,18 @@ makeShader ::
     -- | The input vertex sizes
     [Int] ->
     EPrimitiveMode ->
-    IO FullShader
+    IO (FullShader,VBO)
 makeShader s shaderlist sizes pm = do
     prog <- makeSourcedShader s shaderlist
-    vaob <- setupVAO sizes
-    return $
-        FullShader
+    (vao,vbo) <- setupVAO sizes
+    return ( FullShader
             { _shadName = prog
-            , _shadVAO' = vaob
+            , _shadVAO' = vao
             , _shadPrim' = pm
             , _shadTex' = Nothing
             , _shadUnis' = mempty
             }
+            , vbo)
 
 makeByteStringShaderUsingVAO ::
     -- | (Arbitrary) name of the shader
@@ -95,18 +95,18 @@ makeShaderSized ::
     -- | Number of vertexes that can be poked
     Int ->
     EPrimitiveMode ->
-    IO FullShader
+    IO (FullShader,VBO)
 makeShaderSized s shaderlist sizes ndraw pm = do
     prog <- makeSourcedShader s shaderlist
-    vaob <- setupVAOSized ndraw sizes
-    return $
-        FullShader
+    (vao,vbo) <- setupVAOSized ndraw sizes
+    return ( FullShader
             { _shadName = prog
-            , _shadVAO' = vaob
+            , _shadVAO' = vao
             , _shadPrim' = pm
             , _shadTex' = Nothing
             , _shadUnis' = mempty
             }
+        , vbo)
 
 {- | Compile shader and get its uniform locations.
  supposes the shader code is in the shader folder, with the string names
@@ -124,21 +124,20 @@ shaderTypeExt' GL_FRAGMENT_SHADER = ".frag"
 shaderTypeExt' _ = undefined
 
 -- I think that this requires that the correct shader program is bound?
-setupVAO :: [Int] -> IO VAO
+setupVAO :: [Int] -> IO (VAO,VBO)
 setupVAO = setupVAOSized numDrawableElements
 
-setupVAOSized :: Int -> [Int] -> IO VAO
+setupVAOSized :: Int -> [Int] -> IO (VAO,VBO)
 setupVAOSized ndraw sizes = do
     vaoname <- mglCreate glCreateVertexArrays
     glBindVertexArray vaoname
     theVBO <- setupVBOSized ndraw vaoname sizes
-    return $
-        VAO
+    return ( VAO
             { _vaoName = vaoname
             , _vaoAttribSizes = sizes
             , _vaoStride = sum sizes
-            , _vaoVBO = theVBO
             }
+        , theVBO)
 
 setupVBOSized :: Int -> GLuint -> [Int] -> IO VBO
 setupVBOSized ndraw vao sizes = do

src/Shader/Data.hs

@@ -11,7 +11,7 @@ module Shader.Data
     , EPrimitiveMode (..)
 -- | Lens functions
     , vaoName
-    , vaoVBO
+--    , vaoVBO
     , vaoAttribSizes
     , vaoStride
 
@@ -50,7 +50,7 @@ data VAO = VAO
     { _vaoName  :: GLuint
     , _vaoAttribSizes :: [Int]  -- ^ It is not clear to me if this is necessary to store or not
     , _vaoStride      :: Int
-    , _vaoVBO   :: VBO
+--    , _vaoVBO   :: VBO
     }
 {- | Vertex buffer object: contains the reference to the object,
 a pointer to a location with space that can be written to the buffer,
@@ -61,6 +61,7 @@ data VBO = VBO
     , _vboPtr         :: Ptr Float
     , _vboAttribSizes :: [Int]  -- ^ It is not clear to me if this is necessary to store or not
     , _vboStride      :: Int
+    -- add int for AMOUNT of data poked!
     }
 data EBO = EBO
     { _eboName  :: GLuint

src/Shader/Poke.hs

@@ -25,17 +25,17 @@ import Control.Monad.Primitive
 --import qualified Control.Monad.Parallel as MP
 
 pokeVerxs 
-    :: MV.MVector (PrimState IO) FullShader
+    :: MV.MVector (PrimState IO) (FullShader,VBO)
     -> UMV.MVector (PrimState IO) Int 
     -> Picture
     -> IO ()
 --pokeVerxs vbos count = S.mapM_ (pokeVerx vbos count) . S.each
 pokeVerxs vbos count = VFSM.mapM_ (pokeVerx vbos count) . VFSM.fromList
 
-pokeVerx :: MV.MVector (PrimState IO) FullShader -> UMV.MVector (PrimState IO) Int -> Verx -> IO ()
+pokeVerx :: MV.MVector (PrimState IO) (FullShader,VBO) -> UMV.MVector (PrimState IO) Int -> Verx -> IO ()
 pokeVerx vbos offsets Verx{_vxPos=thePos,_vxCol=theCol,_vxExt=ext,_vxShadNum=theShadNum} = do
     typeOff <- UMV.unsafeRead offsets sn
-    basePtr <- _vboPtr . _vaoVBO . _shadVAO' <$> MV.unsafeRead vbos sn
+    basePtr <- _vboPtr . snd <$> MV.unsafeRead vbos sn
     let thePtr = plusPtr basePtr (typeOff * pokeStride sn * floatSize)
     poke34 thePtr thePos theCol
     pokeArrayOff thePtr 7 ext
@@ -185,18 +185,18 @@ pokeJustV ptr nv sh = do
     V4 d e f g  = _svCol sh
 
 pokeLayVerxs 
-    :: MV.MVector (PrimState IO) FullShader 
+    :: MV.MVector (PrimState IO) (FullShader ,VBO)
     -> UMV.MVector (PrimState IO) Int
     -> Picture 
     -> IO ()
 --pokeLayVerxs vbos counts = S.mapM_ (pokeLayVerx vbos counts) . S.each
 pokeLayVerxs vbos counts = VFSM.mapM_ (pokeLayVerx vbos counts) . VFSM.fromList
 
-pokeLayVerx :: MV.MVector (PrimState IO) FullShader -> UMV.MVector (PrimState IO) Int -> Verx -> IO ()
+pokeLayVerx :: MV.MVector (PrimState IO) (FullShader,VBO) -> UMV.MVector (PrimState IO) Int -> Verx -> IO ()
 --{-# INLINE pokeLayVerx #-}
 pokeLayVerx vbos counts vx = do
     theOff <- UMV.unsafeRead counts vecPos
-    basePtr <- _vboPtr . _vaoVBO . _shadVAO' <$> MV.unsafeRead vbos sn
+    basePtr <- _vboPtr . snd <$> MV.unsafeRead vbos sn
     let thePtr = plusPtr basePtr ((theOff + layOff) * theStride * floatSize)
     poke34 thePtr thePos theCol
     pokeArrayOff thePtr 7 (_vxExt vx)