90 lines
3 KiB
Text
90 lines
3 KiB
Text
## Naïve code cleaning
|
|
|
|
The first approach to clean the code is to separate the GLUT/OpenGL
|
|
part from the computation of the shape.
|
|
Here is the cleaned version of the preceding section.
|
|
Most boilerplate was put in external files.
|
|
|
|
- [`YBoiler.hs`](code/04_Mandelbulb/YBoiler.hs), the 3D rendering
|
|
- [`Mandel`](code/04_Mandelbulb/Mandel.hs), the mandel function
|
|
- [`ExtComplex`](code/04_Mandelbulb/ExtComplex.hs), the extended complexes
|
|
|
|
> import YBoiler -- Most the OpenGL Boilerplate
|
|
> import Mandel -- The 3D Mandelbrot maths
|
|
|
|
The `yMainLoop` takes two arguments:
|
|
the title of the window
|
|
and a function from time to triangles
|
|
|
|
> main :: IO ()
|
|
> main = yMainLoop "3D Mandelbrot" (\_ -> allPoints)
|
|
|
|
We set some global constant (this is generally bad).
|
|
|
|
> nbDetails = 200 :: GLfloat
|
|
> width = nbDetails
|
|
> height = nbDetails
|
|
> deep = nbDetails
|
|
|
|
We then generate colored points from our function.
|
|
This is similar to the preceding section.
|
|
|
|
> allPoints :: [ColoredPoint]
|
|
> allPoints = planPoints ++ map inverseDepth planPoints
|
|
> where
|
|
> planPoints = depthPoints ++ map inverseHeight depthPoints
|
|
> inverseHeight (x,y,z,c) = (x,-y,z,c)
|
|
> inverseDepth (x,y,z,c) = (x,y,-z+1/deep,c)
|
|
|
|
> depthPoints :: [ColoredPoint]
|
|
> depthPoints = do
|
|
> x <- [-width..width]
|
|
> y <- [0..height]
|
|
> let
|
|
> neighbors = [(x,y),(x+1,y),(x+1,y+1),(x,y+1)]
|
|
> depthOf (u,v) = maxZeroIndex (ymandel u v) 0 deep 7
|
|
> -- zs are 3D points with found depth
|
|
> zs = map (\(u,v) -> (u,v,depthOf (u,v))) neighbors
|
|
> -- ts are 3D pixels + mandel value
|
|
> ts = map (\(u,v,w) -> (u,v,w,ymandel u v (w+1))) zs
|
|
> -- ps are 3D opengl points + color value
|
|
> ps = map (\(u,v,w,c') ->
|
|
> (u/width,v/height,w/deep,colorFromValue c')) ts
|
|
> -- If the point diverged too fast, don't display it
|
|
> if (and $ map (\(_,_,_,c) -> c>=57) ts)
|
|
> then []
|
|
> -- Draw two triangles
|
|
> else [ps!!0,ps!!1,ps!!2,ps!!0,ps!!2,ps!!3]
|
|
>
|
|
>
|
|
> -- given f min max nbtest,
|
|
> -- considering
|
|
> -- - f is an increasing function
|
|
> -- - f(min)=0
|
|
> -- - f(max)≠0
|
|
> -- then maxZeroIndex f min max nbtest returns x such that
|
|
> -- f(x - ε)=0 and f(x + ε)≠0
|
|
> -- where ε=(max-min)/2^(nbtest+1)
|
|
> maxZeroIndex func minval maxval 0 = (minval+maxval)/2
|
|
> maxZeroIndex func minval maxval n =
|
|
> if (func medpoint) /= 0
|
|
> then maxZeroIndex func minval medpoint (n-1)
|
|
> else maxZeroIndex func medpoint maxval (n-1)
|
|
> where medpoint = (minval+maxval)/2
|
|
>
|
|
> colorFromValue n =
|
|
> let
|
|
> t :: Int -> GLfloat
|
|
> t i = 0.7 + 0.3*cos( fromIntegral i / 10 )
|
|
> in
|
|
> ((t n),(t (n+5)),(t (n+10)))
|
|
>
|
|
> ymandel x y z = mandel (2*x/width) (2*y/height) (2*z/deep) 64
|
|
|
|
This code is cleaner but many things doesn't feel right.
|
|
First, all the user interaction code is outside our main file.
|
|
I feel it is okay to hide the detail for the rendering.
|
|
But I would have preferred to control the user actions.
|
|
|
|
On the other hand, we continue to handle a lot rendering details.
|
|
For example, we provide ordered vertices.
|