Drawing lines with opengl in Haskell

Question

I'm trying to create a go board using opengl. To do this, I'm trying to draw a bunch of lines to create the grid. However, every tutorial site (including opengl's) has the examples in C++ and the Haskell wiki doesn't do a good job of explaining it. I'm new to opengl and would like a tutorial.

Answer 1

I'll assume that you want to use OpenGL 2.1 or earlier. For OpenGL 3.0, you need different code.

So, in C you would write this:

glBegin(GL_LINES);
glVertex3f(1, 2, 3);
glVertex3f(5, 6, 7);
glEnd();

You write the equivalent in Haskell like this:

renderPrimitive Lines $ do
  vertex $ Vertex3 1 2 3
  vertex $ Vertex3 5 6 7

With this code, since I used e.g. 1 instead of some variable, you might get errors about ambiguous types (So you should replace 1 with (1 :: GLfloat)), but if you use actual variables that already have the type GLfloat, you shouldn't have to do this.

Here's a complete program that draws a white diagonal in the window:

import Graphics.Rendering.OpenGL
import Graphics.UI.GLUT

main :: IO ()
main = do
  -- Initialize OpenGL via GLUT
  (progname, _) <- getArgsAndInitialize

  -- Create the output window
  createWindow progname

  -- Every time the window needs to be updated, call the display function
  displayCallback $= display

  -- Let GLUT handle the window events, calling the displayCallback as fast as it can
  mainLoop

display :: IO ()
display = do
  -- Clear the screen with the default clear color (black)
  clear [ ColorBuffer ]

  -- Render a line from the bottom left to the top right
  renderPrimitive Lines $ do
    vertex $ (Vertex3 (-1) (-1)  0 :: Vertex3 GLfloat)
    vertex $ (Vertex3   1    1   0 :: Vertex3 GLfloat)

  -- Send all of the drawing commands to the OpenGL server
  flush

The default OpenGL fixed-function projection uses (-1, -1) for the bottom left and (1, 1) for the top right of the window. You need to alter the projection matrix to get different coordinate spaces.

For more complete examples like this, see the Haskell port of the NEHE tutorials. They use the RAW OpenGL bindings, which are more like the C bindings.

Answer 2

A quick google turned up this:

http://www.haskell.org/haskellwiki/OpenGLTutorial1

In any case, since OpenGL is originally a C library, you may want to get your feet wet in C (or C++) first, since you'll be able to use the original OpenGL documentation as-is; after that, you may want to dig into the Haskell bindings and see how you use the same OpenGL calls in Haskell.