Example #1
0
// NormFloat64 returns a normally distributed float64 in the range
// [-math.MaxFloat64, +math.MaxFloat64] with
// standard normal distribution (mean = 0, stddev = 1).
// To produce a different normal distribution, callers can
// adjust the output using:
//
//  sample = NormFloat64() * desiredStdDev + desiredMean
//
real_t rstdnorm_zig(void) {
        for (;;) {
                int32_t j = gen_rand32(); // Possibly negative
                int32_t i = j & 0x7F;
                real_t x = (real_t)(j) * (real_t)(wn[i]);
                if (absInt32(j) < kn[i]) {
                        // This case should be hit better than 99% of the time.
                        return x;
                }

                if (i == 0) {
                        // This extra work is only required for the base strip.
                        for (;;) {
                                x = -log(runif()) * (1.0 / rn);
                                real_t y = -log(runif());
                                if (y+y >= x*x) {
                                        break;
                                }
                        }
                        if (j > 0) {
                                return rn + x;
                        }
                        return -rn - x;
                }
                if (fn[i]+runif()*(fn[i-1]-fn[i]) < exp(-.5*x*x)) {
                        return x;
                }
        }
        errx(EXIT_FAILURE,"Unreachable: %s (%s:%d)",__func__,__FILE__,__LINE__);
}
Example #2
0
File: main.c Project: olls/hex-game
void
render_hex(v2 hex_pos, uint32_t * pixels, HexShape hexes, v2 window_dimensions_in_pixels, uint32_t color)
{
  // TODO: Sub-pixel rendering, instead of flooring
  v2 startPos = subV2(hex_pos, floorVf2(hexes.dimensions_in_pixels));
  v2 endPos = addV2(hex_pos, floorVf2(hexes.dimensions_in_pixels));

  if (startPos.x < 0)
  {
    startPos.x = 0;
  }
  else if (startPos.x > window_dimensions_in_pixels.x)
  {
    startPos.x = window_dimensions_in_pixels.x;
  }

  if (startPos.y < 0)
  {
    startPos.y = 0;
  }
  else if (startPos.y > window_dimensions_in_pixels.y)
  {
    startPos.y = window_dimensions_in_pixels.y;
  }

  v2 pos;
  for (pos.y = startPos.y;
       pos.y < endPos.y;
       pos.y++)
  {
    for (pos.x = startPos.x;
         pos.x < endPos.x;
         pos.x++)
    {
      v2 rel_to_hex_pos = subV2(pos, hex_pos);
      if (absInt32(rel_to_hex_pos.x) < hexes.radius_in_pixels * (hexes.dimensions_in_pixels.y - absInt32(rel_to_hex_pos.y) * .5f) / hexes.dimensions_in_pixels.y)
      {
        pixels[v2ToV1(pos, window_dimensions_in_pixels.x)] = color;
      }
    }
  }
}
Example #3
0
File: main.c Project: olls/hex-game
int
main(int32_t argc, char * argv)
{
  srand(time(NULL));

  void * game_memory = malloc(MEM);
  void * game_memory_pos = game_memory;
  assert(game_memory != NULL);


  HexShape hexes;
  hexes.radius_in_pixels = 20;

  // NOTE: This is 'radius' dimensions
  hexes.dimensions_in_pixels = mulVf2ByScalar((vf2){1, sqrt(3) * .5f}, hexes.radius_in_pixels);

  v2 window_dimensions_in_pixels = floorVf2(mulV2ByVf2((v2){24, 18}, hexes.dimensions_in_pixels));
  vHex camera_position_in_hexes = {2,3};

  SDL_Init(SDL_INIT_VIDEO);

  SDL_Window * window = SDL_CreateWindow("A Hex Game",
    SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, window_dimensions_in_pixels.x, window_dimensions_in_pixels.y, 0);

  SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, 0);
  SDL_Texture * texture = SDL_CreateTexture(renderer,
    SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, window_dimensions_in_pixels.x, window_dimensions_in_pixels.y);

  // The pixel buffer
  uint32_t * pixels = (uint32_t *)game_memory_pos;
  game_memory_pos += window_dimensions_in_pixels.x * window_dimensions_in_pixels.y * sizeof(uint32_t);
  assert(game_memory_pos < game_memory + MEM);

  printf("Starting\n");

  // For average FPS measurement
  uint64_t last_measure = get_us();
  uint32_t frame_count = 0;

  // For FPS timing
  uint64_t last_frame = get_us();
  uint32_t delta_frame;

  bool32 quit = false;
  SDL_Event event;

  while (!quit)
  {
    uint64_t now = get_us();

    // Measure FPS
    if (now >= (last_measure + 1000000))
    {
      // If last measurement was more than 1 sec ago
      last_measure = now;
      printf("%f us/frame\n", 1000000.0f / (double)frame_count);
      frame_count = 0;
    }

    // Render
    if (now >= last_frame + (1000000/FPS))
    {
      delta_frame = now - last_frame;
      last_frame = now;
      frame_count++;

      // Clear screen to white

      v2 pixelPointer;
      for (pixelPointer.y = 0;
           pixelPointer.y < window_dimensions_in_pixels.y;
           pixelPointer.y++)
      {
        for (pixelPointer.x = 0;
             pixelPointer.x < window_dimensions_in_pixels.x;
             pixelPointer.x++)
        {
          pixels[v2ToV1(pixelPointer, window_dimensions_in_pixels.x)] = 0x00FFFFFF;
        }
      }

      // Draw Hexagons
      int32_t radius = 2;
      vHex hex_pos;
      for (hex_pos.q = 1-radius;
           hex_pos.q < radius;
           hex_pos.q += 1)
      {
        for (hex_pos.r = 1-radius;
             hex_pos.r < radius;
             hex_pos.r += 1)
        {
          if (absInt32(hex_pos.q + hex_pos.r) < radius)
          {
            uint32_t color;
            if (hex_pos.q == 0 && hex_pos.r == 0)
            {
              color = 0x00FF0000;
            }
            else
            {
              color = 0;
            }

            v2 hex_pixel_pos = floorVf2(mulVf2ByVf2(
              hexes.dimensions_in_pixels,
              hexToCart(addHexes(hex_pos, camera_position_in_hexes), hexes.radius_in_pixels)
            ));
            render_hex(hex_pixel_pos, pixels, hexes, window_dimensions_in_pixels, color);
          }
        }
      }

      // Flip pixels
      v2 pos;
      for (pos.y = 0;
           pos.y < window_dimensions_in_pixels.y / 2;
           pos.y++)
      {
        for (pos.x = 0;
             pos.x < window_dimensions_in_pixels.x;
             pos.x++)
        {
          uint32_t top_pixel = pixels[pos.y * window_dimensions_in_pixels.x + pos.x];
          pixels[v2ToV1(pos, window_dimensions_in_pixels.x)] = pixels[(window_dimensions_in_pixels.y - pos.y - 1) * window_dimensions_in_pixels.x + pos.x];
          pixels[(window_dimensions_in_pixels.y - pos.y - 1) * window_dimensions_in_pixels.x + pos.x] = top_pixel;
        }
      }

      SDL_UpdateTexture(texture, NULL, pixels, window_dimensions_in_pixels.x * sizeof(uint32_t));

      SDL_RenderClear(renderer);
      SDL_RenderCopy(renderer, texture, NULL, NULL);
      SDL_RenderPresent(renderer);

    }

    // Get inputs
    SDL_PollEvent(&event);

    if (event.type == SDL_QUIT)
    {
      quit = true;
    }
    else if (event.type == SDL_KEYDOWN)
    {
      if (event.key.keysym.sym == 'w' && event.key.keysym.mod == KMOD_LCTRL)
      {
        quit = true;
      }
    }
  }

  error("Quitting");

  SDL_DestroyTexture(texture);
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  SDL_Quit();

  free(game_memory);

  printf("Finished\n");

  return 0;
}