/*
* Mesa 3-D graphics library
- * Version: 4.0.3
+ * Version: 6.5
*
- * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
/** Convert GLushort in [0,65536] to GLfloat in [0.0,1.0] */
#define USHORT_TO_FLOAT(S) ((GLfloat) (S) * (1.0F / 65535.0F))
-/** Convert GLfloat in [0.0,1.0] to GLushort in [0,65536] */
-#define FLOAT_TO_USHORT(X) ((GLushort) (GLint) ((X) * 65535.0F))
-
/** Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0] */
#define SHORT_TO_FLOAT(S) ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
#define CLAMPED_FLOAT_TO_USHORT(us, f) \
us = ( (GLushort) IROUND( (f) * 65535.0F) )
+/*@}*/
+
/** Stepping a GLfloat pointer by a byte stride */
#define STRIDE_F(p, i) (p = (GLfloat *)((GLubyte *)p + i))
#define STRIDE_UI(p, i) (p = (GLuint *)((GLubyte *)p + i))
/** Stepping a GLubyte[4] pointer by a byte stride */
#define STRIDE_4UB(p, i) (p = (GLubyte (*)[4])((GLubyte *)p + i))
+/** Stepping a GLfloat[4] pointer by a byte stride */
+#define STRIDE_4F(p, i) (p = (GLfloat (*)[4])((GLubyte *)p + i))
/** Stepping a GLchan[4] pointer by a byte stride */
#define STRIDE_4CHAN(p, i) (p = (GLchan (*)[4])((GLubyte *)p + i))
/** Stepping a GLchan pointer by a byte stride */
/** Copy a 4-element unsigned byte vector */
#if defined(__i386__)
-#define COPY_4UBV(DST, SRC) \
-do { \
+#define COPY_4UBV(DST, SRC) \
+do { \
*((GLuint*)(DST)) = *((GLuint*)(SRC)); \
} while (0)
#else
} while (0)
#endif
-/** Copy a 4-element float vector (Use COPY_FLOAT to avoid loading FPU) */
-#define COPY_4FV( DST, SRC ) \
-do { \
- COPY_FLOAT((DST)[0], (SRC)[0]); \
- COPY_FLOAT((DST)[1], (SRC)[1]); \
- COPY_FLOAT((DST)[2], (SRC)[2]); \
- COPY_FLOAT((DST)[3], (SRC)[3]); \
+/**
+ * Copy a 4-element float vector (avoid using FPU registers)
+ * XXX Could use two 64-bit moves on 64-bit systems
+ */
+#define COPY_4FV( DST, SRC ) \
+do { \
+ const GLuint *_s = (const GLuint *) (SRC); \
+ GLuint *_d = (GLuint *) (DST); \
+ _d[0] = _s[0]; \
+ _d[1] = _s[1]; \
+ _d[2] = _s[2]; \
+ _d[3] = _s[3]; \
} while (0)
-
/** Copy \p SZ elements into a 4-element vector */
-#define COPY_SZ_4V(DST, SZ, SRC) \
-do { \
- switch (SZ) { \
- case 4: (DST)[3] = (SRC)[3]; \
- case 3: (DST)[2] = (SRC)[2]; \
- case 2: (DST)[1] = (SRC)[1]; \
- case 1: (DST)[0] = (SRC)[0]; \
- } \
+#define COPY_SZ_4V(DST, SZ, SRC) \
+do { \
+ switch (SZ) { \
+ case 4: (DST)[3] = (SRC)[3]; \
+ case 3: (DST)[2] = (SRC)[2]; \
+ case 2: (DST)[1] = (SRC)[1]; \
+ case 1: (DST)[0] = (SRC)[0]; \
+ } \
} while(0)
/** Copy \p SZ elements into a homegeneous (4-element) vector, giving
* default values to the remaining */
-#define COPY_CLEAN_4V(DST, SZ, SRC) \
-do { \
- ASSIGN_4V( DST, 0, 0, 0, 1 ); \
- COPY_SZ_4V( DST, SZ, SRC ); \
+#define COPY_CLEAN_4V(DST, SZ, SRC) \
+do { \
+ ASSIGN_4V( DST, 0, 0, 0, 1 ); \
+ COPY_SZ_4V( DST, SZ, SRC ); \
} while (0)
/** Subtraction */
-#define SUB_4V( DST, SRCA, SRCB ) \
-do { \
+#define SUB_4V( DST, SRCA, SRCB ) \
+do { \
(DST)[0] = (SRCA)[0] - (SRCB)[0]; \
(DST)[1] = (SRCA)[1] - (SRCB)[1]; \
(DST)[2] = (SRCA)[2] - (SRCB)[2]; \
} while (0)
/** Addition */
-#define ADD_4V( DST, SRCA, SRCB ) \
-do { \
+#define ADD_4V( DST, SRCA, SRCB ) \
+do { \
(DST)[0] = (SRCA)[0] + (SRCB)[0]; \
(DST)[1] = (SRCA)[1] + (SRCB)[1]; \
(DST)[2] = (SRCA)[2] + (SRCB)[2]; \
} while (0)
/** Element-wise multiplication */
-#define SCALE_4V( DST, SRCA, SRCB ) \
-do { \
+#define SCALE_4V( DST, SRCA, SRCB ) \
+do { \
(DST)[0] = (SRCA)[0] * (SRCB)[0]; \
(DST)[1] = (SRCA)[1] * (SRCB)[1]; \
(DST)[2] = (SRCA)[2] * (SRCB)[2]; \
/** In-place addition */
#define ACC_4V( DST, SRC ) \
-do { \
+do { \
(DST)[0] += (SRC)[0]; \
(DST)[1] += (SRC)[1]; \
(DST)[2] += (SRC)[2]; \
/** Element-wise multiplication and addition */
#define ACC_SCALE_4V( DST, SRCA, SRCB ) \
-do { \
+do { \
(DST)[0] += (SRCA)[0] * (SRCB)[0]; \
(DST)[1] += (SRCA)[1] * (SRCB)[1]; \
(DST)[2] += (SRCA)[2] * (SRCB)[2]; \
/** In-place scalar multiplication and addition */
#define ACC_SCALE_SCALAR_4V( DST, S, SRCB ) \
-do { \
- (DST)[0] += S * (SRCB)[0]; \
- (DST)[1] += S * (SRCB)[1]; \
- (DST)[2] += S * (SRCB)[2]; \
- (DST)[3] += S * (SRCB)[3]; \
+do { \
+ (DST)[0] += S * (SRCB)[0]; \
+ (DST)[1] += S * (SRCB)[1]; \
+ (DST)[2] += S * (SRCB)[2]; \
+ (DST)[3] += S * (SRCB)[3]; \
} while (0)
/** Scalar multiplication */
-#define SCALE_SCALAR_4V( DST, S, SRCB ) \
-do { \
+#define SCALE_SCALAR_4V( DST, S, SRCB ) \
+do { \
(DST)[0] = S * (SRCB)[0]; \
(DST)[1] = S * (SRCB)[1]; \
(DST)[2] = S * (SRCB)[2]; \
} while (0)
/** In-place scalar multiplication */
-#define SELF_SCALE_SCALAR_4V( DST, S ) \
-do { \
- (DST)[0] *= S; \
- (DST)[1] *= S; \
- (DST)[2] *= S; \
- (DST)[3] *= S; \
+#define SELF_SCALE_SCALAR_4V( DST, S ) \
+do { \
+ (DST)[0] *= S; \
+ (DST)[1] *= S; \
+ (DST)[2] *= S; \
+ (DST)[3] *= S; \
} while (0)
/** Assignment */
-#define ASSIGN_4V( V, V0, V1, V2, V3 ) \
-do { \
- V[0] = V0; \
- V[1] = V1; \
- V[2] = V2; \
- V[3] = V3; \
+#define ASSIGN_4V( V, V0, V1, V2, V3 ) \
+do { \
+ V[0] = V0; \
+ V[1] = V1; \
+ V[2] = V2; \
+ V[3] = V3; \
} while(0)
/*@}*/
#define ZERO_3V( DST ) (DST)[0] = (DST)[1] = (DST)[2] = 0
/** Test for equality */
-#define TEST_EQ_3V(a,b) ((a)[0] == (b)[0] && \
- (a)[1] == (b)[1] && \
- (a)[2] == (b)[2])
+#define TEST_EQ_3V(a,b) \
+ ((a)[0] == (b)[0] && \
+ (a)[1] == (b)[1] && \
+ (a)[2] == (b)[2])
/** Copy a 3-element vector */
#define COPY_3V( DST, SRC ) \
-do { \
+do { \
(DST)[0] = (SRC)[0]; \
(DST)[1] = (SRC)[1]; \
(DST)[2] = (SRC)[2]; \
} while (0)
/** Copy a 3-element vector with cast */
-#define COPY_3V_CAST( DST, SRC, CAST ) \
-do { \
+#define COPY_3V_CAST( DST, SRC, CAST ) \
+do { \
(DST)[0] = (CAST)(SRC)[0]; \
(DST)[1] = (CAST)(SRC)[1]; \
(DST)[2] = (CAST)(SRC)[2]; \
} while (0)
/** Copy a 3-element float vector */
-#define COPY_3FV( DST, SRC ) \
-do { \
- const GLfloat *_tmp = (SRC); \
+#define COPY_3FV( DST, SRC ) \
+do { \
+ const GLfloat *_tmp = (SRC); \
(DST)[0] = _tmp[0]; \
(DST)[1] = _tmp[1]; \
(DST)[2] = _tmp[2]; \
} while (0)
/** Subtraction */
-#define SUB_3V( DST, SRCA, SRCB ) \
-do { \
- (DST)[0] = (SRCA)[0] - (SRCB)[0]; \
- (DST)[1] = (SRCA)[1] - (SRCB)[1]; \
- (DST)[2] = (SRCA)[2] - (SRCB)[2]; \
+#define SUB_3V( DST, SRCA, SRCB ) \
+do { \
+ (DST)[0] = (SRCA)[0] - (SRCB)[0]; \
+ (DST)[1] = (SRCA)[1] - (SRCB)[1]; \
+ (DST)[2] = (SRCA)[2] - (SRCB)[2]; \
} while (0)
/** Addition */
#define ADD_3V( DST, SRCA, SRCB ) \
-do { \
- (DST)[0] = (SRCA)[0] + (SRCB)[0]; \
- (DST)[1] = (SRCA)[1] + (SRCB)[1]; \
- (DST)[2] = (SRCA)[2] + (SRCB)[2]; \
+do { \
+ (DST)[0] = (SRCA)[0] + (SRCB)[0]; \
+ (DST)[1] = (SRCA)[1] + (SRCB)[1]; \
+ (DST)[2] = (SRCA)[2] + (SRCB)[2]; \
} while (0)
/** In-place scalar multiplication */
#define SCALE_3V( DST, SRCA, SRCB ) \
-do { \
- (DST)[0] = (SRCA)[0] * (SRCB)[0]; \
- (DST)[1] = (SRCA)[1] * (SRCB)[1]; \
- (DST)[2] = (SRCA)[2] * (SRCB)[2]; \
+do { \
+ (DST)[0] = (SRCA)[0] * (SRCB)[0]; \
+ (DST)[1] = (SRCA)[1] * (SRCB)[1]; \
+ (DST)[2] = (SRCA)[2] * (SRCB)[2]; \
} while (0)
/** In-place element-wise multiplication */
-#define SELF_SCALE_3V( DST, SRC ) \
-do { \
+#define SELF_SCALE_3V( DST, SRC ) \
+do { \
(DST)[0] *= (SRC)[0]; \
(DST)[1] *= (SRC)[1]; \
(DST)[2] *= (SRC)[2]; \
/** In-place addition */
#define ACC_3V( DST, SRC ) \
-do { \
+do { \
(DST)[0] += (SRC)[0]; \
(DST)[1] += (SRC)[1]; \
(DST)[2] += (SRC)[2]; \
/** Element-wise multiplication and addition */
#define ACC_SCALE_3V( DST, SRCA, SRCB ) \
-do { \
+do { \
(DST)[0] += (SRCA)[0] * (SRCB)[0]; \
(DST)[1] += (SRCA)[1] * (SRCB)[1]; \
(DST)[2] += (SRCA)[2] * (SRCB)[2]; \
} while (0)
/** Scalar multiplication */
-#define SCALE_SCALAR_3V( DST, S, SRCB ) \
-do { \
+#define SCALE_SCALAR_3V( DST, S, SRCB ) \
+do { \
(DST)[0] = S * (SRCB)[0]; \
(DST)[1] = S * (SRCB)[1]; \
(DST)[2] = S * (SRCB)[2]; \
/** In-place scalar multiplication and addition */
#define ACC_SCALE_SCALAR_3V( DST, S, SRCB ) \
-do { \
- (DST)[0] += S * (SRCB)[0]; \
- (DST)[1] += S * (SRCB)[1]; \
- (DST)[2] += S * (SRCB)[2]; \
+do { \
+ (DST)[0] += S * (SRCB)[0]; \
+ (DST)[1] += S * (SRCB)[1]; \
+ (DST)[2] += S * (SRCB)[2]; \
} while (0)
/** In-place scalar multiplication */
-#define SELF_SCALE_SCALAR_3V( DST, S ) \
-do { \
- (DST)[0] *= S; \
- (DST)[1] *= S; \
- (DST)[2] *= S; \
+#define SELF_SCALE_SCALAR_3V( DST, S ) \
+do { \
+ (DST)[0] *= S; \
+ (DST)[1] *= S; \
+ (DST)[2] *= S; \
} while (0)
/** In-place scalar addition */
-#define ACC_SCALAR_3V( DST, S ) \
-do { \
+#define ACC_SCALAR_3V( DST, S ) \
+do { \
(DST)[0] += S; \
(DST)[1] += S; \
(DST)[2] += S; \
/** Assignment */
#define ASSIGN_3V( V, V0, V1, V2 ) \
-do { \
- V[0] = V0; \
- V[1] = V1; \
- V[2] = V2; \
+do { \
+ V[0] = V0; \
+ V[1] = V1; \
+ V[2] = V2; \
} while(0)
/*@}*/
#define LEN_SQUARED_2FV( V ) ((V)[0]*(V)[0]+(V)[1]*(V)[1])
-/*@}*/
-
-
#endif