gv_math.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <assert.h>
#include <float.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
 
static inline int fcmp(double a, double b) {
  if (a < b) {
    return -1;
  }
  if (a > b) {
    return 1;
  }
  return 0;
}
 
static inline int imax(int a, int b) { return a > b ? a : b; }
 
static inline size_t zmax(size_t a, size_t b) { return a > b ? a : b; }
 
static inline size_t zmin(size_t a, size_t b) { return a < b ? a : b; }
 
static inline int imin(int a, int b) { return a < b ? a : b; }
 
static inline bool is_exactly_equal(double a, double b) {
  return memcmp(&a, &b, sizeof(a)) == 0;
}
 
static inline bool is_exactly_zero(double v) { return is_exactly_equal(v, 0); }
 
static inline int scale_clamp(int original, double scale) {
  assert(original >= 0);
 
  if (scale < 0) {
    return 0;
  }
 
  if (scale > 1 && original > INT_MAX / scale) {
    return INT_MAX;
  }
 
  return (int)(original * scale);
}
 
enum { BYTES_PER_PIXEL = 4 };
 
static inline void argb2rgba(size_t width, size_t height, unsigned char *data) {
  assert(data != NULL || (width == 0 && height == 0));
 
  // indices to color bytes in each format
  enum { Ba = 0, Ga = 1, Ra = 2, Aa = 3 };
  enum { Rb = 0, Gb = 1, Bb = 2, Ab = 3 };
 
  for (size_t y = 0; y < height; ++y) {
    for (size_t x = 0; x < width; ++x) {
      const unsigned char red = data[Ra];
      const unsigned char blue = data[Ba];
      data[Rb] = red;
      data[Bb] = blue;
      data += BYTES_PER_PIXEL;
    }
  }
}
 
#define SWAP(a, b)                                                             \
  do {                                                                         \
    /* trigger a -Wcompare-distinct-pointer-types compiler warning if `a` */   \
    /* and `b` have differing types                                       */   \
    (void)((a) == (b));                                                        \
                                                                               \
    /* Swap their targets. Contemporary compilers will optimize the `memcpy`s  \
     * into direct writes for primitive types.                                 \
     */                                                                        \
    char tmp_[sizeof(*(a))];                                                   \
    memcpy(tmp_, (a), sizeof(*(a)));                                           \
    *(a) = *(b);                                                               \
    memcpy((b), tmp_, sizeof(*(b)));                                           \
  } while (0)
 
static inline int d2i(double v) {
  if (v > INT_MAX) {
    return INT_MAX;
  }
  if (v < INT_MIN) {
    return INT_MIN;
  }
  return (int)v;
}
 
static inline float d2f(double v) {
  if (v > FLT_MAX) {
    return FLT_MAX;
  }
  if (v < -FLT_MAX) {
    return -FLT_MAX;
  }
  return (float)v;
}