summaryrefslogtreecommitdiffstats
path: root/libdimension
diff options
context:
space:
mode:
Diffstat (limited to 'libdimension')
-rw-r--r--libdimension/Makefile.am2
-rw-r--r--libdimension/canvas.c166
-rw-r--r--libdimension/color.c259
-rw-r--r--libdimension/dimension.h4
-rw-r--r--libdimension/dimension/canvas.h11
-rw-r--r--libdimension/dimension/color.h51
-rw-r--r--libdimension/dimension/geometry.h16
-rw-r--r--libdimension/inlines.c22
8 files changed, 343 insertions, 188 deletions
diff --git a/libdimension/Makefile.am b/libdimension/Makefile.am
index 293093c..9338b38 100644
--- a/libdimension/Makefile.am
+++ b/libdimension/Makefile.am
@@ -21,5 +21,5 @@ nobase_include_HEADERS = dimension.h dimension/geometry.h dimension/color.h dime
lib_LTLIBRARIES = libdimension.la
-libdimension_la_SOURCES = dimension.h dimension/geometry.h dimension/color.h dimension/canvas.h canvas.c
+libdimension_la_SOURCES = dimension.h dimension/geometry.h dimension/color.h dimension/canvas.h canvas.c color.c inlines.c
libdimension_la_LDFLAGS = -version-info 0:0:0
diff --git a/libdimension/canvas.c b/libdimension/canvas.c
index 4e3f89f..21d6d86 100644
--- a/libdimension/canvas.c
+++ b/libdimension/canvas.c
@@ -19,169 +19,7 @@
*************************************************************************/
#include "dimension.h"
-#include <math.h>
-#include <stdlib.h>
-
-/* Conversions between CIE 1931 XYZ and sRGB color. */
-
-dmnsn_pixel
-dmnsn_pixel_from_color(dmnsn_color color)
-{
- double X, Y, Z; /* CIE XYZ values */
- double Rlinear, Glinear, Blinear; /* Linear RGB values - no gamma */
- double R, G, B; /* sRGB values */
- dmnsn_pixel pixel;
-
- /* Convert from CIE xyY to CIE XYZ */
- Y = color.Y;
- X = Y*color.x/color.y;
- Z = Y*(1.0 - color.x - color.y)/color.y;
-
- /*
- * First, the linear conversion. Expressed as matrix multiplication, it looks
- * like this:
- *
- * [Rlinear] [ 3.2410 -1.5374 -0.4986] [X]
- * [Glinear] = [-0.9692 1.8760 0.0416]*[Y]
- * [Blinear] [ 0.0556 -0.2040 1.0570] [Z]
- */
- Rlinear = 3.2410*X - 1.5374*Y - 0.4986*Z;
- Glinear = -0.9692*X + 1.8760*Y + 0.0416*Z;
- Blinear = 0.0556*X - 0.2040*Y + 1.0570*Z;
-
- /*
- * If C represents R, G, and B, then the sRGB values are now found as follows:
- *
- * { 12.92*Clinear, Clinear <= 0.0031308
- * Csrgb = { 1/2.4
- * { (1.055)*Clinear - 0.055, Clinear > 0.0031308
- */
-
- if (Rlinear <= 0.0031308) {
- R = 12.92*Rlinear;
- } else {
- R = 1.055*pow(Rlinear, 1.0/2.4) - 0.055;
- }
-
- if (Glinear <= 0.0031308) {
- G = 12.92*Glinear;
- } else {
- G = 1.055*pow(Glinear, 1.0/2.4) - 0.055;
- }
-
- if (Blinear <= 0.0031308) {
- B = 12.92*Blinear;
- } else {
- B = 1.055*pow(Blinear, 1.0/2.4) - 0.055;
- }
-
- /* Now we go from unlimited to limited light, saturating at UINT16_MAX */
-
- if (R < 0.0) {
- pixel.r = 0.0;
- } else if (R > 1.0) {
- pixel.r = UINT16_MAX;
- } else {
- pixel.r = UINT16_MAX*R;
- }
-
- if (G < 0.0) {
- pixel.g = 0.0;
- } else if (G > 1.0) {
- pixel.g = UINT16_MAX;
- } else {
- pixel.g = UINT16_MAX*G;
- }
-
- if (B < 0.0) {
- pixel.b = 0.0;
- } else if (B > 1.0) {
- pixel.b = UINT16_MAX;
- } else {
- pixel.b = UINT16_MAX*B;
- }
-
- if (color.filter < 0.0) {
- pixel.a = 0.0;
- } else if (color.filter > 1.0) {
- pixel.a = UINT16_MAX;
- } else {
- pixel.a = UINT16_MAX*color.filter;
- }
-
- if (color.trans < 0.0) {
- pixel.t = 0.0;
- } else if (color.trans > 1.0) {
- pixel.t = UINT16_MAX;
- } else {
- pixel.t = UINT16_MAX*color.trans;
- }
-
- return pixel;
-}
-
-dmnsn_color
-dmnsn_color_from_pixel(dmnsn_pixel pixel)
-{
- double R, G, B; /* sRGB values */
- double Rlinear, Glinear, Blinear; /* Linear RGB values - no gamma */
- double X, Y, Z; /* CIE XYZ values */
- dmnsn_color color;
-
- /* Conversion back to unlimited light */
- R = ((double)pixel.r)/UINT16_MAX;
- G = ((double)pixel.g)/UINT16_MAX;
- B = ((double)pixel.b)/UINT16_MAX;
-
- /*
- * If C represents R, G, and B, then the Clinear values are now found as
- * follows:
- *
- * { Csrgb/12.92, Csrgb <= 0.04045
- * Clinear = { 1/2.4
- * { ((Csrgb + 0.055)/1.055) , Csrgb > 0.04045
- */
-
- if (R <= 0.04045) {
- Rlinear = R/19.92;
- } else {
- Rlinear = pow((R + 0.055)/1.055, 2.4);
- }
-
- if (G <= 0.04045) {
- Glinear = G/19.92;
- } else {
- Glinear = pow((G + 0.055)/1.055, 2.4);
- }
-
- if (B <= 0.04045) {
- Blinear = B/19.92;
- } else {
- Blinear = pow((B + 0.055)/1.055, 2.4);
- }
-
- /*
- * Now, the linear conversion. Expressed as matrix multiplication, it looks
- * like this:
- *
- * [X] [0.4124 0.3576 0.1805] [Rlinear]
- * [Y] = [0.2126 0.7152 0.0722]*[Glinear]
- * [X] [0.0193 0.1192 0.9505] [Blinear]
- */
-
- X = 0.4124*Rlinear + 0.3576*Glinear + 0.1805*Blinear;
- Y = 0.2126*Rlinear + 0.7152*Glinear + 0.0722*Blinear;
- Z = 0.0193*Rlinear + 0.1192*Glinear + 0.9505*Blinear;
-
- /* Now convert to CIE xyY colorspace */
- color.x = X/(X + Y + Z);
- color.y = Y/(X + Y + Z);
- color.Y = Y;
- color.filter = ((double)pixel.a)/UINT16_MAX;
- color.trans = ((double)pixel.t)/UINT16_MAX;
-
- return color;
-}
+#include <stdlib.h> /* For malloc(), free() */
dmnsn_canvas *
dmnsn_new_canvas(unsigned int x, unsigned int y)
@@ -191,7 +29,7 @@ dmnsn_new_canvas(unsigned int x, unsigned int y)
if (canvas) {
canvas->x = x;
canvas->y = y;
- canvas->pixels = malloc(sizeof(dmnsn_pixel)*x*y);
+ canvas->pixels = malloc(sizeof(dmnsn_color)*x*y);
if (canvas->pixels) {
return canvas;
diff --git a/libdimension/color.c b/libdimension/color.c
new file mode 100644
index 0000000..bbde48d
--- /dev/null
+++ b/libdimension/color.c
@@ -0,0 +1,259 @@
+/*************************************************************************
+ * Copyright (C) 2008 Tavian Barnes <tavianator@gmail.com> *
+ * *
+ * This file is part of Dimension. *
+ * *
+ * Dimension is free software; you can redistribute it and/or modify it *
+ * under the terms of the GNU Lesser General Public License as published *
+ * by the Free Software Foundation; either version 3 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * Dimension is distributed in the hope that it will be useful, but *
+ * WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
+ * Lesser General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU Lesser General Public *
+ * License along with this program. If not, see *
+ * <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+#include "dimension.h"
+#include <math.h> /* For pow() */
+
+dmnsn_CIE_XYZ whitepoint = { 0.9505, 1, 1.089 };
+
+dmnsn_color
+dmnsn_color_from_XYZ(dmnsn_CIE_XYZ XYZ)
+{
+ dmnsn_color ret = { XYZ.X, XYZ.Y, XYZ.Z, 0.0, 0.0 };
+ return ret;
+}
+
+dmnsn_color
+dmnsn_color_from_xyY(dmnsn_CIE_xyY xyY)
+{
+ dmnsn_color ret = { xyY.Y*xyY.x/xyY.y,
+ xyY.Y,
+ xyY.Y*(1.0 - xyY.x - xyY.Y)/xyY.y,
+ 0.0, 0.0 };
+ return ret;
+}
+
+static double Lab_finv(double t) {
+ if (t > 6.0/29.0) {
+ return t*t*t;
+ } else {
+ return 108.0*(t - 16.0/116.0)/841.0;
+ }
+}
+
+dmnsn_color
+dmnsn_color_from_Lab(dmnsn_CIE_Lab Lab, dmnsn_CIE_XYZ white)
+{
+ double fx, fy, fz;
+ dmnsn_color ret;
+
+ fy = (Lab.L + 16.0)/116.0;
+ fx = fy + Lab.a/500.0;
+ fz = fy - Lab.b/200.0;
+
+ ret.X = white.X*Lab_finv(fx);
+ ret.Y = white.Y*Lab_finv(fy);
+ ret.Z = white.Z*Lab_finv(fz);
+
+ return ret;
+}
+
+dmnsn_color
+dmnsn_color_from_Luv(dmnsn_CIE_Luv Luv, dmnsn_CIE_XYZ white)
+{
+ double fy;
+ double uprime, unprime, vprime, vnprime;
+ dmnsn_color ret;
+
+ fy = (Luv.L + 16.0)/116.0;
+
+ unprime = 4.0*white.X/(white.X + 15.0*white.Y + 3.0*white.Z);
+ uprime = Luv.u/Luv.L/13.0 + unprime;
+ vnprime = 9.0*white.Y/(white.X + 15.0*white.Y + 3.0*white.Z);
+ vprime = Luv.v/Luv.L/13.0 + vnprime;
+
+ ret.Y = white.Y*Lab_finv(fy);
+ ret.X = ret.Y*9.0*uprime/vprime/4.0;
+ ret.Z = ret.Y*(12.0 - 3*uprime - 20*vprime)/vprime/4.0;
+
+ return ret;
+}
+
+dmnsn_color
+dmnsn_color_from_sRGB(dmnsn_sRGB sRGB)
+{
+ double Rlinear, Glinear, Blinear; /* Linear RGB values - no gamma */
+ dmnsn_color ret;
+
+ /*
+ * If C represents R, G, and B, then the Clinear values are now found as
+ * follows:
+ *
+ * { Csrgb/12.92, Csrgb <= 0.04045
+ * Clinear = { 1/2.4
+ * { ((Csrgb + 0.055)/1.055) , Csrgb > 0.04045
+ */
+
+ if (sRGB.R <= 0.04045) {
+ Rlinear = sRGB.R/19.92;
+ } else {
+ Rlinear = pow((sRGB.R + 0.055)/1.055, 2.4);
+ }
+
+ if (sRGB.G <= 0.04045) {
+ Glinear = sRGB.G/19.92;
+ } else {
+ Glinear = pow((sRGB.G + 0.055)/1.055, 2.4);
+ }
+
+ if (sRGB.B <= 0.04045) {
+ Blinear = sRGB.B/19.92;
+ } else {
+ Blinear = pow((sRGB.B + 0.055)/1.055, 2.4);
+ }
+
+ /*
+ * Now, the linear conversion. Expressed as matrix multiplication, it looks
+ * like this:
+ *
+ * [X] [0.4124 0.3576 0.1805] [Rlinear]
+ * [Y] = [0.2126 0.7152 0.0722]*[Glinear]
+ * [X] [0.0193 0.1192 0.9505] [Blinear]
+ */
+
+ ret.X = 0.4124*Rlinear + 0.3576*Glinear + 0.1805*Blinear;
+ ret.Y = 0.2126*Rlinear + 0.7152*Glinear + 0.0722*Blinear;
+ ret.Z = 0.0193*Rlinear + 0.1192*Glinear + 0.9505*Blinear;
+ ret.filter = 0.0;
+ ret.trans = 0.0;
+
+ return ret;
+}
+
+dmnsn_CIE_XYZ
+dmnsn_XYZ_from_color(dmnsn_color color)
+{
+ dmnsn_CIE_XYZ ret = { color.X, color.Y, color.Z };
+ return ret;
+}
+
+dmnsn_CIE_xyY
+dmnsn_xyY_from_color(dmnsn_color color)
+{
+ dmnsn_CIE_xyY ret = { color.X/(color.X + color.Y + color.Z),
+ color.Y/(color.X + color.Y + color.Z),
+ color.Y };
+ return ret;
+}
+
+static double Lab_f(double t) {
+ if (t > 216.0/24389.0) {
+ return pow(t, 1.0/3.0);
+ } else {
+ return 841.0*t/108.0 + 4.0/29.0;
+ }
+}
+
+dmnsn_CIE_Lab
+dmnsn_Lab_from_color(dmnsn_color color, dmnsn_CIE_XYZ white)
+{
+ dmnsn_CIE_Lab ret;
+
+ ret.L = 116.0*Lab_f(color.Y/white.Y) - 16.0;
+ ret.a = 500.0*(Lab_f(color.X/white.X) - Lab_f(color.Y/white.Y));
+ ret.b = 200.0*(Lab_f(color.Y/white.Y) - Lab_f(color.Z/white.Z));
+
+ return ret;
+}
+
+dmnsn_CIE_Luv
+dmnsn_Luv_from_color(dmnsn_color color, dmnsn_CIE_XYZ white)
+{
+ double uprime, unprime, vprime, vnprime;
+ dmnsn_CIE_Luv ret;
+
+ uprime = 4.0*color.X/(color.X + 15.0*color.Y + 3.0*color.Z);
+ unprime = 4.0*white.X/(white.X + 15.0*white.Y + 3.0*white.Z);
+ vprime = 9.0*color.Y/(color.X + 15.0*color.Y + 3.0*color.Z);
+ vnprime = 9.0*white.Y/(white.X + 15.0*white.Y + 3.0*white.Z);
+
+ ret.L = 116.0*Lab_f(color.Y/white.Y) - 16.0;
+ ret.u = 13.0*ret.L*(uprime - unprime);
+ ret.v = 13.0*ret.L*(vprime - vnprime);
+
+ return ret;
+}
+
+dmnsn_sRGB
+dmnsn_sRGB_from_color(dmnsn_color color)
+{
+ double Rlinear, Glinear, Blinear; /* Linear RGB values - no gamma */
+ dmnsn_sRGB ret;
+
+ /*
+ * First, the linear conversion. Expressed as matrix multiplication, it looks
+ * like this:
+ *
+ * [Rlinear] [ 3.2410 -1.5374 -0.4986] [X]
+ * [Glinear] = [-0.9692 1.8760 0.0416]*[Y]
+ * [Blinear] [ 0.0556 -0.2040 1.0570] [Z]
+ */
+ Rlinear = 3.2410*color.X - 1.5374*color.Y - 0.4986*color.Z;
+ Glinear = -0.9692*color.X + 1.8760*color.Y + 0.0416*color.Z;
+ Blinear = 0.0556*color.X - 0.2040*color.Y + 1.0570*color.Z;
+
+ /*
+ * If C represents R, G, and B, then the sRGB values are now found as follows:
+ *
+ * { 12.92*Clinear, Clinear <= 0.0031308
+ * Csrgb = { 1/2.4
+ * { (1.055)*Clinear - 0.055, Clinear > 0.0031308
+ */
+
+ if (Rlinear <= 0.0031308) {
+ ret.R = 12.92*Rlinear;
+ } else {
+ ret.R = 1.055*pow(Rlinear, 1.0/2.4) - 0.055;
+ }
+
+ if (Glinear <= 0.0031308) {
+ ret.G = 12.92*Glinear;
+ } else {
+ ret.G = 1.055*pow(Glinear, 1.0/2.4) - 0.055;
+ }
+
+ if (Blinear <= 0.0031308) {
+ ret.B = 12.92*Blinear;
+ } else {
+ ret.B = 1.055*pow(Blinear, 1.0/2.4) - 0.055;
+ }
+
+ return ret;
+}
+
+dmnsn_color
+dmnsn_color_add(dmnsn_color color1, dmnsn_color color2)
+{
+ dmnsn_CIE_Lab Lab, Lab1, Lab2;
+ dmnsn_color ret;
+
+ Lab1 = dmnsn_Lab_from_color(color1, whitepoint);
+ Lab2 = dmnsn_Lab_from_color(color2, whitepoint);
+
+ Lab.L = Lab1.L + Lab2.L;
+ Lab.a = (Lab1.L*Lab1.a + Lab2.L*Lab2.a)/Lab.L;
+ Lab.b = (Lab1.L*Lab1.b + Lab2.L*Lab2.b)/Lab.L;
+
+ ret = dmnsn_color_from_Lab(Lab, whitepoint);
+ ret.filter = (Lab1.L*color1.filter + Lab2.L*color2.filter)/Lab.L;
+ ret.trans = (Lab1.L*color1.trans + Lab2.L*color2.trans)/Lab.L;
+
+ return ret;
+}
diff --git a/libdimension/dimension.h b/libdimension/dimension.h
index 558c9ed..c52ae31 100644
--- a/libdimension/dimension.h
+++ b/libdimension/dimension.h
@@ -28,6 +28,10 @@
extern "C" {
#endif
+#ifndef DMNSN_INLINE
+#define DMNSN_INLINE extern inline
+#endif
+
#include <dimension/geometry.h>
#include <dimension/color.h>
#include <dimension/canvas.h>
diff --git a/libdimension/dimension/canvas.h b/libdimension/dimension/canvas.h
index 8959e12..21d56e4 100644
--- a/libdimension/dimension/canvas.h
+++ b/libdimension/dimension/canvas.h
@@ -25,15 +25,6 @@
#ifndef DIMENSION_CANVAS_H
#define DIMENSION_CANVAS_H
-/* 48-bit sRGB color for pixels. */
-typedef struct {
- uint16_t r, g, b; /* Red, green, blue */
- uint16_t a, t; /* Filtered transparancy, normal transparancy */
-} dmnsn_pixel;
-
-dmnsn_pixel dmnsn_pixel_from_color(dmnsn_color color);
-dmnsn_color dmnsn_color_from_pixel(dmnsn_pixel pixel);
-
typedef struct {
unsigned int x, y;
@@ -41,7 +32,7 @@ typedef struct {
* Stored in first-quadrant representation (origin is bottom-left). The pixel
* at (a,b) is accessible as pixels[b*x + a].
*/
- dmnsn_pixel *pixels;
+ dmnsn_color *pixels;
} dmnsn_canvas;
dmnsn_canvas *dmnsn_new_canvas(unsigned int x, unsigned int y);
diff --git a/libdimension/dimension/color.h b/libdimension/dimension/color.h
index 34668e3..d637a81 100644
--- a/libdimension/dimension/color.h
+++ b/libdimension/dimension/color.h
@@ -29,16 +29,57 @@
extern "C" {
#endif
-/* CIE 1931 xyY color. */
+/* Internally, we use CIE 1931 XYZ color. */
+typedef struct {
+ double X, Y, Z;
+ double filter, trans; /* Filter transparancy only lets light of this color
+ through; regular transparancy lets all colors
+ through. filter + trans should be <= 1.0. */
+} dmnsn_color;
+
+typedef struct {
+ double X, Y, Z; /* X, Y, and Z are tristimulus values, unbounded above zero.
+ Diffuse white is (0.9505, 1, 1.089). */
+} dmnsn_CIE_XYZ;
+
typedef struct {
double x, y, Y; /* x and y are chromaticity coordinates, and Y is luminance,
in the CIE 1931 xyZ color space. We use an unlimited light
model, so x,y in [0, 1] and Y >= 0, with 1 = diffuse
white */
- double filter, trans; /* Filter transparancy only lets light of this color
- through; regular transparancy lets all colors
- through */
-} dmnsn_color;
+} dmnsn_CIE_xyY;
+
+typedef struct {
+ double L, a, b; /* L is luminence (100 = diffuse white); a and b are color-
+ opponent dimensions. This color space is used for color
+ arithmetic. */
+} dmnsn_CIE_Lab;
+
+typedef struct {
+ double L, u, v; /* L is luminence (100 = diffuse white); u and v are
+ chromaticity coordinates. */
+} dmnsn_CIE_Luv;
+
+typedef struct {
+ double R, G, B; /* sRGB R, G, and B values */
+} dmnsn_sRGB;
+
+/* Standard whitepoint, determined by the conversion of sRGB white to XYZ */
+extern dmnsn_CIE_XYZ whitepoint;
+
+dmnsn_color dmnsn_color_from_XYZ(dmnsn_CIE_XYZ XYZ);
+dmnsn_color dmnsn_color_from_xyY(dmnsn_CIE_xyY xyY);
+dmnsn_color dmnsn_color_from_Lab(dmnsn_CIE_Lab Lab, dmnsn_CIE_XYZ white);
+dmnsn_color dmnsn_color_from_Luv(dmnsn_CIE_Luv Luv, dmnsn_CIE_XYZ white);
+dmnsn_color dmnsn_color_from_sRGB(dmnsn_sRGB sRGB);
+
+dmnsn_CIE_XYZ dmnsn_XYZ_from_color(dmnsn_color color);
+dmnsn_CIE_xyY dmnsn_xyY_from_color(dmnsn_color color);
+dmnsn_CIE_Lab dmnsn_Lab_from_color(dmnsn_color color, dmnsn_CIE_XYZ white);
+dmnsn_CIE_Luv dmnsn_Luv_from_color(dmnsn_color color, dmnsn_CIE_XYZ white);
+dmnsn_sRGB dmnsn_sRGB_from_color(dmnsn_color color);
+
+dmnsn_color dmnsn_color_add(dmnsn_color color1, dmnsn_color color2);
#ifdef __cplusplus
}
diff --git a/libdimension/dimension/geometry.h b/libdimension/dimension/geometry.h
index 2c0c204..11a6daf 100644
--- a/libdimension/dimension/geometry.h
+++ b/libdimension/dimension/geometry.h
@@ -31,44 +31,44 @@ typedef struct { dmnsn_scalar x, y, z; } dmnsn_vector;
/* Vector arithmetic */
-inline dmnsn_vector
+DMNSN_INLINE dmnsn_vector
dmnsn_vector_construct(dmnsn_scalar x, dmnsn_scalar y, dmnsn_scalar z)
{
dmnsn_vector v = { .x = x, .y = y, .z = z };
return v;
}
-inline dmnsn_vector
+DMNSN_INLINE dmnsn_vector
dmnsn_vector_add(dmnsn_vector lhs, dmnsn_vector rhs)
{
return dmnsn_vector_construct(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z);
}
-inline dmnsn_vector
+DMNSN_INLINE dmnsn_vector
dmnsn_vector_sub(dmnsn_vector lhs, dmnsn_vector rhs)
{
return dmnsn_vector_construct(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);
}
-inline dmnsn_vector
+DMNSN_INLINE dmnsn_vector
dmnsn_vector_mul(dmnsn_scalar lhs, dmnsn_vector rhs)
{
return dmnsn_vector_construct(lhs*rhs.x, lhs*rhs.y, lhs*rhs.z);
}
-inline dmnsn_vector
+DMNSN_INLINE dmnsn_vector
dmnsn_vector_div(dmnsn_vector lhs, dmnsn_scalar rhs)
{
return dmnsn_vector_construct(lhs.x/rhs, lhs.y/rhs, lhs.z/rhs);
}
-inline dmnsn_scalar
+DMNSN_INLINE dmnsn_scalar
dmnsn_vector_dot(dmnsn_vector lhs, dmnsn_vector rhs)
{
return lhs.x*rhs.x + lhs.y*rhs.y + lhs.z*rhs.z;
}
-inline dmnsn_vector
+DMNSN_INLINE dmnsn_vector
dmnsn_vector_cross(dmnsn_vector lhs, dmnsn_vector rhs)
{
return dmnsn_vector_construct(lhs.y*rhs.z - lhs.z*rhs.y,
@@ -83,7 +83,7 @@ typedef struct {
} dmnsn_line;
/* A point on a line, defined by x0 + t*n */
-inline dmnsn_vector
+DMNSN_INLINE dmnsn_vector
dmnsn_line_point(dmnsn_line l, dmnsn_scalar t)
{
return dmnsn_vector_add(l.x0, dmnsn_vector_mul(t, l.n));
diff --git a/libdimension/inlines.c b/libdimension/inlines.c
new file mode 100644
index 0000000..51348fa
--- /dev/null
+++ b/libdimension/inlines.c
@@ -0,0 +1,22 @@
+/*************************************************************************
+ * Copyright (C) 2008 Tavian Barnes <tavianator@gmail.com> *
+ * *
+ * This file is part of Dimension. *
+ * *
+ * Dimension is free software; you can redistribute it and/or modify it *
+ * under the terms of the GNU Lesser General Public License as published *
+ * by the Free Software Foundation; either version 3 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * Dimension is distributed in the hope that it will be useful, but *
+ * WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
+ * Lesser General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU Lesser General Public *
+ * License along with this program. If not, see *
+ * <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+#define DMNSN_INLINE
+#include "dimension.h"
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-10 13:32:06 +0000