Pokitto-Raycasting/helloRay.cpp

/**
  Raycasting hello world program for Pokitto, using raycastlib.

  author: Miloslav "drummyfish" Ciz
  license: CC0 1.0
*/

#define RCL_PIXEL_FUNCTION pixelFunc
/* ^ Before including raycastlib, this has to be set to the name of the
     function that will render pixels. It allows super performance. */

#define RCL_COMPUTE_WALL_TEXCOORDS 0
/* ^ We won't be using textures, so turn them off. */

/* There are many other options that can be defined here, check the library
   for details. Don't forget to disable the features you won't be using - it
   will speed up the rendering. */

#include "raycastlib.h"
#include "Pokitto.h"

Pokitto::Core pokitto;

RCL_Camera camera; // Defines a view that will be rendered.
RCL_RayConstraints constraints;

/* Function that for given square coordinates returns height of the floor
   (in RCL_Units). */
RCL_Unit floorHeightAt(int16_t x, int16_t y)
{
  return x < 0 || x >= 10 || y < 0 || y >= 10 ?
    RCL_UNITS_PER_SQUARE * 2 : 0;
    /* ^ RCL_UNITS_PER_SQUARE is the length of one side of the game square.
         Since we'll place the camera at RCL_UNITS_PER_SQUARE height, let's
         make the walls twice as high. */

  /* You can either generate the level procedurally as above, or read it from
     an array and return it here. */
}

/* Function that will be called by the library in order to draw individual
   pixels (similar to fragment shaders in OpenGL). */

void pixelFunc(RCL_PixelInfo *pixel)
{
  uint8_t color;

  /* The pixel variable holds all kind of info about the pixel to be rendered.
     Check the PixelInfo struct for details. */

  if (pixel->isWall)
    color = pixel->hit.direction + 2; // give walls different colors
  else
    color = pixel->isFloor ? 10 : 11; // also make ceiling and floor differ

  /* You can do all kinds of processing here and draw the pixel wherever you
     want, or even discard it. Just remember this function has to be fast and
     will usually be the bottleneck. */

  pokitto.display.drawPixel(pixel->position.x,pixel->position.y,color);
}

void draw()
{
  /* This triggers the rendering, which will keep calling pixelFunc to render
     the camera view. */

  RCL_renderSimple(camera,floorHeightAt,0,0,constraints);
}

int main()
{
  pokitto.begin(); 
  pokitto.setFrameRate(60);

  RCL_initCamera(&camera); /* To initialize all parameters so that none
                              remains undefined. */

  // Set the camera position to square [4;6].
  camera.position.x = 4 * RCL_UNITS_PER_SQUARE;
  camera.position.y = 6 * RCL_UNITS_PER_SQUARE;

  camera.height = RCL_UNITS_PER_SQUARE;

  // Set the camera resolution to Pokitto display resolution.
  camera.resolution.x = 110;
  camera.resolution.y = 88;

  // This specifies the ray behavior.
  RCL_initRayConstraints(&constraints);
  constraints.maxHits = 1;   // Stop at first intersection with a wall.
  constraints.maxSteps = 20; // Trace maximum of 20 squares.

  while (pokitto.isRunning())
  {
    if (pokitto.update())
    {
      draw();
      camera.direction -= 10; // Rotate the camera for some animation.
    }
  }

  return 0;
}