drawPixel(V) not working?

[sojastar]

Hello,

Thank you for these very extensive bindings! I have been using them to learn Haskell with Paul Hudak's Haskell School of Expression. So far so good but I can't seem to be able to draw a single pixel. I managed to draw other graphic primitives, but not a single pixel though the binding exists. Here is how I am doing it:

module Main where

-- 1. Imports :
import Raylib.Core (clearBackground)
import Raylib.Core.Shapes (drawPixel, drawPixelV, drawTriangle)
import Raylib.Types(Vector2 (Vector2))
import Raylib.Util (drawing, whileWindowOpen0, withWindow)
import Raylib.Util.Colors (lightGray, red)


-- 2. Constants :
fbWidth, fbHeight :: Int
fbWidth   = 160
fbHeight  = 120


-- 3. Main Loop :
main :: IO ()
main = do
  withWindow
    fbWidth
    fbHeight
    "Ray Marching Demo"
    60
    ( \window -> do
        whileWindowOpen0
          ( drawing
            ( do
              clearBackground lightGray
              drawPixel 80 60 red
              drawPixelV (Vector2 82 62) red
              drawTriangle (Vector2 100 100) (Vector2 120 100) (Vector2 110 90) red
            )
          )
    )

This code does draw the red triangle, but not the 2 red pixels. Any suggestions?

Thanks!

[sojastar]

I just asked a friend to give the code a try and the pixels properly draw on his machine. His version of Raylib is 4.6. Mine is 5.1. I just tried reproducing the code in C and the pixels do appear.

[Anut-py]

I ran your code and the pixels do appear for me, but the triangle is in a different position than the screenshot you attached. Is that from a previous version of the code?

[sojastar]

Yes, sorry, that was a different version of the code.

I have pursued the investigations a little bit deeper and I am more and more confused. I have tried two basic and, I believe, equivalent programs, one in C/raylib 5.0 and one in Haskell/h-raylib 5.1. These programs completely fill the window with white pixels on a black background. I ran those programs on 3 machines: a 2013 MacBook Air, 2018 MacMini, both Intel machines, and a 2022 M1 MacBook Air.

The C Program shows consistent results on all machines: a completely white window.

The Haskell program works perfectly on the M1. On the 2013 MacBook Air, the window remains black, it looks like no pixel is drawn. On the MacMini (with a 4K display), the program show a lattice of white points rendered on the black background. Here is a screenshot (you may have to zoom on the picture to see it):

This looks like an SD/HD alignment problem (I don't know how to call it, I am not expert at all in these maters). But the M1 Retina screen doesn't seem affected.

Also, replacing drawPixel by drawRectangle with 1x1 pixels works perfectly fine.

Here are the programs:

module Main where

-- 1. Imports :
import Raylib.Core (clearBackground)
import Raylib.Core.Shapes (drawPixel,drawRectangle)
import Raylib.Util (drawing, whileWindowOpen0, withWindow)
import Raylib.Util.Colors (black, white)


-- 2. Constants :
windowWidth, windowHeight :: Int
windowWidth   = 160
windowHeight  = 120

-- 3. Main Loop :
main :: IO ()
main = do
  let pixels    = [(x,y,white) | y <- [0..windowHeight-1], x <- [0..windowWidth-1]]
      drawCalls = map (\(x,y,c) -> drawPixel x y c) pixels
      --drawCalls = map (\(x,y,c) -> drawRectangle x y 1 1 c) pixels

  withWindow
    windowWidth
    windowHeight
    "drawPixel test"
    60
    ( \window -> do
        whileWindowOpen0
          ( drawing
              ( do
                  clearBackground black
                  sequence_ drawCalls
              )
          )
    )

and

#include "raylib.h"

int main(void) {
    const int screenWidth = 160;
    const int screenHeight = 120;

    InitWindow(screenWidth, screenHeight, "drawPixel test");

    SetTargetFPS(60);

    while (!WindowShouldClose()) {
        BeginDrawing();

        ClearBackground(BLACK);

        int x, y;
        for(y = 0; y < screenHeight; y++)
          for(x = 0; x < screenWidth; x++)
            DrawPixel(x, y, WHITE);

        EndDrawing();
    }

    CloseWindow();

    return 0;
}

[Anut-py]

Which exact version of h-raylib are you using (5.1.0.1 or 5.1.1.0) and what is your build system?

[Anut-py]

If you are using 5.1.0.1, then this is a known bug with raylib. The C raylib version used by h-raylib 5.1.0.1 does not have the fix, h-raylib 5.1.1.0 does. This is the fix, which was committed only a month ago.

[Anut-py]

By the way, drawPixel is extremely slow. If you are doing something like raytracing (which I'm guessing is true, based on the window title), it is better to use an image for rendering. Unfortunately, you'll have to use raw pointers to do this. I have written a proof-of-concept below, the performance is much better than drawPixel but it is not very readable. If you are learning Haskell, just use drawPixel, it's not worth it to worry about the performance.

{-# OPTIONS -Wall #-}
{-# LANGUAGE BangPatterns #-}

module Main where

-- 1. Imports :

import Data.Foldable (forM_)
import Foreign (Storable (peek, poke), castPtr, free, malloc)
import Raylib.Core (clearBackground)
import Raylib.Core.Textures (c'imageDrawPixel, c'unloadImage, drawTexture, genImageColor, loadTextureFromImage, updateTexture)
import Raylib.Types (p'image'data)
import Raylib.Util (drawing, whileWindowOpen0, withWindow)
import Raylib.Util.Colors (black, red, white)

-- 2. Constants :
windowWidth, windowHeight :: Int
windowWidth = 800
windowHeight = 600

-- 3. Main Loop :
main :: IO ()
main = do
  whitePtr <- malloc
  poke whitePtr white
  redPtr <- malloc
  poke redPtr red
  -- red/white checkerboard
  let !pixels = [(x, y, if odd ((x `div` 10) + (y `div` 10)) then whitePtr else redPtr) | y <- [0 .. windowHeight - 1], x <- [0 .. windowWidth - 1]]

  withWindow
    windowWidth
    windowHeight
    "drawPixel test"
    60
    ( \window -> do
        imagePtr <- malloc -- mutable pointer
        blackBg <- genImageColor (fromIntegral windowWidth) (fromIntegral windowHeight) black -- this is a regular haskell record, it is not mutable
        poke imagePtr blackBg

        tex <- loadTextureFromImage blackBg window

        whileWindowOpen0
          ( drawing
              ( do
                  clearBackground black
                  forM_ pixels (\(x, y, c) -> c'imageDrawPixel imagePtr (fromIntegral x) (fromIntegral y) c) -- update the mutable pointer
                  _ <- updateTexture tex . castPtr =<< peek (p'image'data imagePtr) -- access the raw data
                  drawTexture tex 0 0 white
              )
          )

        free whitePtr
        free redPtr
        c'unloadImage imagePtr
        free imagePtr
    )

[sojastar]

Ah! I feel so stupid, updating should have been my first reflex. It all works now! I installed h-raylib about a month ago, probably a few days before the Raylib patch was published. Sorry I have taken some of your time for this. And thank you very much for the

You guessed right, I am indeed trying to teach myself ray marching/ray tracing. Speed does not matter at this stage but thank you very much for the suggested code, as it will probably come in handy as some point.

Thanks again!