diff options
Diffstat (limited to 'dep/src')
107 files changed, 39441 insertions, 715 deletions
diff --git a/dep/src/bzip2/blocksort.c b/dep/src/bzip2/blocksort.c new file mode 100644 index 00000000000..bd2dec157fa --- /dev/null +++ b/dep/src/bzip2/blocksort.c @@ -0,0 +1,1094 @@ + +/*-------------------------------------------------------------*/ +/*--- Block sorting machinery ---*/ +/*--- blocksort.c ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#include "bzlib_private.h" + +/*---------------------------------------------*/ +/*--- Fallback O(N log(N)^2) sorting ---*/ +/*--- algorithm, for repetitive blocks ---*/ +/*---------------------------------------------*/ + +/*---------------------------------------------*/ +static +__inline__ +void fallbackSimpleSort ( UInt32* fmap, + UInt32* eclass, + Int32 lo, + Int32 hi ) +{ + Int32 i, j, tmp; + UInt32 ec_tmp; + + if (lo == hi) return; + + if (hi - lo > 3) { + for ( i = hi-4; i >= lo; i-- ) { + tmp = fmap[i]; + ec_tmp = eclass[tmp]; + for ( j = i+4; j <= hi && ec_tmp > eclass[fmap[j]]; j += 4 ) + fmap[j-4] = fmap[j]; + fmap[j-4] = tmp; + } + } + + for ( i = hi-1; i >= lo; i-- ) { + tmp = fmap[i]; + ec_tmp = eclass[tmp]; + for ( j = i+1; j <= hi && ec_tmp > eclass[fmap[j]]; j++ ) + fmap[j-1] = fmap[j]; + fmap[j-1] = tmp; + } +} + + +/*---------------------------------------------*/ +#define fswap(zz1, zz2) \ + { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; } + +#define fvswap(zzp1, zzp2, zzn) \ +{ \ + Int32 yyp1 = (zzp1); \ + Int32 yyp2 = (zzp2); \ + Int32 yyn = (zzn); \ + while (yyn > 0) { \ + fswap(fmap[yyp1], fmap[yyp2]); \ + yyp1++; yyp2++; yyn--; \ + } \ +} + + +#define fmin(a,b) ((a) < (b)) ? (a) : (b) + +#define fpush(lz,hz) { stackLo[sp] = lz; \ + stackHi[sp] = hz; \ + sp++; } + +#define fpop(lz,hz) { sp--; \ + lz = stackLo[sp]; \ + hz = stackHi[sp]; } + +#define FALLBACK_QSORT_SMALL_THRESH 10 +#define FALLBACK_QSORT_STACK_SIZE 100 + + +static +void fallbackQSort3 ( UInt32* fmap, + UInt32* eclass, + Int32 loSt, + Int32 hiSt ) +{ + Int32 unLo, unHi, ltLo, gtHi, n, m; + Int32 sp, lo, hi; + UInt32 med, r, r3; + Int32 stackLo[FALLBACK_QSORT_STACK_SIZE]; + Int32 stackHi[FALLBACK_QSORT_STACK_SIZE]; + + r = 0; + + sp = 0; + fpush ( loSt, hiSt ); + + while (sp > 0) { + + AssertH ( sp < FALLBACK_QSORT_STACK_SIZE - 1, 1004 ); + + fpop ( lo, hi ); + if (hi - lo < FALLBACK_QSORT_SMALL_THRESH) { + fallbackSimpleSort ( fmap, eclass, lo, hi ); + continue; + } + + /* Random partitioning. Median of 3 sometimes fails to + avoid bad cases. Median of 9 seems to help but + looks rather expensive. This too seems to work but + is cheaper. Guidance for the magic constants + 7621 and 32768 is taken from Sedgewick's algorithms + book, chapter 35. + */ + r = ((r * 7621) + 1) % 32768; + r3 = r % 3; + if (r3 == 0) med = eclass[fmap[lo]]; else + if (r3 == 1) med = eclass[fmap[(lo+hi)>>1]]; else + med = eclass[fmap[hi]]; + + unLo = ltLo = lo; + unHi = gtHi = hi; + + while (1) { + while (1) { + if (unLo > unHi) break; + n = (Int32)eclass[fmap[unLo]] - (Int32)med; + if (n == 0) { + fswap(fmap[unLo], fmap[ltLo]); + ltLo++; unLo++; + continue; + }; + if (n > 0) break; + unLo++; + } + while (1) { + if (unLo > unHi) break; + n = (Int32)eclass[fmap[unHi]] - (Int32)med; + if (n == 0) { + fswap(fmap[unHi], fmap[gtHi]); + gtHi--; unHi--; + continue; + }; + if (n < 0) break; + unHi--; + } + if (unLo > unHi) break; + fswap(fmap[unLo], fmap[unHi]); unLo++; unHi--; + } + + AssertD ( unHi == unLo-1, "fallbackQSort3(2)" ); + + if (gtHi < ltLo) continue; + + n = fmin(ltLo-lo, unLo-ltLo); fvswap(lo, unLo-n, n); + m = fmin(hi-gtHi, gtHi-unHi); fvswap(unLo, hi-m+1, m); + + n = lo + unLo - ltLo - 1; + m = hi - (gtHi - unHi) + 1; + + if (n - lo > hi - m) { + fpush ( lo, n ); + fpush ( m, hi ); + } else { + fpush ( m, hi ); + fpush ( lo, n ); + } + } +} + +#undef fmin +#undef fpush +#undef fpop +#undef fswap +#undef fvswap +#undef FALLBACK_QSORT_SMALL_THRESH +#undef FALLBACK_QSORT_STACK_SIZE + + +/*---------------------------------------------*/ +/* Pre: + nblock > 0 + eclass exists for [0 .. nblock-1] + ((UChar*)eclass) [0 .. nblock-1] holds block + ptr exists for [0 .. nblock-1] + + Post: + ((UChar*)eclass) [0 .. nblock-1] holds block + All other areas of eclass destroyed + fmap [0 .. nblock-1] holds sorted order + bhtab [ 0 .. 2+(nblock/32) ] destroyed +*/ + +#define SET_BH(zz) bhtab[(zz) >> 5] |= (1 << ((zz) & 31)) +#define CLEAR_BH(zz) bhtab[(zz) >> 5] &= ~(1 << ((zz) & 31)) +#define ISSET_BH(zz) (bhtab[(zz) >> 5] & (1 << ((zz) & 31))) +#define WORD_BH(zz) bhtab[(zz) >> 5] +#define UNALIGNED_BH(zz) ((zz) & 0x01f) + +static +void fallbackSort ( UInt32* fmap, + UInt32* eclass, + UInt32* bhtab, + Int32 nblock, + Int32 verb ) +{ + Int32 ftab[257]; + Int32 ftabCopy[256]; + Int32 H, i, j, k, l, r, cc, cc1; + Int32 nNotDone; + Int32 nBhtab; + UChar* eclass8 = (UChar*)eclass; + + /*-- + Initial 1-char radix sort to generate + initial fmap and initial BH bits. + --*/ + if (verb >= 4) + VPrintf0 ( " bucket sorting ...\n" ); + for (i = 0; i < 257; i++) ftab[i] = 0; + for (i = 0; i < nblock; i++) ftab[eclass8[i]]++; + for (i = 0; i < 256; i++) ftabCopy[i] = ftab[i]; + for (i = 1; i < 257; i++) ftab[i] += ftab[i-1]; + + for (i = 0; i < nblock; i++) { + j = eclass8[i]; + k = ftab[j] - 1; + ftab[j] = k; + fmap[k] = i; + } + + nBhtab = 2 + (nblock / 32); + for (i = 0; i < nBhtab; i++) bhtab[i] = 0; + for (i = 0; i < 256; i++) SET_BH(ftab[i]); + + /*-- + Inductively refine the buckets. Kind-of an + "exponential radix sort" (!), inspired by the + Manber-Myers suffix array construction algorithm. + --*/ + + /*-- set sentinel bits for block-end detection --*/ + for (i = 0; i < 32; i++) { + SET_BH(nblock + 2*i); + CLEAR_BH(nblock + 2*i + 1); + } + + /*-- the log(N) loop --*/ + H = 1; + while (1) { + + if (verb >= 4) + VPrintf1 ( " depth %6d has ", H ); + + j = 0; + for (i = 0; i < nblock; i++) { + if (ISSET_BH(i)) j = i; + k = fmap[i] - H; if (k < 0) k += nblock; + eclass[k] = j; + } + + nNotDone = 0; + r = -1; + while (1) { + + /*-- find the next non-singleton bucket --*/ + k = r + 1; + while (ISSET_BH(k) && UNALIGNED_BH(k)) k++; + if (ISSET_BH(k)) { + while (WORD_BH(k) == 0xffffffff) k += 32; + while (ISSET_BH(k)) k++; + } + l = k - 1; + if (l >= nblock) break; + while (!ISSET_BH(k) && UNALIGNED_BH(k)) k++; + if (!ISSET_BH(k)) { + while (WORD_BH(k) == 0x00000000) k += 32; + while (!ISSET_BH(k)) k++; + } + r = k - 1; + if (r >= nblock) break; + + /*-- now [l, r] bracket current bucket --*/ + if (r > l) { + nNotDone += (r - l + 1); + fallbackQSort3 ( fmap, eclass, l, r ); + + /*-- scan bucket and generate header bits-- */ + cc = -1; + for (i = l; i <= r; i++) { + cc1 = eclass[fmap[i]]; + if (cc != cc1) { SET_BH(i); cc = cc1; }; + } + } + } + + if (verb >= 4) + VPrintf1 ( "%6d unresolved strings\n", nNotDone ); + + H *= 2; + if (H > nblock || nNotDone == 0) break; + } + + /*-- + Reconstruct the original block in + eclass8 [0 .. nblock-1], since the + previous phase destroyed it. + --*/ + if (verb >= 4) + VPrintf0 ( " reconstructing block ...\n" ); + j = 0; + for (i = 0; i < nblock; i++) { + while (ftabCopy[j] == 0) j++; + ftabCopy[j]--; + eclass8[fmap[i]] = (UChar)j; + } + AssertH ( j < 256, 1005 ); +} + +#undef SET_BH +#undef CLEAR_BH +#undef ISSET_BH +#undef WORD_BH +#undef UNALIGNED_BH + + +/*---------------------------------------------*/ +/*--- The main, O(N^2 log(N)) sorting ---*/ +/*--- algorithm. Faster for "normal" ---*/ +/*--- non-repetitive blocks. ---*/ +/*---------------------------------------------*/ + +/*---------------------------------------------*/ +static +__inline__ +Bool mainGtU ( UInt32 i1, + UInt32 i2, + UChar* block, + UInt16* quadrant, + UInt32 nblock, + Int32* budget ) +{ + Int32 k; + UChar c1, c2; + UInt16 s1, s2; + + AssertD ( i1 != i2, "mainGtU" ); + /* 1 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 2 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 3 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 4 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 5 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 6 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 7 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 8 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 9 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 10 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 11 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 12 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + + k = nblock + 8; + + do { + /* 1 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 2 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 3 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 4 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 5 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 6 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 7 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 8 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + + if (i1 >= nblock) i1 -= nblock; + if (i2 >= nblock) i2 -= nblock; + + k -= 8; + (*budget)--; + } + while (k >= 0); + + return False; +} + + +/*---------------------------------------------*/ +/*-- + Knuth's increments seem to work better + than Incerpi-Sedgewick here. Possibly + because the number of elems to sort is + usually small, typically <= 20. +--*/ +static +Int32 incs[14] = { 1, 4, 13, 40, 121, 364, 1093, 3280, + 9841, 29524, 88573, 265720, + 797161, 2391484 }; + +static +void mainSimpleSort ( UInt32* ptr, + UChar* block, + UInt16* quadrant, + Int32 nblock, + Int32 lo, + Int32 hi, + Int32 d, + Int32* budget ) +{ + Int32 i, j, h, bigN, hp; + UInt32 v; + + bigN = hi - lo + 1; + if (bigN < 2) return; + + hp = 0; + while (incs[hp] < bigN) hp++; + hp--; + + for (; hp >= 0; hp--) { + h = incs[hp]; + + i = lo + h; + while (True) { + + /*-- copy 1 --*/ + if (i > hi) break; + v = ptr[i]; + j = i; + while ( mainGtU ( + ptr[j-h]+d, v+d, block, quadrant, nblock, budget + ) ) { + ptr[j] = ptr[j-h]; + j = j - h; + if (j <= (lo + h - 1)) break; + } + ptr[j] = v; + i++; + + /*-- copy 2 --*/ + if (i > hi) break; + v = ptr[i]; + j = i; + while ( mainGtU ( + ptr[j-h]+d, v+d, block, quadrant, nblock, budget + ) ) { + ptr[j] = ptr[j-h]; + j = j - h; + if (j <= (lo + h - 1)) break; + } + ptr[j] = v; + i++; + + /*-- copy 3 --*/ + if (i > hi) break; + v = ptr[i]; + j = i; + while ( mainGtU ( + ptr[j-h]+d, v+d, block, quadrant, nblock, budget + ) ) { + ptr[j] = ptr[j-h]; + j = j - h; + if (j <= (lo + h - 1)) break; + } + ptr[j] = v; + i++; + + if (*budget < 0) return; + } + } +} + + +/*---------------------------------------------*/ +/*-- + The following is an implementation of + an elegant 3-way quicksort for strings, + described in a paper "Fast Algorithms for + Sorting and Searching Strings", by Robert + Sedgewick and Jon L. Bentley. +--*/ + +#define mswap(zz1, zz2) \ + { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; } + +#define mvswap(zzp1, zzp2, zzn) \ +{ \ + Int32 yyp1 = (zzp1); \ + Int32 yyp2 = (zzp2); \ + Int32 yyn = (zzn); \ + while (yyn > 0) { \ + mswap(ptr[yyp1], ptr[yyp2]); \ + yyp1++; yyp2++; yyn--; \ + } \ +} + +static +__inline__ +UChar mmed3 ( UChar a, UChar b, UChar c ) +{ + UChar t; + if (a > b) { t = a; a = b; b = t; }; + if (b > c) { + b = c; + if (a > b) b = a; + } + return b; +} + +#define mmin(a,b) ((a) < (b)) ? (a) : (b) + +#define mpush(lz,hz,dz) { stackLo[sp] = lz; \ + stackHi[sp] = hz; \ + stackD [sp] = dz; \ + sp++; } + +#define mpop(lz,hz,dz) { sp--; \ + lz = stackLo[sp]; \ + hz = stackHi[sp]; \ + dz = stackD [sp]; } + + +#define mnextsize(az) (nextHi[az]-nextLo[az]) + +#define mnextswap(az,bz) \ + { Int32 tz; \ + tz = nextLo[az]; nextLo[az] = nextLo[bz]; nextLo[bz] = tz; \ + tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \ + tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; } + + +#define MAIN_QSORT_SMALL_THRESH 20 +#define MAIN_QSORT_DEPTH_THRESH (BZ_N_RADIX + BZ_N_QSORT) +#define MAIN_QSORT_STACK_SIZE 100 + +static +void mainQSort3 ( UInt32* ptr, + UChar* block, + UInt16* quadrant, + Int32 nblock, + Int32 loSt, + Int32 hiSt, + Int32 dSt, + Int32* budget ) +{ + Int32 unLo, unHi, ltLo, gtHi, n, m, med; + Int32 sp, lo, hi, d; + + Int32 stackLo[MAIN_QSORT_STACK_SIZE]; + Int32 stackHi[MAIN_QSORT_STACK_SIZE]; + Int32 stackD [MAIN_QSORT_STACK_SIZE]; + + Int32 nextLo[3]; + Int32 nextHi[3]; + Int32 nextD [3]; + + sp = 0; + mpush ( loSt, hiSt, dSt ); + + while (sp > 0) { + + AssertH ( sp < MAIN_QSORT_STACK_SIZE - 2, 1001 ); + + mpop ( lo, hi, d ); + if (hi - lo < MAIN_QSORT_SMALL_THRESH || + d > MAIN_QSORT_DEPTH_THRESH) { + mainSimpleSort ( ptr, block, quadrant, nblock, lo, hi, d, budget ); + if (*budget < 0) return; + continue; + } + + med = (Int32) + mmed3 ( block[ptr[ lo ]+d], + block[ptr[ hi ]+d], + block[ptr[ (lo+hi)>>1 ]+d] ); + + unLo = ltLo = lo; + unHi = gtHi = hi; + + while (True) { + while (True) { + if (unLo > unHi) break; + n = ((Int32)block[ptr[unLo]+d]) - med; + if (n == 0) { + mswap(ptr[unLo], ptr[ltLo]); + ltLo++; unLo++; continue; + }; + if (n > 0) break; + unLo++; + } + while (True) { + if (unLo > unHi) break; + n = ((Int32)block[ptr[unHi]+d]) - med; + if (n == 0) { + mswap(ptr[unHi], ptr[gtHi]); + gtHi--; unHi--; continue; + }; + if (n < 0) break; + unHi--; + } + if (unLo > unHi) break; + mswap(ptr[unLo], ptr[unHi]); unLo++; unHi--; + } + + AssertD ( unHi == unLo-1, "mainQSort3(2)" ); + + if (gtHi < ltLo) { + mpush(lo, hi, d+1 ); + continue; + } + + n = mmin(ltLo-lo, unLo-ltLo); mvswap(lo, unLo-n, n); + m = mmin(hi-gtHi, gtHi-unHi); mvswap(unLo, hi-m+1, m); + + n = lo + unLo - ltLo - 1; + m = hi - (gtHi - unHi) + 1; + + nextLo[0] = lo; nextHi[0] = n; nextD[0] = d; + nextLo[1] = m; nextHi[1] = hi; nextD[1] = d; + nextLo[2] = n+1; nextHi[2] = m-1; nextD[2] = d+1; + + if (mnextsize(0) < mnextsize(1)) mnextswap(0,1); + if (mnextsize(1) < mnextsize(2)) mnextswap(1,2); + if (mnextsize(0) < mnextsize(1)) mnextswap(0,1); + + AssertD (mnextsize(0) >= mnextsize(1), "mainQSort3(8)" ); + AssertD (mnextsize(1) >= mnextsize(2), "mainQSort3(9)" ); + + mpush (nextLo[0], nextHi[0], nextD[0]); + mpush (nextLo[1], nextHi[1], nextD[1]); + mpush (nextLo[2], nextHi[2], nextD[2]); + } +} + +#undef mswap +#undef mvswap +#undef mpush +#undef mpop +#undef mmin +#undef mnextsize +#undef mnextswap +#undef MAIN_QSORT_SMALL_THRESH +#undef MAIN_QSORT_DEPTH_THRESH +#undef MAIN_QSORT_STACK_SIZE + + +/*---------------------------------------------*/ +/* Pre: + nblock > N_OVERSHOOT + block32 exists for [0 .. nblock-1 +N_OVERSHOOT] + ((UChar*)block32) [0 .. nblock-1] holds block + ptr exists for [0 .. nblock-1] + + Post: + ((UChar*)block32) [0 .. nblock-1] holds block + All other areas of block32 destroyed + ftab [0 .. 65536 ] destroyed + ptr [0 .. nblock-1] holds sorted order + if (*budget < 0), sorting was abandoned +*/ + +#define BIGFREQ(b) (ftab[((b)+1) << 8] - ftab[(b) << 8]) +#define SETMASK (1 << 21) +#define CLEARMASK (~(SETMASK)) + +static +void mainSort ( UInt32* ptr, + UChar* block, + UInt16* quadrant, + UInt32* ftab, + Int32 nblock, + Int32 verb, + Int32* budget ) +{ + Int32 i, j, k, ss, sb; + Int32 runningOrder[256]; + Bool bigDone[256]; + Int32 copyStart[256]; + Int32 copyEnd [256]; + UChar c1; + Int32 numQSorted; + UInt16 s; + if (verb >= 4) VPrintf0 ( " main sort initialise ...\n" ); + + /*-- set up the 2-byte frequency table --*/ + for (i = 65536; i >= 0; i--) ftab[i] = 0; + + j = block[0] << 8; + i = nblock-1; + for (; i >= 3; i -= 4) { + quadrant[i] = 0; + j = (j >> 8) | ( ((UInt16)block[i]) << 8); + ftab[j]++; + quadrant[i-1] = 0; + j = (j >> 8) | ( ((UInt16)block[i-1]) << 8); + ftab[j]++; + quadrant[i-2] = 0; + j = (j >> 8) | ( ((UInt16)block[i-2]) << 8); + ftab[j]++; + quadrant[i-3] = 0; + j = (j >> 8) | ( ((UInt16)block[i-3]) << 8); + ftab[j]++; + } + for (; i >= 0; i--) { + quadrant[i] = 0; + j = (j >> 8) | ( ((UInt16)block[i]) << 8); + ftab[j]++; + } + + /*-- (emphasises close relationship of block & quadrant) --*/ + for (i = 0; i < BZ_N_OVERSHOOT; i++) { + block [nblock+i] = block[i]; + quadrant[nblock+i] = 0; + } + + if (verb >= 4) VPrintf0 ( " bucket sorting ...\n" ); + + /*-- Complete the initial radix sort --*/ + for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1]; + + s = block[0] << 8; + i = nblock-1; + for (; i >= 3; i -= 4) { + s = (s >> 8) | (block[i] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i; + s = (s >> 8) | (block[i-1] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i-1; + s = (s >> 8) | (block[i-2] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i-2; + s = (s >> 8) | (block[i-3] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i-3; + } + for (; i >= 0; i--) { + s = (s >> 8) | (block[i] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i; + } + + /*-- + Now ftab contains the first loc of every small bucket. + Calculate the running order, from smallest to largest + big bucket. + --*/ + for (i = 0; i <= 255; i++) { + bigDone [i] = False; + runningOrder[i] = i; + } + + { + Int32 vv; + Int32 h = 1; + do h = 3 * h + 1; while (h <= 256); + do { + h = h / 3; + for (i = h; i <= 255; i++) { + vv = runningOrder[i]; + j = i; + while ( BIGFREQ(runningOrder[j-h]) > BIGFREQ(vv) ) { + runningOrder[j] = runningOrder[j-h]; + j = j - h; + if (j <= (h - 1)) goto zero; + } + zero: + runningOrder[j] = vv; + } + } while (h != 1); + } + + /*-- + The main sorting loop. + --*/ + + numQSorted = 0; + + for (i = 0; i <= 255; i++) { + + /*-- + Process big buckets, starting with the least full. + Basically this is a 3-step process in which we call + mainQSort3 to sort the small buckets [ss, j], but + also make a big effort to avoid the calls if we can. + --*/ + ss = runningOrder[i]; + + /*-- + Step 1: + Complete the big bucket [ss] by quicksorting + any unsorted small buckets [ss, j], for j != ss. + Hopefully previous pointer-scanning phases have already + completed many of the small buckets [ss, j], so + we don't have to sort them at all. + --*/ + for (j = 0; j <= 255; j++) { + if (j != ss) { + sb = (ss << 8) + j; + if ( ! (ftab[sb] & SETMASK) ) { + Int32 lo = ftab[sb] & CLEARMASK; + Int32 hi = (ftab[sb+1] & CLEARMASK) - 1; + if (hi > lo) { + if (verb >= 4) + VPrintf4 ( " qsort [0x%x, 0x%x] " + "done %d this %d\n", + ss, j, numQSorted, hi - lo + 1 ); + mainQSort3 ( + ptr, block, quadrant, nblock, + lo, hi, BZ_N_RADIX, budget + ); + numQSorted += (hi - lo + 1); + if (*budget < 0) return; + } + } + ftab[sb] |= SETMASK; + } + } + + AssertH ( !bigDone[ss], 1006 ); + + /*-- + Step 2: + Now scan this big bucket [ss] so as to synthesise the + sorted order for small buckets [t, ss] for all t, + including, magically, the bucket [ss,ss] too. + This will avoid doing Real Work in subsequent Step 1's. + --*/ + { + for (j = 0; j <= 255; j++) { + copyStart[j] = ftab[(j << 8) + ss] & CLEARMASK; + copyEnd [j] = (ftab[(j << 8) + ss + 1] & CLEARMASK) - 1; + } + for (j = ftab[ss << 8] & CLEARMASK; j < copyStart[ss]; j++) { + k = ptr[j]-1; if (k < 0) k += nblock; + c1 = block[k]; + if (!bigDone[c1]) + ptr[ copyStart[c1]++ ] = k; + } + for (j = (ftab[(ss+1) << 8] & CLEARMASK) - 1; j > copyEnd[ss]; j--) { + k = ptr[j]-1; if (k < 0) k += nblock; + c1 = block[k]; + if (!bigDone[c1]) + ptr[ copyEnd[c1]-- ] = k; + } + } + + AssertH ( (copyStart[ss]-1 == copyEnd[ss]) + || + /* Extremely rare case missing in bzip2-1.0.0 and 1.0.1. + Necessity for this case is demonstrated by compressing + a sequence of approximately 48.5 million of character + 251; 1.0.0/1.0.1 will then die here. */ + (copyStart[ss] == 0 && copyEnd[ss] == nblock-1), + 1007 ) + + for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= SETMASK; + + /*-- + Step 3: + The [ss] big bucket is now done. Record this fact, + and update the quadrant descriptors. Remember to + update quadrants in the overshoot area too, if + necessary. The "if (i < 255)" test merely skips + this updating for the last bucket processed, since + updating for the last bucket is pointless. + + The quadrant array provides a way to incrementally + cache sort orderings, as they appear, so as to + make subsequent comparisons in fullGtU() complete + faster. For repetitive blocks this makes a big + difference (but not big enough to be able to avoid + the fallback sorting mechanism, exponential radix sort). + + The precise meaning is: at all times: + + for 0 <= i < nblock and 0 <= j <= nblock + + if block[i] != block[j], + + then the relative values of quadrant[i] and + quadrant[j] are meaningless. + + else { + if quadrant[i] < quadrant[j] + then the string starting at i lexicographically + precedes the string starting at j + + else if quadrant[i] > quadrant[j] + then the string starting at j lexicographically + precedes the string starting at i + + else + the relative ordering of the strings starting + at i and j has not yet been determined. + } + --*/ + bigDone[ss] = True; + + if (i < 255) { + Int32 bbStart = ftab[ss << 8] & CLEARMASK; + Int32 bbSize = (ftab[(ss+1) << 8] & CLEARMASK) - bbStart; + Int32 shifts = 0; + + while ((bbSize >> shifts) > 65534) shifts++; + + for (j = bbSize-1; j >= 0; j--) { + Int32 a2update = ptr[bbStart + j]; + UInt16 qVal = (UInt16)(j >> shifts); + quadrant[a2update] = qVal; + if (a2update < BZ_N_OVERSHOOT) + quadrant[a2update + nblock] = qVal; + } + AssertH ( ((bbSize-1) >> shifts) <= 65535, 1002 ); + } + + } + + if (verb >= 4) + VPrintf3 ( " %d pointers, %d sorted, %d scanned\n", + nblock, numQSorted, nblock - numQSorted ); +} + +#undef BIGFREQ +#undef SETMASK +#undef CLEARMASK + + +/*---------------------------------------------*/ +/* Pre: + nblock > 0 + arr2 exists for [0 .. nblock-1 +N_OVERSHOOT] + ((UChar*)arr2) [0 .. nblock-1] holds block + arr1 exists for [0 .. nblock-1] + + Post: + ((UChar*)arr2) [0 .. nblock-1] holds block + All other areas of block destroyed + ftab [ 0 .. 65536 ] destroyed + arr1 [0 .. nblock-1] holds sorted order +*/ +void BZ2_blockSort ( EState* s ) +{ + UInt32* ptr = s->ptr; + UChar* block = s->block; + UInt32* ftab = s->ftab; + Int32 nblock = s->nblock; + Int32 verb = s->verbosity; + Int32 wfact = s->workFactor; + UInt16* quadrant; + Int32 budget; + Int32 budgetInit; + Int32 i; + + if (nblock < 10000) { + fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb ); + } else { + /* Calculate the location for quadrant, remembering to get + the alignment right. Assumes that &(block[0]) is at least + 2-byte aligned -- this should be ok since block is really + the first section of arr2. + */ + i = nblock+BZ_N_OVERSHOOT; + if (i & 1) i++; + quadrant = (UInt16*)(&(block[i])); + + /* (wfact-1) / 3 puts the default-factor-30 + transition point at very roughly the same place as + with v0.1 and v0.9.0. + Not that it particularly matters any more, since the + resulting compressed stream is now the same regardless + of whether or not we use the main sort or fallback sort. + */ + if (wfact < 1 ) wfact = 1; + if (wfact > 100) wfact = 100; + budgetInit = nblock * ((wfact-1) / 3); + budget = budgetInit; + + mainSort ( ptr, block, quadrant, ftab, nblock, verb, &budget ); + if (verb >= 3) + VPrintf3 ( " %d work, %d block, ratio %5.2f\n", + budgetInit - budget, + nblock, + (float)(budgetInit - budget) / + (float)(nblock==0 ? 1 : nblock) ); + if (budget < 0) { + if (verb >= 2) + VPrintf0 ( " too repetitive; using fallback" + " sorting algorithm\n" ); + fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb ); + } + } + + s->origPtr = -1; + for (i = 0; i < s->nblock; i++) + if (ptr[i] == 0) + { s->origPtr = i; break; }; + + AssertH( s->origPtr != -1, 1003 ); +} + + +/*-------------------------------------------------------------*/ +/*--- end blocksort.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/bzlib.c b/dep/src/bzip2/bzlib.c new file mode 100644 index 00000000000..ef86c91e695 --- /dev/null +++ b/dep/src/bzip2/bzlib.c @@ -0,0 +1,1572 @@ + +/*-------------------------------------------------------------*/ +/*--- Library top-level functions. ---*/ +/*--- bzlib.c ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + +/* CHANGES + 0.9.0 -- original version. + 0.9.0a/b -- no changes in this file. + 0.9.0c -- made zero-length BZ_FLUSH work correctly in bzCompress(). + fixed bzWrite/bzRead to ignore zero-length requests. + fixed bzread to correctly handle read requests after EOF. + wrong parameter order in call to bzDecompressInit in + bzBuffToBuffDecompress. Fixed. +*/ + +#include "bzlib_private.h" + + +/*---------------------------------------------------*/ +/*--- Compression stuff ---*/ +/*---------------------------------------------------*/ + + +/*---------------------------------------------------*/ +#ifndef BZ_NO_STDIO +void BZ2_bz__AssertH__fail ( int errcode ) +{ + fprintf(stderr, + "\n\nbzip2/libbzip2: internal error number %d.\n" + "This is a bug in bzip2/libbzip2, %s.\n" + "Please report it to me at: jseward@bzip.org. If this happened\n" + "when you were using some program which uses libbzip2 as a\n" + "component, you should also report this bug to the author(s)\n" + "of that program. Please make an effort to report this bug;\n" + "timely and accurate bug reports eventually lead to higher\n" + "quality software. Thanks. Julian Seward, 10 December 2007.\n\n", + errcode, + BZ2_bzlibVersion() + ); + + if (errcode == 1007) { + fprintf(stderr, + "\n*** A special note about internal error number 1007 ***\n" + "\n" + "Experience suggests that a common cause of i.e. 1007\n" + "is unreliable memory or other hardware. The 1007 assertion\n" + "just happens to cross-check the results of huge numbers of\n" + "memory reads/writes, and so acts (unintendedly) as a stress\n" + "test of your memory system.\n" + "\n" + "I suggest the following: try compressing the file again,\n" + "possibly monitoring progress in detail with the -vv flag.\n" + "\n" + "* If the error cannot be reproduced, and/or happens at different\n" + " points in compression, you may have a flaky memory system.\n" + " Try a memory-test program. I have used Memtest86\n" + " (www.memtest86.com). At the time of writing it is free (GPLd).\n" + " Memtest86 tests memory much more thorougly than your BIOSs\n" + " power-on test, and may find failures that the BIOS doesn't.\n" + "\n" + "* If the error can be repeatably reproduced, this is a bug in\n" + " bzip2, and I would very much like to hear about it. Please\n" + " let me know, and, ideally, save a copy of the file causing the\n" + " problem -- without which I will be unable to investigate it.\n" + "\n" + ); + } + + exit(3); +} +#endif + + +/*---------------------------------------------------*/ +static +int bz_config_ok ( void ) +{ + if (sizeof(int) != 4) return 0; + if (sizeof(short) != 2) return 0; + if (sizeof(char) != 1) return 0; + return 1; +} + + +/*---------------------------------------------------*/ +static +void* default_bzalloc ( void* opaque, Int32 items, Int32 size ) +{ + void* v = malloc ( items * size ); + return v; +} + +static +void default_bzfree ( void* opaque, void* addr ) +{ + if (addr != NULL) free ( addr ); +} + + +/*---------------------------------------------------*/ +static +void prepare_new_block ( EState* s ) +{ + Int32 i; + s->nblock = 0; + s->numZ = 0; + s->state_out_pos = 0; + BZ_INITIALISE_CRC ( s->blockCRC ); + for (i = 0; i < 256; i++) s->inUse[i] = False; + s->blockNo++; +} + + +/*---------------------------------------------------*/ +static +void init_RL ( EState* s ) +{ + s->state_in_ch = 256; + s->state_in_len = 0; +} + + +static +Bool isempty_RL ( EState* s ) +{ + if (s->state_in_ch < 256 && s->state_in_len > 0) + return False; else + return True; +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzCompressInit) + ( bz_stream* strm, + int blockSize100k, + int verbosity, + int workFactor ) +{ + Int32 n; + EState* s; + + if (!bz_config_ok()) return BZ_CONFIG_ERROR; + + if (strm == NULL || + blockSize100k < 1 || blockSize100k > 9 || + workFactor < 0 || workFactor > 250) + return BZ_PARAM_ERROR; + + if (workFactor == 0) workFactor = 30; + if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc; + if (strm->bzfree == NULL) strm->bzfree = default_bzfree; + + s = BZALLOC( sizeof(EState) ); + if (s == NULL) return BZ_MEM_ERROR; + s->strm = strm; + + s->arr1 = NULL; + s->arr2 = NULL; + s->ftab = NULL; + + n = 100000 * blockSize100k; + s->arr1 = BZALLOC( n * sizeof(UInt32) ); + s->arr2 = BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) ); + s->ftab = BZALLOC( 65537 * sizeof(UInt32) ); + + if (s->arr1 == NULL || s->arr2 == NULL || s->ftab == NULL) { + if (s->arr1 != NULL) BZFREE(s->arr1); + if (s->arr2 != NULL) BZFREE(s->arr2); + if (s->ftab != NULL) BZFREE(s->ftab); + if (s != NULL) BZFREE(s); + return BZ_MEM_ERROR; + } + + s->blockNo = 0; + s->state = BZ_S_INPUT; + s->mode = BZ_M_RUNNING; + s->combinedCRC = 0; + s->blockSize100k = blockSize100k; + s->nblockMAX = 100000 * blockSize100k - 19; + s->verbosity = verbosity; + s->workFactor = workFactor; + + s->block = (UChar*)s->arr2; + s->mtfv = (UInt16*)s->arr1; + s->zbits = NULL; + s->ptr = (UInt32*)s->arr1; + + strm->state = s; + strm->total_in_lo32 = 0; + strm->total_in_hi32 = 0; + strm->total_out_lo32 = 0; + strm->total_out_hi32 = 0; + init_RL ( s ); + prepare_new_block ( s ); + return BZ_OK; +} + + +/*---------------------------------------------------*/ +static +void add_pair_to_block ( EState* s ) +{ + Int32 i; + UChar ch = (UChar)(s->state_in_ch); + for (i = 0; i < s->state_in_len; i++) { + BZ_UPDATE_CRC( s->blockCRC, ch ); + } + s->inUse[s->state_in_ch] = True; + switch (s->state_in_len) { + case 1: + s->block[s->nblock] = (UChar)ch; s->nblock++; + break; + case 2: + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + break; + case 3: + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + break; + default: + s->inUse[s->state_in_len-4] = True; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = ((UChar)(s->state_in_len-4)); + s->nblock++; + break; + } +} + + +/*---------------------------------------------------*/ +static +void flush_RL ( EState* s ) +{ + if (s->state_in_ch < 256) add_pair_to_block ( s ); + init_RL ( s ); +} + + +/*---------------------------------------------------*/ +#define ADD_CHAR_TO_BLOCK(zs,zchh0) \ +{ \ + UInt32 zchh = (UInt32)(zchh0); \ + /*-- fast track the common case --*/ \ + if (zchh != zs->state_in_ch && \ + zs->state_in_len == 1) { \ + UChar ch = (UChar)(zs->state_in_ch); \ + BZ_UPDATE_CRC( zs->blockCRC, ch ); \ + zs->inUse[zs->state_in_ch] = True; \ + zs->block[zs->nblock] = (UChar)ch; \ + zs->nblock++; \ + zs->state_in_ch = zchh; \ + } \ + else \ + /*-- general, uncommon cases --*/ \ + if (zchh != zs->state_in_ch || \ + zs->state_in_len == 255) { \ + if (zs->state_in_ch < 256) \ + add_pair_to_block ( zs ); \ + zs->state_in_ch = zchh; \ + zs->state_in_len = 1; \ + } else { \ + zs->state_in_len++; \ + } \ +} + + +/*---------------------------------------------------*/ +static +Bool copy_input_until_stop ( EState* s ) +{ + Bool progress_in = False; + + if (s->mode == BZ_M_RUNNING) { + + /*-- fast track the common case --*/ + while (True) { + /*-- block full? --*/ + if (s->nblock >= s->nblockMAX) break; + /*-- no input? --*/ + if (s->strm->avail_in == 0) break; + progress_in = True; + ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ); + s->strm->next_in++; + s->strm->avail_in--; + s->strm->total_in_lo32++; + if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; + } + + } else { + + /*-- general, uncommon case --*/ + while (True) { + /*-- block full? --*/ + if (s->nblock >= s->nblockMAX) break; + /*-- no input? --*/ + if (s->strm->avail_in == 0) break; + /*-- flush/finish end? --*/ + if (s->avail_in_expect == 0) break; + progress_in = True; + ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ); + s->strm->next_in++; + s->strm->avail_in--; + s->strm->total_in_lo32++; + if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; + s->avail_in_expect--; + } + } + return progress_in; +} + + +/*---------------------------------------------------*/ +static +Bool copy_output_until_stop ( EState* s ) +{ + Bool progress_out = False; + + while (True) { + + /*-- no output space? --*/ + if (s->strm->avail_out == 0) break; + + /*-- block done? --*/ + if (s->state_out_pos >= s->numZ) break; + + progress_out = True; + *(s->strm->next_out) = s->zbits[s->state_out_pos]; + s->state_out_pos++; + s->strm->avail_out--; + s->strm->next_out++; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + return progress_out; +} + + +/*---------------------------------------------------*/ +static +Bool handle_compress ( bz_stream* strm ) +{ + Bool progress_in = False; + Bool progress_out = False; + EState* s = strm->state; + + while (True) { + + if (s->state == BZ_S_OUTPUT) { + progress_out |= copy_output_until_stop ( s ); + if (s->state_out_pos < s->numZ) break; + if (s->mode == BZ_M_FINISHING && + s->avail_in_expect == 0 && + isempty_RL(s)) break; + prepare_new_block ( s ); + s->state = BZ_S_INPUT; + if (s->mode == BZ_M_FLUSHING && + s->avail_in_expect == 0 && + isempty_RL(s)) break; + } + + if (s->state == BZ_S_INPUT) { + progress_in |= copy_input_until_stop ( s ); + if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) { + flush_RL ( s ); + BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) ); + s->state = BZ_S_OUTPUT; + } + else + if (s->nblock >= s->nblockMAX) { + BZ2_compressBlock ( s, False ); + s->state = BZ_S_OUTPUT; + } + else + if (s->strm->avail_in == 0) { + break; + } + } + + } + + return progress_in || progress_out; +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action ) +{ + Bool progress; + EState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + preswitch: + switch (s->mode) { + + case BZ_M_IDLE: + return BZ_SEQUENCE_ERROR; + + case BZ_M_RUNNING: + if (action == BZ_RUN) { + progress = handle_compress ( strm ); + return progress ? BZ_RUN_OK : BZ_PARAM_ERROR; + } + else + if (action == BZ_FLUSH) { + s->avail_in_expect = strm->avail_in; + s->mode = BZ_M_FLUSHING; + goto preswitch; + } + else + if (action == BZ_FINISH) { + s->avail_in_expect = strm->avail_in; + s->mode = BZ_M_FINISHING; + goto preswitch; + } + else + return BZ_PARAM_ERROR; + + case BZ_M_FLUSHING: + if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR; + if (s->avail_in_expect != s->strm->avail_in) + return BZ_SEQUENCE_ERROR; + progress = handle_compress ( strm ); + if (s->avail_in_expect > 0 || !isempty_RL(s) || + s->state_out_pos < s->numZ) return BZ_FLUSH_OK; + s->mode = BZ_M_RUNNING; + return BZ_RUN_OK; + + case BZ_M_FINISHING: + if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR; + if (s->avail_in_expect != s->strm->avail_in) + return BZ_SEQUENCE_ERROR; + progress = handle_compress ( strm ); + if (!progress) return BZ_SEQUENCE_ERROR; + if (s->avail_in_expect > 0 || !isempty_RL(s) || + s->state_out_pos < s->numZ) return BZ_FINISH_OK; + s->mode = BZ_M_IDLE; + return BZ_STREAM_END; + } + return BZ_OK; /*--not reached--*/ +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzCompressEnd) ( bz_stream *strm ) +{ + EState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + if (s->arr1 != NULL) BZFREE(s->arr1); + if (s->arr2 != NULL) BZFREE(s->arr2); + if (s->ftab != NULL) BZFREE(s->ftab); + BZFREE(strm->state); + + strm->state = NULL; + + return BZ_OK; +} + + +/*---------------------------------------------------*/ +/*--- Decompression stuff ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzDecompressInit) + ( bz_stream* strm, + int verbosity, + int small ) +{ + DState* s; + + if (!bz_config_ok()) return BZ_CONFIG_ERROR; + + if (strm == NULL) return BZ_PARAM_ERROR; + if (small != 0 && small != 1) return BZ_PARAM_ERROR; + if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR; + + if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc; + if (strm->bzfree == NULL) strm->bzfree = default_bzfree; + + s = BZALLOC( sizeof(DState) ); + if (s == NULL) return BZ_MEM_ERROR; + s->strm = strm; + strm->state = s; + s->state = BZ_X_MAGIC_1; + s->bsLive = 0; + s->bsBuff = 0; + s->calculatedCombinedCRC = 0; + strm->total_in_lo32 = 0; + strm->total_in_hi32 = 0; + strm->total_out_lo32 = 0; + strm->total_out_hi32 = 0; + s->smallDecompress = (Bool)small; + s->ll4 = NULL; + s->ll16 = NULL; + s->tt = NULL; + s->currBlockNo = 0; + s->verbosity = verbosity; + + return BZ_OK; +} + + +/*---------------------------------------------------*/ +/* Return True iff data corruption is discovered. + Returns False if there is no problem. +*/ +static +Bool unRLE_obuf_to_output_FAST ( DState* s ) +{ + UChar k1; + + if (s->blockRandomised) { + + while (True) { + /* try to finish existing run */ + while (True) { + if (s->strm->avail_out == 0) return False; + if (s->state_out_len == 0) break; + *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; + BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) return False; + + /* Only caused by corrupt data stream? */ + if (s->nblock_used > s->save_nblock+1) + return True; + + s->state_out_len = 1; + s->state_out_ch = s->k0; + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 2; + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 3; + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + s->state_out_len = ((Int32)k1) + 4; + BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK; + s->k0 ^= BZ_RAND_MASK; s->nblock_used++; + } + + } else { + + /* restore */ + UInt32 c_calculatedBlockCRC = s->calculatedBlockCRC; + UChar c_state_out_ch = s->state_out_ch; + Int32 c_state_out_len = s->state_out_len; + Int32 c_nblock_used = s->nblock_used; + Int32 c_k0 = s->k0; + UInt32* c_tt = s->tt; + UInt32 c_tPos = s->tPos; + char* cs_next_out = s->strm->next_out; + unsigned int cs_avail_out = s->strm->avail_out; + Int32 ro_blockSize100k = s->blockSize100k; + /* end restore */ + + UInt32 avail_out_INIT = cs_avail_out; + Int32 s_save_nblockPP = s->save_nblock+1; + unsigned int total_out_lo32_old; + + while (True) { + + /* try to finish existing run */ + if (c_state_out_len > 0) { + while (True) { + if (cs_avail_out == 0) goto return_notr; + if (c_state_out_len == 1) break; + *( (UChar*)(cs_next_out) ) = c_state_out_ch; + BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); + c_state_out_len--; + cs_next_out++; + cs_avail_out--; + } + s_state_out_len_eq_one: + { + if (cs_avail_out == 0) { + c_state_out_len = 1; goto return_notr; + }; + *( (UChar*)(cs_next_out) ) = c_state_out_ch; + BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); + cs_next_out++; + cs_avail_out--; + } + } + /* Only caused by corrupt data stream? */ + if (c_nblock_used > s_save_nblockPP) + return True; + + /* can a new run be started? */ + if (c_nblock_used == s_save_nblockPP) { + c_state_out_len = 0; goto return_notr; + }; + c_state_out_ch = c_k0; + BZ_GET_FAST_C(k1); c_nblock_used++; + if (k1 != c_k0) { + c_k0 = k1; goto s_state_out_len_eq_one; + }; + if (c_nblock_used == s_save_nblockPP) + goto s_state_out_len_eq_one; + + c_state_out_len = 2; + BZ_GET_FAST_C(k1); c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) continue; + if (k1 != c_k0) { c_k0 = k1; continue; }; + + c_state_out_len = 3; + BZ_GET_FAST_C(k1); c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) continue; + if (k1 != c_k0) { c_k0 = k1; continue; }; + + BZ_GET_FAST_C(k1); c_nblock_used++; + c_state_out_len = ((Int32)k1) + 4; + BZ_GET_FAST_C(c_k0); c_nblock_used++; + } + + return_notr: + total_out_lo32_old = s->strm->total_out_lo32; + s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out); + if (s->strm->total_out_lo32 < total_out_lo32_old) + s->strm->total_out_hi32++; + + /* save */ + s->calculatedBlockCRC = c_calculatedBlockCRC; + s->state_out_ch = c_state_out_ch; + s->state_out_len = c_state_out_len; + s->nblock_used = c_nblock_used; + s->k0 = c_k0; + s->tt = c_tt; + s->tPos = c_tPos; + s->strm->next_out = cs_next_out; + s->strm->avail_out = cs_avail_out; + /* end save */ + } + return False; +} + + + +/*---------------------------------------------------*/ +__inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab ) +{ + Int32 nb, na, mid; + nb = 0; + na = 256; + do { + mid = (nb + na) >> 1; + if (indx >= cftab[mid]) nb = mid; else na = mid; + } + while (na - nb != 1); + return nb; +} + + +/*---------------------------------------------------*/ +/* Return True iff data corruption is discovered. + Returns False if there is no problem. +*/ +static +Bool unRLE_obuf_to_output_SMALL ( DState* s ) +{ + UChar k1; + + if (s->blockRandomised) { + + while (True) { + /* try to finish existing run */ + while (True) { + if (s->strm->avail_out == 0) return False; + if (s->state_out_len == 0) break; + *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; + BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) return False; + + /* Only caused by corrupt data stream? */ + if (s->nblock_used > s->save_nblock+1) + return True; + + s->state_out_len = 1; + s->state_out_ch = s->k0; + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 2; + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 3; + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + s->state_out_len = ((Int32)k1) + 4; + BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK; + s->k0 ^= BZ_RAND_MASK; s->nblock_used++; + } + + } else { + + while (True) { + /* try to finish existing run */ + while (True) { + if (s->strm->avail_out == 0) return False; + if (s->state_out_len == 0) break; + *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; + BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) return False; + + /* Only caused by corrupt data stream? */ + if (s->nblock_used > s->save_nblock+1) + return True; + + s->state_out_len = 1; + s->state_out_ch = s->k0; + BZ_GET_SMALL(k1); s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 2; + BZ_GET_SMALL(k1); s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 3; + BZ_GET_SMALL(k1); s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + BZ_GET_SMALL(k1); s->nblock_used++; + s->state_out_len = ((Int32)k1) + 4; + BZ_GET_SMALL(s->k0); s->nblock_used++; + } + + } +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzDecompress) ( bz_stream *strm ) +{ + Bool corrupt; + DState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + while (True) { + if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR; + if (s->state == BZ_X_OUTPUT) { + if (s->smallDecompress) + corrupt = unRLE_obuf_to_output_SMALL ( s ); else + corrupt = unRLE_obuf_to_output_FAST ( s ); + if (corrupt) return BZ_DATA_ERROR; + if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { + BZ_FINALISE_CRC ( s->calculatedBlockCRC ); + if (s->verbosity >= 3) + VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC, + s->calculatedBlockCRC ); + if (s->verbosity >= 2) VPrintf0 ( "]" ); + if (s->calculatedBlockCRC != s->storedBlockCRC) + return BZ_DATA_ERROR; + s->calculatedCombinedCRC + = (s->calculatedCombinedCRC << 1) | + (s->calculatedCombinedCRC >> 31); + s->calculatedCombinedCRC ^= s->calculatedBlockCRC; + s->state = BZ_X_BLKHDR_1; + } else { + return BZ_OK; + } + } + if (s->state >= BZ_X_MAGIC_1) { + Int32 r = BZ2_decompress ( s ); + if (r == BZ_STREAM_END) { + if (s->verbosity >= 3) + VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x", + s->storedCombinedCRC, s->calculatedCombinedCRC ); + if (s->calculatedCombinedCRC != s->storedCombinedCRC) + return BZ_DATA_ERROR; + return r; + } + if (s->state != BZ_X_OUTPUT) return r; + } + } + + AssertH ( 0, 6001 ); + + return 0; /*NOTREACHED*/ +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm ) +{ + DState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + if (s->tt != NULL) BZFREE(s->tt); + if (s->ll16 != NULL) BZFREE(s->ll16); + if (s->ll4 != NULL) BZFREE(s->ll4); + + BZFREE(strm->state); + strm->state = NULL; + + return BZ_OK; +} + + +#ifndef BZ_NO_STDIO +/*---------------------------------------------------*/ +/*--- File I/O stuff ---*/ +/*---------------------------------------------------*/ + +#define BZ_SETERR(eee) \ +{ \ + if (bzerror != NULL) *bzerror = eee; \ + if (bzf != NULL) bzf->lastErr = eee; \ +} + +typedef + struct { + FILE* handle; + Char buf[BZ_MAX_UNUSED]; + Int32 bufN; + Bool writing; + bz_stream strm; + Int32 lastErr; + Bool initialisedOk; + } + bzFile; + + +/*---------------------------------------------*/ +static Bool myfeof ( FILE* f ) +{ + Int32 c = fgetc ( f ); + if (c == EOF) return True; + ungetc ( c, f ); + return False; +} + + +/*---------------------------------------------------*/ +BZFILE* BZ_API(BZ2_bzWriteOpen) + ( int* bzerror, + FILE* f, + int blockSize100k, + int verbosity, + int workFactor ) +{ + Int32 ret; + bzFile* bzf = NULL; + + BZ_SETERR(BZ_OK); + + if (f == NULL || + (blockSize100k < 1 || blockSize100k > 9) || + (workFactor < 0 || workFactor > 250) || + (verbosity < 0 || verbosity > 4)) + { BZ_SETERR(BZ_PARAM_ERROR); return NULL; }; + + if (ferror(f)) + { BZ_SETERR(BZ_IO_ERROR); return NULL; }; + + bzf = malloc ( sizeof(bzFile) ); + if (bzf == NULL) + { BZ_SETERR(BZ_MEM_ERROR); return NULL; }; + + BZ_SETERR(BZ_OK); + bzf->initialisedOk = False; + bzf->bufN = 0; + bzf->handle = f; + bzf->writing = True; + bzf->strm.bzalloc = NULL; + bzf->strm.bzfree = NULL; + bzf->strm.opaque = NULL; + + if (workFactor == 0) workFactor = 30; + ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k, + verbosity, workFactor ); + if (ret != BZ_OK) + { BZ_SETERR(ret); free(bzf); return NULL; }; + + bzf->strm.avail_in = 0; + bzf->initialisedOk = True; + return bzf; +} + + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzWrite) + ( int* bzerror, + BZFILE* b, + void* buf, + int len ) +{ + Int32 n, n2, ret; + bzFile* bzf = (bzFile*)b; + + BZ_SETERR(BZ_OK); + if (bzf == NULL || buf == NULL || len < 0) + { BZ_SETERR(BZ_PARAM_ERROR); return; }; + if (!(bzf->writing)) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + + if (len == 0) + { BZ_SETERR(BZ_OK); return; }; + + bzf->strm.avail_in = len; + bzf->strm.next_in = buf; + + while (True) { + bzf->strm.avail_out = BZ_MAX_UNUSED; + bzf->strm.next_out = bzf->buf; + ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN ); + if (ret != BZ_RUN_OK) + { BZ_SETERR(ret); return; }; + + if (bzf->strm.avail_out < BZ_MAX_UNUSED) { + n = BZ_MAX_UNUSED - bzf->strm.avail_out; + n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), + n, bzf->handle ); + if (n != n2 || ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + } + + if (bzf->strm.avail_in == 0) + { BZ_SETERR(BZ_OK); return; }; + } +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzWriteClose) + ( int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in, + unsigned int* nbytes_out ) +{ + BZ2_bzWriteClose64 ( bzerror, b, abandon, + nbytes_in, NULL, nbytes_out, NULL ); +} + + +void BZ_API(BZ2_bzWriteClose64) + ( int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in_lo32, + unsigned int* nbytes_in_hi32, + unsigned int* nbytes_out_lo32, + unsigned int* nbytes_out_hi32 ) +{ + Int32 n, n2, ret; + bzFile* bzf = (bzFile*)b; + + if (bzf == NULL) + { BZ_SETERR(BZ_OK); return; }; + if (!(bzf->writing)) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + + if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0; + if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0; + if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0; + if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0; + + if ((!abandon) && bzf->lastErr == BZ_OK) { + while (True) { + bzf->strm.avail_out = BZ_MAX_UNUSED; + bzf->strm.next_out = bzf->buf; + ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH ); + if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END) + { BZ_SETERR(ret); return; }; + + if (bzf->strm.avail_out < BZ_MAX_UNUSED) { + n = BZ_MAX_UNUSED - bzf->strm.avail_out; + n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), + n, bzf->handle ); + if (n != n2 || ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + } + + if (ret == BZ_STREAM_END) break; + } + } + + if ( !abandon && !ferror ( bzf->handle ) ) { + fflush ( bzf->handle ); + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + } + + if (nbytes_in_lo32 != NULL) + *nbytes_in_lo32 = bzf->strm.total_in_lo32; + if (nbytes_in_hi32 != NULL) + *nbytes_in_hi32 = bzf->strm.total_in_hi32; + if (nbytes_out_lo32 != NULL) + *nbytes_out_lo32 = bzf->strm.total_out_lo32; + if (nbytes_out_hi32 != NULL) + *nbytes_out_hi32 = bzf->strm.total_out_hi32; + + BZ_SETERR(BZ_OK); + BZ2_bzCompressEnd ( &(bzf->strm) ); + free ( bzf ); +} + + +/*---------------------------------------------------*/ +BZFILE* BZ_API(BZ2_bzReadOpen) + ( int* bzerror, + FILE* f, + int verbosity, + int small, + void* unused, + int nUnused ) +{ + bzFile* bzf = NULL; + int ret; + + BZ_SETERR(BZ_OK); + + if (f == NULL || + (small != 0 && small != 1) || + (verbosity < 0 || verbosity > 4) || + (unused == NULL && nUnused != 0) || + (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED))) + { BZ_SETERR(BZ_PARAM_ERROR); return NULL; }; + + if (ferror(f)) + { BZ_SETERR(BZ_IO_ERROR); return NULL; }; + + bzf = malloc ( sizeof(bzFile) ); + if (bzf == NULL) + { BZ_SETERR(BZ_MEM_ERROR); return NULL; }; + + BZ_SETERR(BZ_OK); + + bzf->initialisedOk = False; + bzf->handle = f; + bzf->bufN = 0; + bzf->writing = False; + bzf->strm.bzalloc = NULL; + bzf->strm.bzfree = NULL; + bzf->strm.opaque = NULL; + + while (nUnused > 0) { + bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++; + unused = ((void*)( 1 + ((UChar*)(unused)) )); + nUnused--; + } + + ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small ); + if (ret != BZ_OK) + { BZ_SETERR(ret); free(bzf); return NULL; }; + + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + + bzf->initialisedOk = True; + return bzf; +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b ) +{ + bzFile* bzf = (bzFile*)b; + + BZ_SETERR(BZ_OK); + if (bzf == NULL) + { BZ_SETERR(BZ_OK); return; }; + + if (bzf->writing) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + + if (bzf->initialisedOk) + (void)BZ2_bzDecompressEnd ( &(bzf->strm) ); + free ( bzf ); +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzRead) + ( int* bzerror, + BZFILE* b, + void* buf, + int len ) +{ + Int32 n, ret; + bzFile* bzf = (bzFile*)b; + + BZ_SETERR(BZ_OK); + + if (bzf == NULL || buf == NULL || len < 0) + { BZ_SETERR(BZ_PARAM_ERROR); return 0; }; + + if (bzf->writing) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; }; + + if (len == 0) + { BZ_SETERR(BZ_OK); return 0; }; + + bzf->strm.avail_out = len; + bzf->strm.next_out = buf; + + while (True) { + + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return 0; }; + + if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) { + n = fread ( bzf->buf, sizeof(UChar), + BZ_MAX_UNUSED, bzf->handle ); + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return 0; }; + bzf->bufN = n; + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + } + + ret = BZ2_bzDecompress ( &(bzf->strm) ); + + if (ret != BZ_OK && ret != BZ_STREAM_END) + { BZ_SETERR(ret); return 0; }; + + if (ret == BZ_OK && myfeof(bzf->handle) && + bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0) + { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; }; + + if (ret == BZ_STREAM_END) + { BZ_SETERR(BZ_STREAM_END); + return len - bzf->strm.avail_out; }; + if (bzf->strm.avail_out == 0) + { BZ_SETERR(BZ_OK); return len; }; + + } + + return 0; /*not reached*/ +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzReadGetUnused) + ( int* bzerror, + BZFILE* b, + void** unused, + int* nUnused ) +{ + bzFile* bzf = (bzFile*)b; + if (bzf == NULL) + { BZ_SETERR(BZ_PARAM_ERROR); return; }; + if (bzf->lastErr != BZ_STREAM_END) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + if (unused == NULL || nUnused == NULL) + { BZ_SETERR(BZ_PARAM_ERROR); return; }; + + BZ_SETERR(BZ_OK); + *nUnused = bzf->strm.avail_in; + *unused = bzf->strm.next_in; +} +#endif + + +/*---------------------------------------------------*/ +/*--- Misc convenience stuff ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzBuffToBuffCompress) + ( char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int blockSize100k, + int verbosity, + int workFactor ) +{ + bz_stream strm; + int ret; + + if (dest == NULL || destLen == NULL || + source == NULL || + blockSize100k < 1 || blockSize100k > 9 || + verbosity < 0 || verbosity > 4 || + workFactor < 0 || workFactor > 250) + return BZ_PARAM_ERROR; + + if (workFactor == 0) workFactor = 30; + strm.bzalloc = NULL; + strm.bzfree = NULL; + strm.opaque = NULL; + ret = BZ2_bzCompressInit ( &strm, blockSize100k, + verbosity, workFactor ); + if (ret != BZ_OK) return ret; + + strm.next_in = source; + strm.next_out = dest; + strm.avail_in = sourceLen; + strm.avail_out = *destLen; + + ret = BZ2_bzCompress ( &strm, BZ_FINISH ); + if (ret == BZ_FINISH_OK) goto output_overflow; + if (ret != BZ_STREAM_END) goto errhandler; + + /* normal termination */ + *destLen -= strm.avail_out; + BZ2_bzCompressEnd ( &strm ); + return BZ_OK; + + output_overflow: + BZ2_bzCompressEnd ( &strm ); + return BZ_OUTBUFF_FULL; + + errhandler: + BZ2_bzCompressEnd ( &strm ); + return ret; +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzBuffToBuffDecompress) + ( char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int small, + int verbosity ) +{ + bz_stream strm; + int ret; + + if (dest == NULL || destLen == NULL || + source == NULL || + (small != 0 && small != 1) || + verbosity < 0 || verbosity > 4) + return BZ_PARAM_ERROR; + + strm.bzalloc = NULL; + strm.bzfree = NULL; + strm.opaque = NULL; + ret = BZ2_bzDecompressInit ( &strm, verbosity, small ); + if (ret != BZ_OK) return ret; + + strm.next_in = source; + strm.next_out = dest; + strm.avail_in = sourceLen; + strm.avail_out = *destLen; + + ret = BZ2_bzDecompress ( &strm ); + if (ret == BZ_OK) goto output_overflow_or_eof; + if (ret != BZ_STREAM_END) goto errhandler; + + /* normal termination */ + *destLen -= strm.avail_out; + BZ2_bzDecompressEnd ( &strm ); + return BZ_OK; + + output_overflow_or_eof: + if (strm.avail_out > 0) { + BZ2_bzDecompressEnd ( &strm ); + return BZ_UNEXPECTED_EOF; + } else { + BZ2_bzDecompressEnd ( &strm ); + return BZ_OUTBUFF_FULL; + }; + + errhandler: + BZ2_bzDecompressEnd ( &strm ); + return ret; +} + + +/*---------------------------------------------------*/ +/*-- + Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp) + to support better zlib compatibility. + This code is not _officially_ part of libbzip2 (yet); + I haven't tested it, documented it, or considered the + threading-safeness of it. + If this code breaks, please contact both Yoshioka and me. +--*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +/*-- + return version like "0.9.5d, 4-Sept-1999". +--*/ +const char * BZ_API(BZ2_bzlibVersion)(void) +{ + return BZ_VERSION; +} + + +#ifndef BZ_NO_STDIO +/*---------------------------------------------------*/ + +#if defined(_WIN32) || defined(OS2) || defined(MSDOS) +# include <fcntl.h> +# include <io.h> +# define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY) +#else +# define SET_BINARY_MODE(file) +#endif +static +BZFILE * bzopen_or_bzdopen + ( const char *path, /* no use when bzdopen */ + int fd, /* no use when bzdopen */ + const char *mode, + int open_mode) /* bzopen: 0, bzdopen:1 */ +{ + int bzerr; + char unused[BZ_MAX_UNUSED]; + int blockSize100k = 9; + int writing = 0; + char mode2[10] = ""; + FILE *fp = NULL; + BZFILE *bzfp = NULL; + int verbosity = 0; + int workFactor = 30; + int smallMode = 0; + int nUnused = 0; + + if (mode == NULL) return NULL; + while (*mode) { + switch (*mode) { + case 'r': + writing = 0; break; + case 'w': + writing = 1; break; + case 's': + smallMode = 1; break; + default: + if (isdigit((int)(*mode))) { + blockSize100k = *mode-BZ_HDR_0; + } + } + mode++; + } + strcat(mode2, writing ? "w" : "r" ); + strcat(mode2,"b"); /* binary mode */ + + if (open_mode==0) { + if (path==NULL || strcmp(path,"")==0) { + fp = (writing ? stdout : stdin); + SET_BINARY_MODE(fp); + } else { + fp = fopen(path,mode2); + } + } else { +#ifdef BZ_STRICT_ANSI + fp = NULL; +#else + fp = fdopen(fd,mode2); +#endif + } + if (fp == NULL) return NULL; + + if (writing) { + /* Guard against total chaos and anarchy -- JRS */ + if (blockSize100k < 1) blockSize100k = 1; + if (blockSize100k > 9) blockSize100k = 9; + bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k, + verbosity,workFactor); + } else { + bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode, + unused,nUnused); + } + if (bzfp == NULL) { + if (fp != stdin && fp != stdout) fclose(fp); + return NULL; + } + return bzfp; +} + + +/*---------------------------------------------------*/ +/*-- + open file for read or write. + ex) bzopen("file","w9") + case path="" or NULL => use stdin or stdout. +--*/ +BZFILE * BZ_API(BZ2_bzopen) + ( const char *path, + const char *mode ) +{ + return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0); +} + + +/*---------------------------------------------------*/ +BZFILE * BZ_API(BZ2_bzdopen) + ( int fd, + const char *mode ) +{ + return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1); +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len ) +{ + int bzerr, nread; + if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0; + nread = BZ2_bzRead(&bzerr,b,buf,len); + if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) { + return nread; + } else { + return -1; + } +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len ) +{ + int bzerr; + + BZ2_bzWrite(&bzerr,b,buf,len); + if(bzerr == BZ_OK){ + return len; + }else{ + return -1; + } +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzflush) (BZFILE *b) +{ + /* do nothing now... */ + return 0; +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzclose) (BZFILE* b) +{ + int bzerr; + FILE *fp; + + if (b==NULL) {return;} + fp = ((bzFile *)b)->handle; + if(((bzFile*)b)->writing){ + BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL); + if(bzerr != BZ_OK){ + BZ2_bzWriteClose(NULL,b,1,NULL,NULL); + } + }else{ + BZ2_bzReadClose(&bzerr,b); + } + if(fp!=stdin && fp!=stdout){ + fclose(fp); + } +} + + +/*---------------------------------------------------*/ +/*-- + return last error code +--*/ +static const char *bzerrorstrings[] = { + "OK" + ,"SEQUENCE_ERROR" + ,"PARAM_ERROR" + ,"MEM_ERROR" + ,"DATA_ERROR" + ,"DATA_ERROR_MAGIC" + ,"IO_ERROR" + ,"UNEXPECTED_EOF" + ,"OUTBUFF_FULL" + ,"CONFIG_ERROR" + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ +}; + + +const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum) +{ + int err = ((bzFile *)b)->lastErr; + + if(err>0) err = 0; + *errnum = err; + return bzerrorstrings[err*-1]; +} +#endif + + +/*-------------------------------------------------------------*/ +/*--- end bzlib.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/bzlib.h b/dep/src/bzip2/bzlib.h new file mode 100644 index 00000000000..c5b75d6d8ff --- /dev/null +++ b/dep/src/bzip2/bzlib.h @@ -0,0 +1,282 @@ + +/*-------------------------------------------------------------*/ +/*--- Public header file for the library. ---*/ +/*--- bzlib.h ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#ifndef _BZLIB_H +#define _BZLIB_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define BZ_RUN 0 +#define BZ_FLUSH 1 +#define BZ_FINISH 2 + +#define BZ_OK 0 +#define BZ_RUN_OK 1 +#define BZ_FLUSH_OK 2 +#define BZ_FINISH_OK 3 +#define BZ_STREAM_END 4 +#define BZ_SEQUENCE_ERROR (-1) +#define BZ_PARAM_ERROR (-2) +#define BZ_MEM_ERROR (-3) +#define BZ_DATA_ERROR (-4) +#define BZ_DATA_ERROR_MAGIC (-5) +#define BZ_IO_ERROR (-6) +#define BZ_UNEXPECTED_EOF (-7) +#define BZ_OUTBUFF_FULL (-8) +#define BZ_CONFIG_ERROR (-9) + +typedef + struct { + char *next_in; + unsigned int avail_in; + unsigned int total_in_lo32; + unsigned int total_in_hi32; + + char *next_out; + unsigned int avail_out; + unsigned int total_out_lo32; + unsigned int total_out_hi32; + + void *state; + + void *(*bzalloc)(void *,int,int); + void (*bzfree)(void *,void *); + void *opaque; + } + bz_stream; + + +#ifndef BZ_IMPORT +#define BZ_EXPORT +#endif + +#ifndef BZ_NO_STDIO +/* Need a definitition for FILE */ +#include <stdio.h> +#endif + +#ifdef _WIN32 +# include <windows.h> +# ifdef small + /* windows.h define small to char */ +# undef small +# endif +# ifdef BZ_EXPORT +# define BZ_API(func) WINAPI func +# define BZ_EXTERN extern +# else + /* import windows dll dynamically */ +# define BZ_API(func) (WINAPI * func) +# define BZ_EXTERN +# endif +#else +# define BZ_API(func) func +# define BZ_EXTERN extern +#endif + + +/*-- Core (low-level) library functions --*/ + +BZ_EXTERN int BZ_API(BZ2_bzCompressInit) ( + bz_stream* strm, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN int BZ_API(BZ2_bzCompress) ( + bz_stream* strm, + int action + ); + +BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) ( + bz_stream* strm + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) ( + bz_stream *strm, + int verbosity, + int small + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompress) ( + bz_stream* strm + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) ( + bz_stream *strm + ); + + + +/*-- High(er) level library functions --*/ + +#ifndef BZ_NO_STDIO +#define BZ_MAX_UNUSED 5000 + +typedef void BZFILE; + +BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) ( + int* bzerror, + FILE* f, + int verbosity, + int small, + void* unused, + int nUnused + ); + +BZ_EXTERN void BZ_API(BZ2_bzReadClose) ( + int* bzerror, + BZFILE* b + ); + +BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) ( + int* bzerror, + BZFILE* b, + void** unused, + int* nUnused + ); + +BZ_EXTERN int BZ_API(BZ2_bzRead) ( + int* bzerror, + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) ( + int* bzerror, + FILE* f, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN void BZ_API(BZ2_bzWrite) ( + int* bzerror, + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN void BZ_API(BZ2_bzWriteClose) ( + int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in, + unsigned int* nbytes_out + ); + +BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) ( + int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in_lo32, + unsigned int* nbytes_in_hi32, + unsigned int* nbytes_out_lo32, + unsigned int* nbytes_out_hi32 + ); +#endif + + +/*-- Utility functions --*/ + +BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) ( + char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) ( + char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int small, + int verbosity + ); + + +/*-- + Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp) + to support better zlib compatibility. + This code is not _officially_ part of libbzip2 (yet); + I haven't tested it, documented it, or considered the + threading-safeness of it. + If this code breaks, please contact both Yoshioka and me. +--*/ + +BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) ( + void + ); + +#ifndef BZ_NO_STDIO +BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) ( + const char *path, + const char *mode + ); + +BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) ( + int fd, + const char *mode + ); + +BZ_EXTERN int BZ_API(BZ2_bzread) ( + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN int BZ_API(BZ2_bzwrite) ( + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN int BZ_API(BZ2_bzflush) ( + BZFILE* b + ); + +BZ_EXTERN void BZ_API(BZ2_bzclose) ( + BZFILE* b + ); + +BZ_EXTERN const char * BZ_API(BZ2_bzerror) ( + BZFILE *b, + int *errnum + ); +#endif + +#ifdef __cplusplus +} +#endif + +#endif + +/*-------------------------------------------------------------*/ +/*--- end bzlib.h ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/bzlib_private.h b/dep/src/bzip2/bzlib_private.h new file mode 100644 index 00000000000..23427879b18 --- /dev/null +++ b/dep/src/bzip2/bzlib_private.h @@ -0,0 +1,509 @@ + +/*-------------------------------------------------------------*/ +/*--- Private header file for the library. ---*/ +/*--- bzlib_private.h ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#ifndef _BZLIB_PRIVATE_H +#define _BZLIB_PRIVATE_H + +#include <stdlib.h> + +#ifndef BZ_NO_STDIO +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#endif + +#include "bzlib.h" + + + +/*-- General stuff. --*/ + +#define BZ_VERSION "1.0.5, 10-Dec-2007" + +typedef char Char; +typedef unsigned char Bool; +typedef unsigned char UChar; +typedef int Int32; +typedef unsigned int UInt32; +typedef short Int16; +typedef unsigned short UInt16; + +#define True ((Bool)1) +#define False ((Bool)0) + +#ifndef __GNUC__ +#define __inline__ /* */ +#endif + +#ifndef BZ_NO_STDIO + +extern void BZ2_bz__AssertH__fail ( int errcode ); +#define AssertH(cond,errcode) \ + { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); } + +#if BZ_DEBUG +#define AssertD(cond,msg) \ + { if (!(cond)) { \ + fprintf ( stderr, \ + "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\ + exit(1); \ + }} +#else +#define AssertD(cond,msg) /* */ +#endif + +#define VPrintf0(zf) \ + fprintf(stderr,zf) +#define VPrintf1(zf,za1) \ + fprintf(stderr,zf,za1) +#define VPrintf2(zf,za1,za2) \ + fprintf(stderr,zf,za1,za2) +#define VPrintf3(zf,za1,za2,za3) \ + fprintf(stderr,zf,za1,za2,za3) +#define VPrintf4(zf,za1,za2,za3,za4) \ + fprintf(stderr,zf,za1,za2,za3,za4) +#define VPrintf5(zf,za1,za2,za3,za4,za5) \ + fprintf(stderr,zf,za1,za2,za3,za4,za5) + +#else + +extern void bz_internal_error ( int errcode ); +#define AssertH(cond,errcode) \ + { if (!(cond)) bz_internal_error ( errcode ); } +#define AssertD(cond,msg) do { } while (0) +#define VPrintf0(zf) do { } while (0) +#define VPrintf1(zf,za1) do { } while (0) +#define VPrintf2(zf,za1,za2) do { } while (0) +#define VPrintf3(zf,za1,za2,za3) do { } while (0) +#define VPrintf4(zf,za1,za2,za3,za4) do { } while (0) +#define VPrintf5(zf,za1,za2,za3,za4,za5) do { } while (0) + +#endif + + +#define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1) +#define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp)) + + +/*-- Header bytes. --*/ + +#define BZ_HDR_B 0x42 /* 'B' */ +#define BZ_HDR_Z 0x5a /* 'Z' */ +#define BZ_HDR_h 0x68 /* 'h' */ +#define BZ_HDR_0 0x30 /* '0' */ + +/*-- Constants for the back end. --*/ + +#define BZ_MAX_ALPHA_SIZE 258 +#define BZ_MAX_CODE_LEN 23 + +#define BZ_RUNA 0 +#define BZ_RUNB 1 + +#define BZ_N_GROUPS 6 +#define BZ_G_SIZE 50 +#define BZ_N_ITERS 4 + +#define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE)) + + + +/*-- Stuff for randomising repetitive blocks. --*/ + +extern Int32 BZ2_rNums[512]; + +#define BZ_RAND_DECLS \ + Int32 rNToGo; \ + Int32 rTPos \ + +#define BZ_RAND_INIT_MASK \ + s->rNToGo = 0; \ + s->rTPos = 0 \ + +#define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0) + +#define BZ_RAND_UPD_MASK \ + if (s->rNToGo == 0) { \ + s->rNToGo = BZ2_rNums[s->rTPos]; \ + s->rTPos++; \ + if (s->rTPos == 512) s->rTPos = 0; \ + } \ + s->rNToGo--; + + + +/*-- Stuff for doing CRCs. --*/ + +extern UInt32 BZ2_crc32Table[256]; + +#define BZ_INITIALISE_CRC(crcVar) \ +{ \ + crcVar = 0xffffffffL; \ +} + +#define BZ_FINALISE_CRC(crcVar) \ +{ \ + crcVar = ~(crcVar); \ +} + +#define BZ_UPDATE_CRC(crcVar,cha) \ +{ \ + crcVar = (crcVar << 8) ^ \ + BZ2_crc32Table[(crcVar >> 24) ^ \ + ((UChar)cha)]; \ +} + + + +/*-- States and modes for compression. --*/ + +#define BZ_M_IDLE 1 +#define BZ_M_RUNNING 2 +#define BZ_M_FLUSHING 3 +#define BZ_M_FINISHING 4 + +#define BZ_S_OUTPUT 1 +#define BZ_S_INPUT 2 + +#define BZ_N_RADIX 2 +#define BZ_N_QSORT 12 +#define BZ_N_SHELL 18 +#define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2) + + + + +/*-- Structure holding all the compression-side stuff. --*/ + +typedef + struct { + /* pointer back to the struct bz_stream */ + bz_stream* strm; + + /* mode this stream is in, and whether inputting */ + /* or outputting data */ + Int32 mode; + Int32 state; + + /* remembers avail_in when flush/finish requested */ + UInt32 avail_in_expect; + + /* for doing the block sorting */ + UInt32* arr1; + UInt32* arr2; + UInt32* ftab; + Int32 origPtr; + + /* aliases for arr1 and arr2 */ + UInt32* ptr; + UChar* block; + UInt16* mtfv; + UChar* zbits; + + /* for deciding when to use the fallback sorting algorithm */ + Int32 workFactor; + + /* run-length-encoding of the input */ + UInt32 state_in_ch; + Int32 state_in_len; + BZ_RAND_DECLS; + + /* input and output limits and current posns */ + Int32 nblock; + Int32 nblockMAX; + Int32 numZ; + Int32 state_out_pos; + + /* map of bytes used in block */ + Int32 nInUse; + Bool inUse[256]; + UChar unseqToSeq[256]; + + /* the buffer for bit stream creation */ + UInt32 bsBuff; + Int32 bsLive; + + /* block and combined CRCs */ + UInt32 blockCRC; + UInt32 combinedCRC; + + /* misc administratium */ + Int32 verbosity; + Int32 blockNo; + Int32 blockSize100k; + + /* stuff for coding the MTF values */ + Int32 nMTF; + Int32 mtfFreq [BZ_MAX_ALPHA_SIZE]; + UChar selector [BZ_MAX_SELECTORS]; + UChar selectorMtf[BZ_MAX_SELECTORS]; + + UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 rfreq [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + /* second dimension: only 3 needed; 4 makes index calculations faster */ + UInt32 len_pack[BZ_MAX_ALPHA_SIZE][4]; + + } + EState; + + + +/*-- externs for compression. --*/ + +extern void +BZ2_blockSort ( EState* ); + +extern void +BZ2_compressBlock ( EState*, Bool ); + +extern void +BZ2_bsInitWrite ( EState* ); + +extern void +BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 ); + +extern void +BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 ); + + + +/*-- states for decompression. --*/ + +#define BZ_X_IDLE 1 +#define BZ_X_OUTPUT 2 + +#define BZ_X_MAGIC_1 10 +#define BZ_X_MAGIC_2 11 +#define BZ_X_MAGIC_3 12 +#define BZ_X_MAGIC_4 13 +#define BZ_X_BLKHDR_1 14 +#define BZ_X_BLKHDR_2 15 +#define BZ_X_BLKHDR_3 16 +#define BZ_X_BLKHDR_4 17 +#define BZ_X_BLKHDR_5 18 +#define BZ_X_BLKHDR_6 19 +#define BZ_X_BCRC_1 20 +#define BZ_X_BCRC_2 21 +#define BZ_X_BCRC_3 22 +#define BZ_X_BCRC_4 23 +#define BZ_X_RANDBIT 24 +#define BZ_X_ORIGPTR_1 25 +#define BZ_X_ORIGPTR_2 26 +#define BZ_X_ORIGPTR_3 27 +#define BZ_X_MAPPING_1 28 +#define BZ_X_MAPPING_2 29 +#define BZ_X_SELECTOR_1 30 +#define BZ_X_SELECTOR_2 31 +#define BZ_X_SELECTOR_3 32 +#define BZ_X_CODING_1 33 +#define BZ_X_CODING_2 34 +#define BZ_X_CODING_3 35 +#define BZ_X_MTF_1 36 +#define BZ_X_MTF_2 37 +#define BZ_X_MTF_3 38 +#define BZ_X_MTF_4 39 +#define BZ_X_MTF_5 40 +#define BZ_X_MTF_6 41 +#define BZ_X_ENDHDR_2 42 +#define BZ_X_ENDHDR_3 43 +#define BZ_X_ENDHDR_4 44 +#define BZ_X_ENDHDR_5 45 +#define BZ_X_ENDHDR_6 46 +#define BZ_X_CCRC_1 47 +#define BZ_X_CCRC_2 48 +#define BZ_X_CCRC_3 49 +#define BZ_X_CCRC_4 50 + + + +/*-- Constants for the fast MTF decoder. --*/ + +#define MTFA_SIZE 4096 +#define MTFL_SIZE 16 + + + +/*-- Structure holding all the decompression-side stuff. --*/ + +typedef + struct { + /* pointer back to the struct bz_stream */ + bz_stream* strm; + + /* state indicator for this stream */ + Int32 state; + + /* for doing the final run-length decoding */ + UChar state_out_ch; + Int32 state_out_len; + Bool blockRandomised; + BZ_RAND_DECLS; + + /* the buffer for bit stream reading */ + UInt32 bsBuff; + Int32 bsLive; + + /* misc administratium */ + Int32 blockSize100k; + Bool smallDecompress; + Int32 currBlockNo; + Int32 verbosity; + + /* for undoing the Burrows-Wheeler transform */ + Int32 origPtr; + UInt32 tPos; + Int32 k0; + Int32 unzftab[256]; + Int32 nblock_used; + Int32 cftab[257]; + Int32 cftabCopy[257]; + + /* for undoing the Burrows-Wheeler transform (FAST) */ + UInt32 *tt; + + /* for undoing the Burrows-Wheeler transform (SMALL) */ + UInt16 *ll16; + UChar *ll4; + + /* stored and calculated CRCs */ + UInt32 storedBlockCRC; + UInt32 storedCombinedCRC; + UInt32 calculatedBlockCRC; + UInt32 calculatedCombinedCRC; + + /* map of bytes used in block */ + Int32 nInUse; + Bool inUse[256]; + Bool inUse16[16]; + UChar seqToUnseq[256]; + + /* for decoding the MTF values */ + UChar mtfa [MTFA_SIZE]; + Int32 mtfbase[256 / MTFL_SIZE]; + UChar selector [BZ_MAX_SELECTORS]; + UChar selectorMtf[BZ_MAX_SELECTORS]; + UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + + Int32 limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 minLens[BZ_N_GROUPS]; + + /* save area for scalars in the main decompress code */ + Int32 save_i; + Int32 save_j; + Int32 save_t; + Int32 save_alphaSize; + Int32 save_nGroups; + Int32 save_nSelectors; + Int32 save_EOB; + Int32 save_groupNo; + Int32 save_groupPos; + Int32 save_nextSym; + Int32 save_nblockMAX; + Int32 save_nblock; + Int32 save_es; + Int32 save_N; + Int32 save_curr; + Int32 save_zt; + Int32 save_zn; + Int32 save_zvec; + Int32 save_zj; + Int32 save_gSel; + Int32 save_gMinlen; + Int32* save_gLimit; + Int32* save_gBase; + Int32* save_gPerm; + + } + DState; + + + +/*-- Macros for decompression. --*/ + +#define BZ_GET_FAST(cccc) \ + /* c_tPos is unsigned, hence test < 0 is pointless. */ \ + if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \ + s->tPos = s->tt[s->tPos]; \ + cccc = (UChar)(s->tPos & 0xff); \ + s->tPos >>= 8; + +#define BZ_GET_FAST_C(cccc) \ + /* c_tPos is unsigned, hence test < 0 is pointless. */ \ + if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \ + c_tPos = c_tt[c_tPos]; \ + cccc = (UChar)(c_tPos & 0xff); \ + c_tPos >>= 8; + +#define SET_LL4(i,n) \ + { if (((i) & 0x1) == 0) \ + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \ + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \ + } + +#define GET_LL4(i) \ + ((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF) + +#define SET_LL(i,n) \ + { s->ll16[i] = (UInt16)(n & 0x0000ffff); \ + SET_LL4(i, n >> 16); \ + } + +#define GET_LL(i) \ + (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16)) + +#define BZ_GET_SMALL(cccc) \ + /* c_tPos is unsigned, hence test < 0 is pointless. */ \ + if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \ + cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \ + s->tPos = GET_LL(s->tPos); + + +/*-- externs for decompression. --*/ + +extern Int32 +BZ2_indexIntoF ( Int32, Int32* ); + +extern Int32 +BZ2_decompress ( DState* ); + +extern void +BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*, + Int32, Int32, Int32 ); + + +#endif + + +/*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/ + +#ifdef BZ_NO_STDIO +#ifndef NULL +#define NULL 0 +#endif +#endif + + +/*-------------------------------------------------------------*/ +/*--- end bzlib_private.h ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/compress.c b/dep/src/bzip2/compress.c new file mode 100644 index 00000000000..8c80a079700 --- /dev/null +++ b/dep/src/bzip2/compress.c @@ -0,0 +1,672 @@ + +/*-------------------------------------------------------------*/ +/*--- Compression machinery (not incl block sorting) ---*/ +/*--- compress.c ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +/* CHANGES + 0.9.0 -- original version. + 0.9.0a/b -- no changes in this file. + 0.9.0c -- changed setting of nGroups in sendMTFValues() + so as to do a bit better on small files +*/ + +#include "bzlib_private.h" + + +/*---------------------------------------------------*/ +/*--- Bit stream I/O ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +void BZ2_bsInitWrite ( EState* s ) +{ + s->bsLive = 0; + s->bsBuff = 0; +} + + +/*---------------------------------------------------*/ +static +void bsFinishWrite ( EState* s ) +{ + while (s->bsLive > 0) { + s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24); + s->numZ++; + s->bsBuff <<= 8; + s->bsLive -= 8; + } +} + + +/*---------------------------------------------------*/ +#define bsNEEDW(nz) \ +{ \ + while (s->bsLive >= 8) { \ + s->zbits[s->numZ] \ + = (UChar)(s->bsBuff >> 24); \ + s->numZ++; \ + s->bsBuff <<= 8; \ + s->bsLive -= 8; \ + } \ +} + + +/*---------------------------------------------------*/ +static +__inline__ +void bsW ( EState* s, Int32 n, UInt32 v ) +{ + bsNEEDW ( n ); + s->bsBuff |= (v << (32 - s->bsLive - n)); + s->bsLive += n; +} + + +/*---------------------------------------------------*/ +static +void bsPutUInt32 ( EState* s, UInt32 u ) +{ + bsW ( s, 8, (u >> 24) & 0xffL ); + bsW ( s, 8, (u >> 16) & 0xffL ); + bsW ( s, 8, (u >> 8) & 0xffL ); + bsW ( s, 8, u & 0xffL ); +} + + +/*---------------------------------------------------*/ +static +void bsPutUChar ( EState* s, UChar c ) +{ + bsW( s, 8, (UInt32)c ); +} + + +/*---------------------------------------------------*/ +/*--- The back end proper ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +static +void makeMaps_e ( EState* s ) +{ + Int32 i; + s->nInUse = 0; + for (i = 0; i < 256; i++) + if (s->inUse[i]) { + s->unseqToSeq[i] = s->nInUse; + s->nInUse++; + } +} + + +/*---------------------------------------------------*/ +static +void generateMTFValues ( EState* s ) +{ + UChar yy[256]; + Int32 i, j; + Int32 zPend; + Int32 wr; + Int32 EOB; + + /* + After sorting (eg, here), + s->arr1 [ 0 .. s->nblock-1 ] holds sorted order, + and + ((UChar*)s->arr2) [ 0 .. s->nblock-1 ] + holds the original block data. + + The first thing to do is generate the MTF values, + and put them in + ((UInt16*)s->arr1) [ 0 .. s->nblock-1 ]. + Because there are strictly fewer or equal MTF values + than block values, ptr values in this area are overwritten + with MTF values only when they are no longer needed. + + The final compressed bitstream is generated into the + area starting at + (UChar*) (&((UChar*)s->arr2)[s->nblock]) + + These storage aliases are set up in bzCompressInit(), + except for the last one, which is arranged in + compressBlock(). + */ + UInt32* ptr = s->ptr; + UChar* block = s->block; + UInt16* mtfv = s->mtfv; + + makeMaps_e ( s ); + EOB = s->nInUse+1; + + for (i = 0; i <= EOB; i++) s->mtfFreq[i] = 0; + + wr = 0; + zPend = 0; + for (i = 0; i < s->nInUse; i++) yy[i] = (UChar) i; + + for (i = 0; i < s->nblock; i++) { + UChar ll_i; + AssertD ( wr <= i, "generateMTFValues(1)" ); + j = ptr[i]-1; if (j < 0) j += s->nblock; + ll_i = s->unseqToSeq[block[j]]; + AssertD ( ll_i < s->nInUse, "generateMTFValues(2a)" ); + + if (yy[0] == ll_i) { + zPend++; + } else { + + if (zPend > 0) { + zPend--; + while (True) { + if (zPend & 1) { + mtfv[wr] = BZ_RUNB; wr++; + s->mtfFreq[BZ_RUNB]++; + } else { + mtfv[wr] = BZ_RUNA; wr++; + s->mtfFreq[BZ_RUNA]++; + } + if (zPend < 2) break; + zPend = (zPend - 2) / 2; + }; + zPend = 0; + } + { + register UChar rtmp; + register UChar* ryy_j; + register UChar rll_i; + rtmp = yy[1]; + yy[1] = yy[0]; + ryy_j = &(yy[1]); + rll_i = ll_i; + while ( rll_i != rtmp ) { + register UChar rtmp2; + ryy_j++; + rtmp2 = rtmp; + rtmp = *ryy_j; + *ryy_j = rtmp2; + }; + yy[0] = rtmp; + j = ryy_j - &(yy[0]); + mtfv[wr] = j+1; wr++; s->mtfFreq[j+1]++; + } + + } + } + + if (zPend > 0) { + zPend--; + while (True) { + if (zPend & 1) { + mtfv[wr] = BZ_RUNB; wr++; + s->mtfFreq[BZ_RUNB]++; + } else { + mtfv[wr] = BZ_RUNA; wr++; + s->mtfFreq[BZ_RUNA]++; + } + if (zPend < 2) break; + zPend = (zPend - 2) / 2; + }; + zPend = 0; + } + + mtfv[wr] = EOB; wr++; s->mtfFreq[EOB]++; + + s->nMTF = wr; +} + + +/*---------------------------------------------------*/ +#define BZ_LESSER_ICOST 0 +#define BZ_GREATER_ICOST 15 + +static +void sendMTFValues ( EState* s ) +{ + Int32 v, t, i, j, gs, ge, totc, bt, bc, iter; + Int32 nSelectors, alphaSize, minLen, maxLen, selCtr; + Int32 nGroups, nBytes; + + /*-- + UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + is a global since the decoder also needs it. + + Int32 code[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + are also globals only used in this proc. + Made global to keep stack frame size small. + --*/ + + + UInt16 cost[BZ_N_GROUPS]; + Int32 fave[BZ_N_GROUPS]; + + UInt16* mtfv = s->mtfv; + + if (s->verbosity >= 3) + VPrintf3( " %d in block, %d after MTF & 1-2 coding, " + "%d+2 syms in use\n", + s->nblock, s->nMTF, s->nInUse ); + + alphaSize = s->nInUse+2; + for (t = 0; t < BZ_N_GROUPS; t++) + for (v = 0; v < alphaSize; v++) + s->len[t][v] = BZ_GREATER_ICOST; + + /*--- Decide how many coding tables to use ---*/ + AssertH ( s->nMTF > 0, 3001 ); + if (s->nMTF < 200) nGroups = 2; else + if (s->nMTF < 600) nGroups = 3; else + if (s->nMTF < 1200) nGroups = 4; else + if (s->nMTF < 2400) nGroups = 5; else + nGroups = 6; + + /*--- Generate an initial set of coding tables ---*/ + { + Int32 nPart, remF, tFreq, aFreq; + + nPart = nGroups; + remF = s->nMTF; + gs = 0; + while (nPart > 0) { + tFreq = remF / nPart; + ge = gs-1; + aFreq = 0; + while (aFreq < tFreq && ge < alphaSize-1) { + ge++; + aFreq += s->mtfFreq[ge]; + } + + if (ge > gs + && nPart != nGroups && nPart != 1 + && ((nGroups-nPart) % 2 == 1)) { + aFreq -= s->mtfFreq[ge]; + ge--; + } + + if (s->verbosity >= 3) + VPrintf5( " initial group %d, [%d .. %d], " + "has %d syms (%4.1f%%)\n", + nPart, gs, ge, aFreq, + (100.0 * (float)aFreq) / (float)(s->nMTF) ); + + for (v = 0; v < alphaSize; v++) + if (v >= gs && v <= ge) + s->len[nPart-1][v] = BZ_LESSER_ICOST; else + s->len[nPart-1][v] = BZ_GREATER_ICOST; + + nPart--; + gs = ge+1; + remF -= aFreq; + } + } + + /*--- + Iterate up to BZ_N_ITERS times to improve the tables. + ---*/ + for (iter = 0; iter < BZ_N_ITERS; iter++) { + + for (t = 0; t < nGroups; t++) fave[t] = 0; + + for (t = 0; t < nGroups; t++) + for (v = 0; v < alphaSize; v++) + s->rfreq[t][v] = 0; + + /*--- + Set up an auxiliary length table which is used to fast-track + the common case (nGroups == 6). + ---*/ + if (nGroups == 6) { + for (v = 0; v < alphaSize; v++) { + s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v]; + s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v]; + s->len_pack[v][2] = (s->len[5][v] << 16) | s->len[4][v]; + } + } + + nSelectors = 0; + totc = 0; + gs = 0; + while (True) { + + /*--- Set group start & end marks. --*/ + if (gs >= s->nMTF) break; + ge = gs + BZ_G_SIZE - 1; + if (ge >= s->nMTF) ge = s->nMTF-1; + + /*-- + Calculate the cost of this group as coded + by each of the coding tables. + --*/ + for (t = 0; t < nGroups; t++) cost[t] = 0; + + if (nGroups == 6 && 50 == ge-gs+1) { + /*--- fast track the common case ---*/ + register UInt32 cost01, cost23, cost45; + register UInt16 icv; + cost01 = cost23 = cost45 = 0; + +# define BZ_ITER(nn) \ + icv = mtfv[gs+(nn)]; \ + cost01 += s->len_pack[icv][0]; \ + cost23 += s->len_pack[icv][1]; \ + cost45 += s->len_pack[icv][2]; \ + + BZ_ITER(0); BZ_ITER(1); BZ_ITER(2); BZ_ITER(3); BZ_ITER(4); + BZ_ITER(5); BZ_ITER(6); BZ_ITER(7); BZ_ITER(8); BZ_ITER(9); + BZ_ITER(10); BZ_ITER(11); BZ_ITER(12); BZ_ITER(13); BZ_ITER(14); + BZ_ITER(15); BZ_ITER(16); BZ_ITER(17); BZ_ITER(18); BZ_ITER(19); + BZ_ITER(20); BZ_ITER(21); BZ_ITER(22); BZ_ITER(23); BZ_ITER(24); + BZ_ITER(25); BZ_ITER(26); BZ_ITER(27); BZ_ITER(28); BZ_ITER(29); + BZ_ITER(30); BZ_ITER(31); BZ_ITER(32); BZ_ITER(33); BZ_ITER(34); + BZ_ITER(35); BZ_ITER(36); BZ_ITER(37); BZ_ITER(38); BZ_ITER(39); + BZ_ITER(40); BZ_ITER(41); BZ_ITER(42); BZ_ITER(43); BZ_ITER(44); + BZ_ITER(45); BZ_ITER(46); BZ_ITER(47); BZ_ITER(48); BZ_ITER(49); + +# undef BZ_ITER + + cost[0] = cost01 & 0xffff; cost[1] = cost01 >> 16; + cost[2] = cost23 & 0xffff; cost[3] = cost23 >> 16; + cost[4] = cost45 & 0xffff; cost[5] = cost45 >> 16; + + } else { + /*--- slow version which correctly handles all situations ---*/ + for (i = gs; i <= ge; i++) { + UInt16 icv = mtfv[i]; + for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv]; + } + } + + /*-- + Find the coding table which is best for this group, + and record its identity in the selector table. + --*/ + bc = 999999999; bt = -1; + for (t = 0; t < nGroups; t++) + if (cost[t] < bc) { bc = cost[t]; bt = t; }; + totc += bc; + fave[bt]++; + s->selector[nSelectors] = bt; + nSelectors++; + + /*-- + Increment the symbol frequencies for the selected table. + --*/ + if (nGroups == 6 && 50 == ge-gs+1) { + /*--- fast track the common case ---*/ + +# define BZ_ITUR(nn) s->rfreq[bt][ mtfv[gs+(nn)] ]++ + + BZ_ITUR(0); BZ_ITUR(1); BZ_ITUR(2); BZ_ITUR(3); BZ_ITUR(4); + BZ_ITUR(5); BZ_ITUR(6); BZ_ITUR(7); BZ_ITUR(8); BZ_ITUR(9); + BZ_ITUR(10); BZ_ITUR(11); BZ_ITUR(12); BZ_ITUR(13); BZ_ITUR(14); + BZ_ITUR(15); BZ_ITUR(16); BZ_ITUR(17); BZ_ITUR(18); BZ_ITUR(19); + BZ_ITUR(20); BZ_ITUR(21); BZ_ITUR(22); BZ_ITUR(23); BZ_ITUR(24); + BZ_ITUR(25); BZ_ITUR(26); BZ_ITUR(27); BZ_ITUR(28); BZ_ITUR(29); + BZ_ITUR(30); BZ_ITUR(31); BZ_ITUR(32); BZ_ITUR(33); BZ_ITUR(34); + BZ_ITUR(35); BZ_ITUR(36); BZ_ITUR(37); BZ_ITUR(38); BZ_ITUR(39); + BZ_ITUR(40); BZ_ITUR(41); BZ_ITUR(42); BZ_ITUR(43); BZ_ITUR(44); + BZ_ITUR(45); BZ_ITUR(46); BZ_ITUR(47); BZ_ITUR(48); BZ_ITUR(49); + +# undef BZ_ITUR + + } else { + /*--- slow version which correctly handles all situations ---*/ + for (i = gs; i <= ge; i++) + s->rfreq[bt][ mtfv[i] ]++; + } + + gs = ge+1; + } + if (s->verbosity >= 3) { + VPrintf2 ( " pass %d: size is %d, grp uses are ", + iter+1, totc/8 ); + for (t = 0; t < nGroups; t++) + VPrintf1 ( "%d ", fave[t] ); + VPrintf0 ( "\n" ); + } + + /*-- + Recompute the tables based on the accumulated frequencies. + --*/ + /* maxLen was changed from 20 to 17 in bzip2-1.0.3. See + comment in huffman.c for details. */ + for (t = 0; t < nGroups; t++) + BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]), + alphaSize, 17 /*20*/ ); + } + + + AssertH( nGroups < 8, 3002 ); + AssertH( nSelectors < 32768 && + nSelectors <= (2 + (900000 / BZ_G_SIZE)), + 3003 ); + + + /*--- Compute MTF values for the selectors. ---*/ + { + UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp; + for (i = 0; i < nGroups; i++) pos[i] = i; + for (i = 0; i < nSelectors; i++) { + ll_i = s->selector[i]; + j = 0; + tmp = pos[j]; + while ( ll_i != tmp ) { + j++; + tmp2 = tmp; + tmp = pos[j]; + pos[j] = tmp2; + }; + pos[0] = tmp; + s->selectorMtf[i] = j; + } + }; + + /*--- Assign actual codes for the tables. --*/ + for (t = 0; t < nGroups; t++) { + minLen = 32; + maxLen = 0; + for (i = 0; i < alphaSize; i++) { + if (s->len[t][i] > maxLen) maxLen = s->len[t][i]; + if (s->len[t][i] < minLen) minLen = s->len[t][i]; + } + AssertH ( !(maxLen > 17 /*20*/ ), 3004 ); + AssertH ( !(minLen < 1), 3005 ); + BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]), + minLen, maxLen, alphaSize ); + } + + /*--- Transmit the mapping table. ---*/ + { + Bool inUse16[16]; + for (i = 0; i < 16; i++) { + inUse16[i] = False; + for (j = 0; j < 16; j++) + if (s->inUse[i * 16 + j]) inUse16[i] = True; + } + + nBytes = s->numZ; + for (i = 0; i < 16; i++) + if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0); + + for (i = 0; i < 16; i++) + if (inUse16[i]) + for (j = 0; j < 16; j++) { + if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0); + } + + if (s->verbosity >= 3) + VPrintf1( " bytes: mapping %d, ", s->numZ-nBytes ); + } + + /*--- Now the selectors. ---*/ + nBytes = s->numZ; + bsW ( s, 3, nGroups ); + bsW ( s, 15, nSelectors ); + for (i = 0; i < nSelectors; i++) { + for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1); + bsW(s,1,0); + } + if (s->verbosity >= 3) + VPrintf1( "selectors %d, ", s->numZ-nBytes ); + + /*--- Now the coding tables. ---*/ + nBytes = s->numZ; + + for (t = 0; t < nGroups; t++) { + Int32 curr = s->len[t][0]; + bsW ( s, 5, curr ); + for (i = 0; i < alphaSize; i++) { + while (curr < s->len[t][i]) { bsW(s,2,2); curr++; /* 10 */ }; + while (curr > s->len[t][i]) { bsW(s,2,3); curr--; /* 11 */ }; + bsW ( s, 1, 0 ); + } + } + + if (s->verbosity >= 3) + VPrintf1 ( "code lengths %d, ", s->numZ-nBytes ); + + /*--- And finally, the block data proper ---*/ + nBytes = s->numZ; + selCtr = 0; + gs = 0; + while (True) { + if (gs >= s->nMTF) break; + ge = gs + BZ_G_SIZE - 1; + if (ge >= s->nMTF) ge = s->nMTF-1; + AssertH ( s->selector[selCtr] < nGroups, 3006 ); + + if (nGroups == 6 && 50 == ge-gs+1) { + /*--- fast track the common case ---*/ + UInt16 mtfv_i; + UChar* s_len_sel_selCtr + = &(s->len[s->selector[selCtr]][0]); + Int32* s_code_sel_selCtr + = &(s->code[s->selector[selCtr]][0]); + +# define BZ_ITAH(nn) \ + mtfv_i = mtfv[gs+(nn)]; \ + bsW ( s, \ + s_len_sel_selCtr[mtfv_i], \ + s_code_sel_selCtr[mtfv_i] ) + + BZ_ITAH(0); BZ_ITAH(1); BZ_ITAH(2); BZ_ITAH(3); BZ_ITAH(4); + BZ_ITAH(5); BZ_ITAH(6); BZ_ITAH(7); BZ_ITAH(8); BZ_ITAH(9); + BZ_ITAH(10); BZ_ITAH(11); BZ_ITAH(12); BZ_ITAH(13); BZ_ITAH(14); + BZ_ITAH(15); BZ_ITAH(16); BZ_ITAH(17); BZ_ITAH(18); BZ_ITAH(19); + BZ_ITAH(20); BZ_ITAH(21); BZ_ITAH(22); BZ_ITAH(23); BZ_ITAH(24); + BZ_ITAH(25); BZ_ITAH(26); BZ_ITAH(27); BZ_ITAH(28); BZ_ITAH(29); + BZ_ITAH(30); BZ_ITAH(31); BZ_ITAH(32); BZ_ITAH(33); BZ_ITAH(34); + BZ_ITAH(35); BZ_ITAH(36); BZ_ITAH(37); BZ_ITAH(38); BZ_ITAH(39); + BZ_ITAH(40); BZ_ITAH(41); BZ_ITAH(42); BZ_ITAH(43); BZ_ITAH(44); + BZ_ITAH(45); BZ_ITAH(46); BZ_ITAH(47); BZ_ITAH(48); BZ_ITAH(49); + +# undef BZ_ITAH + + } else { + /*--- slow version which correctly handles all situations ---*/ + for (i = gs; i <= ge; i++) { + bsW ( s, + s->len [s->selector[selCtr]] [mtfv[i]], + s->code [s->selector[selCtr]] [mtfv[i]] ); + } + } + + + gs = ge+1; + selCtr++; + } + AssertH( selCtr == nSelectors, 3007 ); + + if (s->verbosity >= 3) + VPrintf1( "codes %d\n", s->numZ-nBytes ); +} + + +/*---------------------------------------------------*/ +void BZ2_compressBlock ( EState* s, Bool is_last_block ) +{ + if (s->nblock > 0) { + + BZ_FINALISE_CRC ( s->blockCRC ); + s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31); + s->combinedCRC ^= s->blockCRC; + if (s->blockNo > 1) s->numZ = 0; + + if (s->verbosity >= 2) + VPrintf4( " block %d: crc = 0x%08x, " + "combined CRC = 0x%08x, size = %d\n", + s->blockNo, s->blockCRC, s->combinedCRC, s->nblock ); + + BZ2_blockSort ( s ); + } + + s->zbits = (UChar*) (&((UChar*)s->arr2)[s->nblock]); + + /*-- If this is the first block, create the stream header. --*/ + if (s->blockNo == 1) { + BZ2_bsInitWrite ( s ); + bsPutUChar ( s, BZ_HDR_B ); + bsPutUChar ( s, BZ_HDR_Z ); + bsPutUChar ( s, BZ_HDR_h ); + bsPutUChar ( s, (UChar)(BZ_HDR_0 + s->blockSize100k) ); + } + + if (s->nblock > 0) { + + bsPutUChar ( s, 0x31 ); bsPutUChar ( s, 0x41 ); + bsPutUChar ( s, 0x59 ); bsPutUChar ( s, 0x26 ); + bsPutUChar ( s, 0x53 ); bsPutUChar ( s, 0x59 ); + + /*-- Now the block's CRC, so it is in a known place. --*/ + bsPutUInt32 ( s, s->blockCRC ); + + /*-- + Now a single bit indicating (non-)randomisation. + As of version 0.9.5, we use a better sorting algorithm + which makes randomisation unnecessary. So always set + the randomised bit to 'no'. Of course, the decoder + still needs to be able to handle randomised blocks + so as to maintain backwards compatibility with + older versions of bzip2. + --*/ + bsW(s,1,0); + + bsW ( s, 24, s->origPtr ); + generateMTFValues ( s ); + sendMTFValues ( s ); + } + + + /*-- If this is the last block, add the stream trailer. --*/ + if (is_last_block) { + + bsPutUChar ( s, 0x17 ); bsPutUChar ( s, 0x72 ); + bsPutUChar ( s, 0x45 ); bsPutUChar ( s, 0x38 ); + bsPutUChar ( s, 0x50 ); bsPutUChar ( s, 0x90 ); + bsPutUInt32 ( s, s->combinedCRC ); + if (s->verbosity >= 2) + VPrintf1( " final combined CRC = 0x%08x\n ", s->combinedCRC ); + bsFinishWrite ( s ); + } +} + + +/*-------------------------------------------------------------*/ +/*--- end compress.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/crctable.c b/dep/src/bzip2/crctable.c new file mode 100644 index 00000000000..215687b2c05 --- /dev/null +++ b/dep/src/bzip2/crctable.c @@ -0,0 +1,104 @@ + +/*-------------------------------------------------------------*/ +/*--- Table for doing CRCs ---*/ +/*--- crctable.c ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#include "bzlib_private.h" + +/*-- + I think this is an implementation of the AUTODIN-II, + Ethernet & FDDI 32-bit CRC standard. Vaguely derived + from code by Rob Warnock, in Section 51 of the + comp.compression FAQ. +--*/ + +UInt32 BZ2_crc32Table[256] = { + + /*-- Ugly, innit? --*/ + + 0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L, + 0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L, + 0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L, + 0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL, + 0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L, + 0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L, + 0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L, + 0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL, + 0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L, + 0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L, + 0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L, + 0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL, + 0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L, + 0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L, + 0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L, + 0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL, + 0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL, + 0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L, + 0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L, + 0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL, + 0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL, + 0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L, + 0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L, + 0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL, + 0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL, + 0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L, + 0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L, + 0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL, + 0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL, + 0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L, + 0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L, + 0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL, + 0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L, + 0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL, + 0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL, + 0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L, + 0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L, + 0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL, + 0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL, + 0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L, + 0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L, + 0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL, + 0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL, + 0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L, + 0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L, + 0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL, + 0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL, + 0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L, + 0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L, + 0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL, + 0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L, + 0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L, + 0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L, + 0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL, + 0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L, + 0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L, + 0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L, + 0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL, + 0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L, + 0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L, + 0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L, + 0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL, + 0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L, + 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L +}; + + +/*-------------------------------------------------------------*/ +/*--- end crctable.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/decompress.c b/dep/src/bzip2/decompress.c new file mode 100644 index 00000000000..bba5e0fa36d --- /dev/null +++ b/dep/src/bzip2/decompress.c @@ -0,0 +1,626 @@ + +/*-------------------------------------------------------------*/ +/*--- Decompression machinery ---*/ +/*--- decompress.c ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#include "bzlib_private.h" + + +/*---------------------------------------------------*/ +static +void makeMaps_d ( DState* s ) +{ + Int32 i; + s->nInUse = 0; + for (i = 0; i < 256; i++) + if (s->inUse[i]) { + s->seqToUnseq[s->nInUse] = i; + s->nInUse++; + } +} + + +/*---------------------------------------------------*/ +#define RETURN(rrr) \ + { retVal = rrr; goto save_state_and_return; }; + +#define GET_BITS(lll,vvv,nnn) \ + case lll: s->state = lll; \ + while (True) { \ + if (s->bsLive >= nnn) { \ + UInt32 v; \ + v = (s->bsBuff >> \ + (s->bsLive-nnn)) & ((1 << nnn)-1); \ + s->bsLive -= nnn; \ + vvv = v; \ + break; \ + } \ + if (s->strm->avail_in == 0) RETURN(BZ_OK); \ + s->bsBuff \ + = (s->bsBuff << 8) | \ + ((UInt32) \ + (*((UChar*)(s->strm->next_in)))); \ + s->bsLive += 8; \ + s->strm->next_in++; \ + s->strm->avail_in--; \ + s->strm->total_in_lo32++; \ + if (s->strm->total_in_lo32 == 0) \ + s->strm->total_in_hi32++; \ + } + +#define GET_UCHAR(lll,uuu) \ + GET_BITS(lll,uuu,8) + +#define GET_BIT(lll,uuu) \ + GET_BITS(lll,uuu,1) + +/*---------------------------------------------------*/ +#define GET_MTF_VAL(label1,label2,lval) \ +{ \ + if (groupPos == 0) { \ + groupNo++; \ + if (groupNo >= nSelectors) \ + RETURN(BZ_DATA_ERROR); \ + groupPos = BZ_G_SIZE; \ + gSel = s->selector[groupNo]; \ + gMinlen = s->minLens[gSel]; \ + gLimit = &(s->limit[gSel][0]); \ + gPerm = &(s->perm[gSel][0]); \ + gBase = &(s->base[gSel][0]); \ + } \ + groupPos--; \ + zn = gMinlen; \ + GET_BITS(label1, zvec, zn); \ + while (1) { \ + if (zn > 20 /* the longest code */) \ + RETURN(BZ_DATA_ERROR); \ + if (zvec <= gLimit[zn]) break; \ + zn++; \ + GET_BIT(label2, zj); \ + zvec = (zvec << 1) | zj; \ + }; \ + if (zvec - gBase[zn] < 0 \ + || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \ + RETURN(BZ_DATA_ERROR); \ + lval = gPerm[zvec - gBase[zn]]; \ +} + + +/*---------------------------------------------------*/ +Int32 BZ2_decompress ( DState* s ) +{ + UChar uc; + Int32 retVal; + Int32 minLen, maxLen; + bz_stream* strm = s->strm; + + /* stuff that needs to be saved/restored */ + Int32 i; + Int32 j; + Int32 t; + Int32 alphaSize; + Int32 nGroups; + Int32 nSelectors; + Int32 EOB; + Int32 groupNo; + Int32 groupPos; + Int32 nextSym; + Int32 nblockMAX; + Int32 nblock; + Int32 es; + Int32 N; + Int32 curr; + Int32 zt; + Int32 zn; + Int32 zvec; + Int32 zj; + Int32 gSel; + Int32 gMinlen; + Int32* gLimit; + Int32* gBase; + Int32* gPerm; + + if (s->state == BZ_X_MAGIC_1) { + /*initialise the save area*/ + s->save_i = 0; + s->save_j = 0; + s->save_t = 0; + s->save_alphaSize = 0; + s->save_nGroups = 0; + s->save_nSelectors = 0; + s->save_EOB = 0; + s->save_groupNo = 0; + s->save_groupPos = 0; + s->save_nextSym = 0; + s->save_nblockMAX = 0; + s->save_nblock = 0; + s->save_es = 0; + s->save_N = 0; + s->save_curr = 0; + s->save_zt = 0; + s->save_zn = 0; + s->save_zvec = 0; + s->save_zj = 0; + s->save_gSel = 0; + s->save_gMinlen = 0; + s->save_gLimit = NULL; + s->save_gBase = NULL; + s->save_gPerm = NULL; + } + + /*restore from the save area*/ + i = s->save_i; + j = s->save_j; + t = s->save_t; + alphaSize = s->save_alphaSize; + nGroups = s->save_nGroups; + nSelectors = s->save_nSelectors; + EOB = s->save_EOB; + groupNo = s->save_groupNo; + groupPos = s->save_groupPos; + nextSym = s->save_nextSym; + nblockMAX = s->save_nblockMAX; + nblock = s->save_nblock; + es = s->save_es; + N = s->save_N; + curr = s->save_curr; + zt = s->save_zt; + zn = s->save_zn; + zvec = s->save_zvec; + zj = s->save_zj; + gSel = s->save_gSel; + gMinlen = s->save_gMinlen; + gLimit = s->save_gLimit; + gBase = s->save_gBase; + gPerm = s->save_gPerm; + + retVal = BZ_OK; + + switch (s->state) { + + GET_UCHAR(BZ_X_MAGIC_1, uc); + if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC); + + GET_UCHAR(BZ_X_MAGIC_2, uc); + if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC); + + GET_UCHAR(BZ_X_MAGIC_3, uc) + if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC); + + GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8) + if (s->blockSize100k < (BZ_HDR_0 + 1) || + s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC); + s->blockSize100k -= BZ_HDR_0; + + if (s->smallDecompress) { + s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) ); + s->ll4 = BZALLOC( + ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) + ); + if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR); + } else { + s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) ); + if (s->tt == NULL) RETURN(BZ_MEM_ERROR); + } + + GET_UCHAR(BZ_X_BLKHDR_1, uc); + + if (uc == 0x17) goto endhdr_2; + if (uc != 0x31) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_2, uc); + if (uc != 0x41) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_3, uc); + if (uc != 0x59) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_4, uc); + if (uc != 0x26) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_5, uc); + if (uc != 0x53) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_6, uc); + if (uc != 0x59) RETURN(BZ_DATA_ERROR); + + s->currBlockNo++; + if (s->verbosity >= 2) + VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo ); + + s->storedBlockCRC = 0; + GET_UCHAR(BZ_X_BCRC_1, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_BCRC_2, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_BCRC_3, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_BCRC_4, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + + GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1); + + s->origPtr = 0; + GET_UCHAR(BZ_X_ORIGPTR_1, uc); + s->origPtr = (s->origPtr << 8) | ((Int32)uc); + GET_UCHAR(BZ_X_ORIGPTR_2, uc); + s->origPtr = (s->origPtr << 8) | ((Int32)uc); + GET_UCHAR(BZ_X_ORIGPTR_3, uc); + s->origPtr = (s->origPtr << 8) | ((Int32)uc); + + if (s->origPtr < 0) + RETURN(BZ_DATA_ERROR); + if (s->origPtr > 10 + 100000*s->blockSize100k) + RETURN(BZ_DATA_ERROR); + + /*--- Receive the mapping table ---*/ + for (i = 0; i < 16; i++) { + GET_BIT(BZ_X_MAPPING_1, uc); + if (uc == 1) + s->inUse16[i] = True; else + s->inUse16[i] = False; + } + + for (i = 0; i < 256; i++) s->inUse[i] = False; + + for (i = 0; i < 16; i++) + if (s->inUse16[i]) + for (j = 0; j < 16; j++) { + GET_BIT(BZ_X_MAPPING_2, uc); + if (uc == 1) s->inUse[i * 16 + j] = True; + } + makeMaps_d ( s ); + if (s->nInUse == 0) RETURN(BZ_DATA_ERROR); + alphaSize = s->nInUse+2; + + /*--- Now the selectors ---*/ + GET_BITS(BZ_X_SELECTOR_1, nGroups, 3); + if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR); + GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15); + if (nSelectors < 1) RETURN(BZ_DATA_ERROR); + for (i = 0; i < nSelectors; i++) { + j = 0; + while (True) { + GET_BIT(BZ_X_SELECTOR_3, uc); + if (uc == 0) break; + j++; + if (j >= nGroups) RETURN(BZ_DATA_ERROR); + } + s->selectorMtf[i] = j; + } + + /*--- Undo the MTF values for the selectors. ---*/ + { + UChar pos[BZ_N_GROUPS], tmp, v; + for (v = 0; v < nGroups; v++) pos[v] = v; + + for (i = 0; i < nSelectors; i++) { + v = s->selectorMtf[i]; + tmp = pos[v]; + while (v > 0) { pos[v] = pos[v-1]; v--; } + pos[0] = tmp; + s->selector[i] = tmp; + } + } + + /*--- Now the coding tables ---*/ + for (t = 0; t < nGroups; t++) { + GET_BITS(BZ_X_CODING_1, curr, 5); + for (i = 0; i < alphaSize; i++) { + while (True) { + if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR); + GET_BIT(BZ_X_CODING_2, uc); + if (uc == 0) break; + GET_BIT(BZ_X_CODING_3, uc); + if (uc == 0) curr++; else curr--; + } + s->len[t][i] = curr; + } + } + + /*--- Create the Huffman decoding tables ---*/ + for (t = 0; t < nGroups; t++) { + minLen = 32; + maxLen = 0; + for (i = 0; i < alphaSize; i++) { + if (s->len[t][i] > maxLen) maxLen = s->len[t][i]; + if (s->len[t][i] < minLen) minLen = s->len[t][i]; + } + BZ2_hbCreateDecodeTables ( + &(s->limit[t][0]), + &(s->base[t][0]), + &(s->perm[t][0]), + &(s->len[t][0]), + minLen, maxLen, alphaSize + ); + s->minLens[t] = minLen; + } + + /*--- Now the MTF values ---*/ + + EOB = s->nInUse+1; + nblockMAX = 100000 * s->blockSize100k; + groupNo = -1; + groupPos = 0; + + for (i = 0; i <= 255; i++) s->unzftab[i] = 0; + + /*-- MTF init --*/ + { + Int32 ii, jj, kk; + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj); + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + /*-- end MTF init --*/ + + nblock = 0; + GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym); + + while (True) { + + if (nextSym == EOB) break; + + if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) { + + es = -1; + N = 1; + do { + if (nextSym == BZ_RUNA) es = es + (0+1) * N; else + if (nextSym == BZ_RUNB) es = es + (1+1) * N; + N = N * 2; + GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym); + } + while (nextSym == BZ_RUNA || nextSym == BZ_RUNB); + + es++; + uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ]; + s->unzftab[uc] += es; + + if (s->smallDecompress) + while (es > 0) { + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + s->ll16[nblock] = (UInt16)uc; + nblock++; + es--; + } + else + while (es > 0) { + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + s->tt[nblock] = (UInt32)uc; + nblock++; + es--; + }; + + continue; + + } else { + + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + + /*-- uc = MTF ( nextSym-1 ) --*/ + { + Int32 ii, jj, kk, pp, lno, off; + UInt32 nn; + nn = (UInt32)(nextSym - 1); + + if (nn < MTFL_SIZE) { + /* avoid general-case expense */ + pp = s->mtfbase[0]; + uc = s->mtfa[pp+nn]; + while (nn > 3) { + Int32 z = pp+nn; + s->mtfa[(z) ] = s->mtfa[(z)-1]; + s->mtfa[(z)-1] = s->mtfa[(z)-2]; + s->mtfa[(z)-2] = s->mtfa[(z)-3]; + s->mtfa[(z)-3] = s->mtfa[(z)-4]; + nn -= 4; + } + while (nn > 0) { + s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; + }; + s->mtfa[pp] = uc; + } else { + /* general case */ + lno = nn / MTFL_SIZE; + off = nn % MTFL_SIZE; + pp = s->mtfbase[lno] + off; + uc = s->mtfa[pp]; + while (pp > s->mtfbase[lno]) { + s->mtfa[pp] = s->mtfa[pp-1]; pp--; + }; + s->mtfbase[lno]++; + while (lno > 0) { + s->mtfbase[lno]--; + s->mtfa[s->mtfbase[lno]] + = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1]; + lno--; + } + s->mtfbase[0]--; + s->mtfa[s->mtfbase[0]] = uc; + if (s->mtfbase[0] == 0) { + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj]; + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + } + } + /*-- end uc = MTF ( nextSym-1 ) --*/ + + s->unzftab[s->seqToUnseq[uc]]++; + if (s->smallDecompress) + s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else + s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]); + nblock++; + + GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym); + continue; + } + } + + /* Now we know what nblock is, we can do a better sanity + check on s->origPtr. + */ + if (s->origPtr < 0 || s->origPtr >= nblock) + RETURN(BZ_DATA_ERROR); + + /*-- Set up cftab to facilitate generation of T^(-1) --*/ + s->cftab[0] = 0; + for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1]; + for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1]; + for (i = 0; i <= 256; i++) { + if (s->cftab[i] < 0 || s->cftab[i] > nblock) { + /* s->cftab[i] can legitimately be == nblock */ + RETURN(BZ_DATA_ERROR); + } + } + + s->state_out_len = 0; + s->state_out_ch = 0; + BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); + s->state = BZ_X_OUTPUT; + if (s->verbosity >= 2) VPrintf0 ( "rt+rld" ); + + if (s->smallDecompress) { + + /*-- Make a copy of cftab, used in generation of T --*/ + for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i]; + + /*-- compute the T vector --*/ + for (i = 0; i < nblock; i++) { + uc = (UChar)(s->ll16[i]); + SET_LL(i, s->cftabCopy[uc]); + s->cftabCopy[uc]++; + } + + /*-- Compute T^(-1) by pointer reversal on T --*/ + i = s->origPtr; + j = GET_LL(i); + do { + Int32 tmp = GET_LL(j); + SET_LL(j, i); + i = j; + j = tmp; + } + while (i != s->origPtr); + + s->tPos = s->origPtr; + s->nblock_used = 0; + if (s->blockRandomised) { + BZ_RAND_INIT_MASK; + BZ_GET_SMALL(s->k0); s->nblock_used++; + BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; + } else { + BZ_GET_SMALL(s->k0); s->nblock_used++; + } + + } else { + + /*-- compute the T^(-1) vector --*/ + for (i = 0; i < nblock; i++) { + uc = (UChar)(s->tt[i] & 0xff); + s->tt[s->cftab[uc]] |= (i << 8); + s->cftab[uc]++; + } + + s->tPos = s->tt[s->origPtr] >> 8; + s->nblock_used = 0; + if (s->blockRandomised) { + BZ_RAND_INIT_MASK; + BZ_GET_FAST(s->k0); s->nblock_used++; + BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; + } else { + BZ_GET_FAST(s->k0); s->nblock_used++; + } + + } + + RETURN(BZ_OK); + + + + endhdr_2: + + GET_UCHAR(BZ_X_ENDHDR_2, uc); + if (uc != 0x72) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_3, uc); + if (uc != 0x45) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_4, uc); + if (uc != 0x38) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_5, uc); + if (uc != 0x50) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_6, uc); + if (uc != 0x90) RETURN(BZ_DATA_ERROR); + + s->storedCombinedCRC = 0; + GET_UCHAR(BZ_X_CCRC_1, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_CCRC_2, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_CCRC_3, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_CCRC_4, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + + s->state = BZ_X_IDLE; + RETURN(BZ_STREAM_END); + + default: AssertH ( False, 4001 ); + } + + AssertH ( False, 4002 ); + + save_state_and_return: + + s->save_i = i; + s->save_j = j; + s->save_t = t; + s->save_alphaSize = alphaSize; + s->save_nGroups = nGroups; + s->save_nSelectors = nSelectors; + s->save_EOB = EOB; + s->save_groupNo = groupNo; + s->save_groupPos = groupPos; + s->save_nextSym = nextSym; + s->save_nblockMAX = nblockMAX; + s->save_nblock = nblock; + s->save_es = es; + s->save_N = N; + s->save_curr = curr; + s->save_zt = zt; + s->save_zn = zn; + s->save_zvec = zvec; + s->save_zj = zj; + s->save_gSel = gSel; + s->save_gMinlen = gMinlen; + s->save_gLimit = gLimit; + s->save_gBase = gBase; + s->save_gPerm = gPerm; + + return retVal; +} + + +/*-------------------------------------------------------------*/ +/*--- end decompress.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/huffman.c b/dep/src/bzip2/huffman.c new file mode 100644 index 00000000000..87e79e38af0 --- /dev/null +++ b/dep/src/bzip2/huffman.c @@ -0,0 +1,205 @@ + +/*-------------------------------------------------------------*/ +/*--- Huffman coding low-level stuff ---*/ +/*--- huffman.c ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#include "bzlib_private.h" + +/*---------------------------------------------------*/ +#define WEIGHTOF(zz0) ((zz0) & 0xffffff00) +#define DEPTHOF(zz1) ((zz1) & 0x000000ff) +#define MYMAX(zz2,zz3) ((zz2) > (zz3) ? (zz2) : (zz3)) + +#define ADDWEIGHTS(zw1,zw2) \ + (WEIGHTOF(zw1)+WEIGHTOF(zw2)) | \ + (1 + MYMAX(DEPTHOF(zw1),DEPTHOF(zw2))) + +#define UPHEAP(z) \ +{ \ + Int32 zz, tmp; \ + zz = z; tmp = heap[zz]; \ + while (weight[tmp] < weight[heap[zz >> 1]]) { \ + heap[zz] = heap[zz >> 1]; \ + zz >>= 1; \ + } \ + heap[zz] = tmp; \ +} + +#define DOWNHEAP(z) \ +{ \ + Int32 zz, yy, tmp; \ + zz = z; tmp = heap[zz]; \ + while (True) { \ + yy = zz << 1; \ + if (yy > nHeap) break; \ + if (yy < nHeap && \ + weight[heap[yy+1]] < weight[heap[yy]]) \ + yy++; \ + if (weight[tmp] < weight[heap[yy]]) break; \ + heap[zz] = heap[yy]; \ + zz = yy; \ + } \ + heap[zz] = tmp; \ +} + + +/*---------------------------------------------------*/ +void BZ2_hbMakeCodeLengths ( UChar *len, + Int32 *freq, + Int32 alphaSize, + Int32 maxLen ) +{ + /*-- + Nodes and heap entries run from 1. Entry 0 + for both the heap and nodes is a sentinel. + --*/ + Int32 nNodes, nHeap, n1, n2, i, j, k; + Bool tooLong; + + Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ]; + Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ]; + Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ]; + + for (i = 0; i < alphaSize; i++) + weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8; + + while (True) { + + nNodes = alphaSize; + nHeap = 0; + + heap[0] = 0; + weight[0] = 0; + parent[0] = -2; + + for (i = 1; i <= alphaSize; i++) { + parent[i] = -1; + nHeap++; + heap[nHeap] = i; + UPHEAP(nHeap); + } + + AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 ); + + while (nHeap > 1) { + n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1); + n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1); + nNodes++; + parent[n1] = parent[n2] = nNodes; + weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]); + parent[nNodes] = -1; + nHeap++; + heap[nHeap] = nNodes; + UPHEAP(nHeap); + } + + AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 ); + + tooLong = False; + for (i = 1; i <= alphaSize; i++) { + j = 0; + k = i; + while (parent[k] >= 0) { k = parent[k]; j++; } + len[i-1] = j; + if (j > maxLen) tooLong = True; + } + + if (! tooLong) break; + + /* 17 Oct 04: keep-going condition for the following loop used + to be 'i < alphaSize', which missed the last element, + theoretically leading to the possibility of the compressor + looping. However, this count-scaling step is only needed if + one of the generated Huffman code words is longer than + maxLen, which up to and including version 1.0.2 was 20 bits, + which is extremely unlikely. In version 1.0.3 maxLen was + changed to 17 bits, which has minimal effect on compression + ratio, but does mean this scaling step is used from time to + time, enough to verify that it works. + + This means that bzip2-1.0.3 and later will only produce + Huffman codes with a maximum length of 17 bits. However, in + order to preserve backwards compatibility with bitstreams + produced by versions pre-1.0.3, the decompressor must still + handle lengths of up to 20. */ + + for (i = 1; i <= alphaSize; i++) { + j = weight[i] >> 8; + j = 1 + (j / 2); + weight[i] = j << 8; + } + } +} + + +/*---------------------------------------------------*/ +void BZ2_hbAssignCodes ( Int32 *code, + UChar *length, + Int32 minLen, + Int32 maxLen, + Int32 alphaSize ) +{ + Int32 n, vec, i; + + vec = 0; + for (n = minLen; n <= maxLen; n++) { + for (i = 0; i < alphaSize; i++) + if (length[i] == n) { code[i] = vec; vec++; }; + vec <<= 1; + } +} + + +/*---------------------------------------------------*/ +void BZ2_hbCreateDecodeTables ( Int32 *limit, + Int32 *base, + Int32 *perm, + UChar *length, + Int32 minLen, + Int32 maxLen, + Int32 alphaSize ) +{ + Int32 pp, i, j, vec; + + pp = 0; + for (i = minLen; i <= maxLen; i++) + for (j = 0; j < alphaSize; j++) + if (length[j] == i) { perm[pp] = j; pp++; }; + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0; + for (i = 0; i < alphaSize; i++) base[length[i]+1]++; + + for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1]; + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0; + vec = 0; + + for (i = minLen; i <= maxLen; i++) { + vec += (base[i+1] - base[i]); + limit[i] = vec-1; + vec <<= 1; + } + for (i = minLen + 1; i <= maxLen; i++) + base[i] = ((limit[i-1] + 1) << 1) - base[i]; +} + + +/*-------------------------------------------------------------*/ +/*--- end huffman.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/bzip2/randtable.c b/dep/src/bzip2/randtable.c new file mode 100644 index 00000000000..068b76367bc --- /dev/null +++ b/dep/src/bzip2/randtable.c @@ -0,0 +1,84 @@ + +/*-------------------------------------------------------------*/ +/*--- Table for randomising repetitive blocks ---*/ +/*--- randtable.c ---*/ +/*-------------------------------------------------------------*/ + +/* ------------------------------------------------------------------ + This file is part of bzip2/libbzip2, a program and library for + lossless, block-sorting data compression. + + bzip2/libbzip2 version 1.0.5 of 10 December 2007 + Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> + + Please read the WARNING, DISCLAIMER and PATENTS sections in the + README file. + + This program is released under the terms of the license contained + in the file LICENSE. + ------------------------------------------------------------------ */ + + +#include "bzlib_private.h" + + +/*---------------------------------------------*/ +Int32 BZ2_rNums[512] = { + 619, 720, 127, 481, 931, 816, 813, 233, 566, 247, + 985, 724, 205, 454, 863, 491, 741, 242, 949, 214, + 733, 859, 335, 708, 621, 574, 73, 654, 730, 472, + 419, 436, 278, 496, 867, 210, 399, 680, 480, 51, + 878, 465, 811, 169, 869, 675, 611, 697, 867, 561, + 862, 687, 507, 283, 482, 129, 807, 591, 733, 623, + 150, 238, 59, 379, 684, 877, 625, 169, 643, 105, + 170, 607, 520, 932, 727, 476, 693, 425, 174, 647, + 73, 122, 335, 530, 442, 853, 695, 249, 445, 515, + 909, 545, 703, 919, 874, 474, 882, 500, 594, 612, + 641, 801, 220, 162, 819, 984, 589, 513, 495, 799, + 161, 604, 958, 533, 221, 400, 386, 867, 600, 782, + 382, 596, 414, 171, 516, 375, 682, 485, 911, 276, + 98, 553, 163, 354, 666, 933, 424, 341, 533, 870, + 227, 730, 475, 186, 263, 647, 537, 686, 600, 224, + 469, 68, 770, 919, 190, 373, 294, 822, 808, 206, + 184, 943, 795, 384, 383, 461, 404, 758, 839, 887, + 715, 67, 618, 276, 204, 918, 873, 777, 604, 560, + 951, 160, 578, 722, 79, 804, 96, 409, 713, 940, + 652, 934, 970, 447, 318, 353, 859, 672, 112, 785, + 645, 863, 803, 350, 139, 93, 354, 99, 820, 908, + 609, 772, 154, 274, 580, 184, 79, 626, 630, 742, + 653, 282, 762, 623, 680, 81, 927, 626, 789, 125, + 411, 521, 938, 300, 821, 78, 343, 175, 128, 250, + 170, 774, 972, 275, 999, 639, 495, 78, 352, 126, + 857, 956, 358, 619, 580, 124, 737, 594, 701, 612, + 669, 112, 134, 694, 363, 992, 809, 743, 168, 974, + 944, 375, 748, 52, 600, 747, 642, 182, 862, 81, + 344, 805, 988, 739, 511, 655, 814, 334, 249, 515, + 897, 955, 664, 981, 649, 113, 974, 459, 893, 228, + 433, 837, 553, 268, 926, 240, 102, 654, 459, 51, + 686, 754, 806, 760, 493, 403, 415, 394, 687, 700, + 946, 670, 656, 610, 738, 392, 760, 799, 887, 653, + 978, 321, 576, 617, 626, 502, 894, 679, 243, 440, + 680, 879, 194, 572, 640, 724, 926, 56, 204, 700, + 707, 151, 457, 449, 797, 195, 791, 558, 945, 679, + 297, 59, 87, 824, 713, 663, 412, 693, 342, 606, + 134, 108, 571, 364, 631, 212, 174, 643, 304, 329, + 343, 97, 430, 751, 497, 314, 983, 374, 822, 928, + 140, 206, 73, 263, 980, 736, 876, 478, 430, 305, + 170, 514, 364, 692, 829, 82, 855, 953, 676, 246, + 369, 970, 294, 750, 807, 827, 150, 790, 288, 923, + 804, 378, 215, 828, 592, 281, 565, 555, 710, 82, + 896, 831, 547, 261, 524, 462, 293, 465, 502, 56, + 661, 821, 976, 991, 658, 869, 905, 758, 745, 193, + 768, 550, 608, 933, 378, 286, 215, 979, 792, 961, + 61, 688, 793, 644, 986, 403, 106, 366, 905, 644, + 372, 567, 466, 434, 645, 210, 389, 550, 919, 135, + 780, 773, 635, 389, 707, 100, 626, 958, 165, 504, + 920, 176, 193, 713, 857, 265, 203, 50, 668, 108, + 645, 990, 626, 197, 510, 357, 358, 850, 858, 364, + 936, 638 +}; + + +/*-------------------------------------------------------------*/ +/*--- end randtable.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/dep/src/g3dlite/AABox.cpp b/dep/src/g3dlite/AABox.cpp index 2279e9a51f0..035497aa3c4 100644 --- a/dep/src/g3dlite/AABox.cpp +++ b/dep/src/g3dlite/AABox.cpp @@ -1,30 +1,61 @@ /** @file AABox.cpp - @maintainer Morgan McGuire, matrix@graphics3d.com + @maintainer Morgan McGuire, http://graphics.cs.williams.edu @created 2004-01-10 @edited 2006-01-11 */ #include "G3D/platform.h" -# if defined(_MSC_VER) && (_MSC_VER <= 1200) - // VC6 std:: has signed/unsigned problems -# pragma warning (disable : 4018) -# endif - -#include <assert.h> #include "G3D/AABox.h" #include "G3D/Box.h" #include "G3D/Plane.h" #include "G3D/Sphere.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + namespace G3D { -Box AABox::toBox() const { - return Box(lo, hi); +const AABox& AABox::maxFinite() { + static const AABox b = AABox(Vector3::minFinite(), + Vector3::maxFinite()); + return b; +} + + +const AABox& AABox::large() { + static const AABox b = AABox(Vector3::minFinite() * 0.5f, + Vector3::maxFinite() * 0.5f); + return b; +} + + +const AABox& AABox::inf() { + static const AABox b = AABox(-Vector3::inf(), Vector3::inf()); + return b; +} + + +const AABox& AABox::zero() { + static const AABox b = AABox(Vector3::zero(), Vector3::zero()); + return b; +} + + +void AABox::serialize(class BinaryOutput& b) const { + b.writeVector3(lo); + b.writeVector3(hi); +} + + +void AABox::deserialize(class BinaryInput& b) { + lo = b.readVector3(); + hi = b.readVector3(); } + void AABox::split(const Vector3::Axis& axis, float location, AABox& low, AABox& high) const { // Low, medium, and high along the chosen axis float L = G3D::min(location, lo[axis]); @@ -41,51 +72,52 @@ void AABox::split(const Vector3::Axis& axis, float location, AABox& low, AABox& high.hi[axis] = H; } -#if 0 + Vector3 AABox::randomSurfacePoint() const { Vector3 extent = hi - lo; float aXY = extent.x * extent.y; float aYZ = extent.y * extent.z; float aZX = extent.z * extent.x; - float r = (float)random(0, aXY + aYZ + aZX); + float r = (float)uniformRandom(0.0f, aXY + aYZ + aZX); // Choose evenly between positive and negative face planes - float d = ((float)random(0, 1) < 0.5f) ? 0.0f : 1.0f; + float d = ((float)uniformRandom(0, 1) < 0.5f) ? 0.0f : 1.0f; // The probability of choosing a given face is proportional to // its area. if (r < aXY) { - return - lo + + return + lo + Vector3( - (float)random(0, extent.x), - (float)random(0, extent.y), + (float)uniformRandom(0.0f, extent.x), + (float)uniformRandom(0.0f, extent.y), d * extent.z); } else if (r < aYZ) { - return - lo + + return + lo + Vector3( d * extent.x, - (float)random(0, extent.y), - (float)random(0, extent.z)); + (float)uniformRandom(0, extent.y), + (float)uniformRandom(0, extent.z)); } else { - return - lo + + return + lo + Vector3( - (float)random(0, extent.x), + (float)uniformRandom(0, extent.x), d * extent.y, - (float)random(0, extent.z)); + (float)uniformRandom(0, extent.z)); } } + Vector3 AABox::randomInteriorPoint() const { return Vector3( - (float)random(lo.x, hi.x), - (float)random(lo.y, hi.y), - (float)random(lo.z, hi.z)); + (float)uniformRandom(lo.x, hi.x), + (float)uniformRandom(lo.y, hi.y), + (float)uniformRandom(lo.z, hi.z)); } -#endif + bool AABox::intersects(const AABox& other) const { // Must be overlap along all three axes. @@ -105,53 +137,35 @@ bool AABox::intersects(const AABox& other) const { return true; } -bool AABox::culledBy( - const Array<Plane>& plane, - int& cullingPlaneIndex, - const uint32 inMask, - uint32& outMask) const { - - return culledBy(plane.getCArray(), plane.size(), cullingPlaneIndex, inMask, outMask); -} - -bool AABox::culledBy( - const Array<Plane>& plane, - int& cullingPlaneIndex, - const uint32 inMask) const { - - return culledBy(plane.getCArray(), plane.size(), cullingPlaneIndex, inMask); -} - int AABox::dummy = 0; bool AABox::culledBy( - const class Plane* plane, - int numPlanes, - int& cullingPlane, - const uint32 _inMask, + const Array<Plane>& plane, + int& cullingPlane, + const uint32 _inMask, uint32& childMask) const { uint32 inMask = _inMask; - assert(numPlanes < 31); + assert(plane.size() < 31); childMask = 0; - const bool finite = - (abs(lo.x) < G3D::inf()) && - (abs(hi.x) < G3D::inf()) && - (abs(lo.y) < G3D::inf()) && - (abs(hi.y) < G3D::inf()) && - (abs(lo.z) < G3D::inf()) && - (abs(hi.z) < G3D::inf()); + const bool finite = + (abs(lo.x) < G3D::finf()) && + (abs(hi.x) < G3D::finf()) && + (abs(lo.y) < G3D::finf()) && + (abs(hi.y) < G3D::finf()) && + (abs(lo.z) < G3D::finf()) && + (abs(hi.z) < G3D::finf()); // See if there is one plane for which all of the - // vertices are in the negative half space. - for (int p = 0; p < numPlanes; p++) { - - // Only test planes that are not masked - if ((inMask & 1) != 0) { + // vertices are in the negative half space. + for (int p = 0; p < plane.size(); ++p) { - Vector3 corner; + // Only test planes that are not masked + if ((inMask & 1) != 0) { + + Vector3 corner; int numContained = 0; int v = 0; @@ -159,13 +173,13 @@ bool AABox::culledBy( // We can early-out only if we have found one point on each // side of the plane (i.e. if we are straddling). That // occurs when (numContained < v) && (numContained > 0) - for (v = 0; (v < 8) && ((numContained == v) || (numContained == 0)); ++v) { + for (v = 0; (v < 8) && ((numContained == v) || (numContained == 0)); ++v) { // Unrolling these 3 if's into a switch decreases performance // by about 2x - corner.x = (v & 1) ? hi.x : lo.x; - corner.y = (v & 2) ? hi.y : lo.y; - corner.z = (v & 4) ? hi.z : lo.z; - + corner.x = (v & 1) ? hi.x : lo.x; + corner.y = (v & 2) ? hi.y : lo.y; + corner.z = (v & 4) ? hi.z : lo.z; + if (finite) { // this branch is highly predictable if (plane[p].halfSpaceContainsFinite(corner)) { ++numContained; @@ -175,101 +189,102 @@ bool AABox::culledBy( ++numContained; } } - } + } - if (numContained == 0) { - // Plane p culled the box - cullingPlane = p; + if (numContained == 0) { + // Plane p culled the box + cullingPlane = p; // The caller should not recurse into the children, // since the parent is culled. If they do recurse, // make them only test against this one plane, which // will immediately cull the volume. childMask = 1 << p; - return true; + return true; } else if (numContained < v) { // The bounding volume straddled the plane; we have // to keep testing against this plane childMask |= (1 << p); } - } + } // Move on to the next bit. - inMask = inMask >> 1; + inMask = inMask >> 1; } // None of the planes could cull this box - cullingPlane = -1; + cullingPlane = -1; return false; } -bool AABox::culledBy( - const class Plane* plane, - int numPlanes, - int& cullingPlane, - const uint32 _inMask) const { - - uint32 inMask = _inMask; - assert(numPlanes < 31); - const bool finite = - (abs(lo.x) < G3D::inf()) && - (abs(hi.x) < G3D::inf()) && - (abs(lo.y) < G3D::inf()) && - (abs(hi.y) < G3D::inf()) && - (abs(lo.z) < G3D::inf()) && - (abs(hi.z) < G3D::inf()); +bool AABox::culledBy( + const Array<Plane>& plane, + int& cullingPlane, + const uint32 _inMask) const { + + uint32 inMask = _inMask; + assert(plane.size() < 31); + + const bool finite = + (abs(lo.x) < G3D::finf()) && + (abs(hi.x) < G3D::finf()) && + (abs(lo.y) < G3D::finf()) && + (abs(hi.y) < G3D::finf()) && + (abs(lo.z) < G3D::finf()) && + (abs(hi.z) < G3D::finf()); // See if there is one plane for which all of the - // vertices are in the negative half space. - for (int p = 0; p < numPlanes; p++) { - - // Only test planes that are not masked - if ((inMask & 1) != 0) { + // vertices are in the negative half space. + for (int p = 0; p < plane.size(); ++p) { - bool culled = true; - Vector3 corner; + // Only test planes that are not masked + if ((inMask & 1) != 0) { + + bool culled = true; + Vector3 corner; int v; - // Assume this plane culls all points. See if there is a point - // not culled by the plane... early out when at least one point + // Assume this plane culls all points. See if there is a point + // not culled by the plane... early out when at least one point // is in the positive half space. - for (v = 0; (v < 8) && culled; ++v) { + for (v = 0; (v < 8) && culled; ++v) { // Unrolling these 3 if's into a switch decreases performance // by about 2x - corner.x = (v & 1) ? hi.x : lo.x; - corner.y = (v & 2) ? hi.y : lo.y; - corner.z = (v & 4) ? hi.z : lo.z; - + corner.x = (v & 1) ? hi.x : lo.x; + corner.y = (v & 2) ? hi.y : lo.y; + corner.z = (v & 4) ? hi.z : lo.z; + if (finite) { // this branch is highly predictable culled = ! plane[p].halfSpaceContainsFinite(corner); } else { culled = ! plane[p].halfSpaceContains(corner); } - } + } - if (culled) { - // Plane p culled the box - cullingPlane = p; + if (culled) { + // Plane p culled the box + cullingPlane = p; - return true; + return true; } - } + } // Move on to the next bit. - inMask = inMask >> 1; + inMask = inMask >> 1; } // None of the planes could cull this box - cullingPlane = -1; + cullingPlane = -1; return false; } + bool AABox::intersects(const class Sphere& sphere) const { - double d = 0; + double d = 0; //find the square of the distance //from the sphere to the box @@ -284,5 +299,68 @@ bool AABox::intersects(const class Sphere& sphere) const { return d <= square(sphere.radius); } -} // namespace +Vector3 AABox::corner(int index) const { + + // default constructor inits all components to 0 + Vector3 v; + + switch (index) + { + case 0: + v.x = lo.x; + v.y = lo.y; + v.z = hi.z; + break; + + case 1: + v.x = hi.x; + v.y = lo.y; + v.z = hi.z; + break; + + case 2: + v.x = hi.x; + v.y = hi.y; + v.z = hi.z; + break; + + case 3: + v.x = lo.x; + v.y = hi.y; + v.z = hi.z; + break; + + case 4: + v.x = lo.x; + v.y = lo.y; + v.z = lo.z; + break; + + case 5: + v.x = hi.x; + v.y = lo.y; + v.z = lo.z; + break; + + case 6: + v.x = hi.x; + v.y = hi.y; + v.z = lo.z; + break; + + case 7: + v.x = lo.x; + v.y = hi.y; + v.z = lo.z; + break; + + default: + debugAssertM(false, "Invalid corner index"); + break; + } + + return v; +} + +} diff --git a/dep/src/g3dlite/Any.cpp b/dep/src/g3dlite/Any.cpp new file mode 100644 index 00000000000..de4d32e83ea --- /dev/null +++ b/dep/src/g3dlite/Any.cpp @@ -0,0 +1,1237 @@ +/** + @file Any.cpp + + @author Morgan McGuire + @author Shawn Yarbrough + + @created 2006-06-11 + @edited 2009-11-15 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/Any.h" +#include "G3D/TextOutput.h" +#include "G3D/TextInput.h" +#include "G3D/stringutils.h" +#include <deque> +#include <iostream> + +namespace G3D { + +void Any::beforeRead() const { + if (isPlaceholder()) { + // Tried to read from a placeholder--throw an exception as if + // the original operator[] had failed. + KeyNotFound e; + alwaysAssertM(m_data, "Corrupt placeholder"); + + e.filename = m_data->source.filename; + e.line = m_data->source.line; + e.character = m_data->source.character; + e.key = m_placeholderName; + e.message = + "This exception may have been thrown later than " + "the actual operator[] invocation."; + + throw e; + } +} + + +Any::Data* Any::Data::create(const Data* d) { + Data* p = create(d->type); + + p->comment = d->comment; + p->name = d->name; + + switch (d->type) { + case NONE: + case BOOLEAN: + case NUMBER: + // No clone needed + break; + + case STRING: + *(p->value.s) = *(d->value.s); + break; + + case ARRAY: + *(p->value.a) = *(d->value.a); + break; + + case TABLE: + *(p->value.t) = *(d->value.t); + // Note that placeholders may be copied; that is ok--they are still + // just placeholders. + break; + } + + return p; +} + + +Any::Data* Any::Data::create(Any::Type t) { + size_t s = sizeof(Data); + + switch (t) { + case NONE: + case BOOLEAN: + case NUMBER: + // No extra space needed + break; + + case STRING: + s += sizeof(std::string); + break; + + case ARRAY: + s += sizeof(AnyArray); + break; + + case TABLE: + s += sizeof(AnyTable); + break; + } + + // Allocate the data object + Data* p = new (MemoryManager::create()->alloc(s)) Data(t); + + // Create the (empyt) value object at the end of the Data object + switch (t) { + case NONE: + case BOOLEAN: + case NUMBER: + // No value + break; + + case STRING: + p->value.s = new (p + 1) std::string(); + break; + + case ARRAY: + p->value.a = new (p + 1) AnyArray(); + break; + + case TABLE: + p->value.t = new (p + 1) AnyTable(); + break; + } + + return p; +} + + +void Any::Data::destroy(Data* d) { + if (d != NULL) { + d->~Data(); + MemoryManager::create()->free(d); + } +} + + +Any::Data::~Data() { + debugAssertM(referenceCount.value() <= 0, "Deleted while still referenced."); + + // Destruct but do not deallocate children + switch (type) { + case STRING: + debugAssert(value.s != NULL); + value.s->~basic_string(); + break; + + case ARRAY: + debugAssert(value.a != NULL); + value.a->~Array(); + break; + + case TABLE: + debugAssert(value.t != NULL); + value.t->~Table(); + break; + + default: + // All other types should have a NULL value pointer (i.e., they were used just for name and comment fields) + debugAssertM(value.s == NULL, "Corrupt Any::Data::Value"); + } + + value.s = NULL; +} + + +////////////////////////////////////////////////////////////// + +bool Any::containsKey(const std::string& x) const { + beforeRead(); + verifyType(TABLE); + + Any* a = m_data->value.t->getPointer(x); + + // Don't return true for placeholder objects + return (a != NULL) && (! a->isPlaceholder()); +} + + +void Any::dropReference() { + if (m_data && m_data->referenceCount.decrement() <= 0) { + // This was the last reference to the shared data + Data::destroy(m_data); + } + m_data = NULL; +} + + +void Any::ensureMutable() { + if (m_data && (m_data->referenceCount.value() >= 1)) { + // Copy the data. We must do this before dropping the reference + // to avoid a race condition + Data* d = Data::create(m_data); + dropReference(); + m_data = d; + } +} + + +Any::Any() : m_type(NONE), m_data(NULL) { +} + + +Any::Any(TextInput& t) : m_type(NONE), m_data(NULL) { + deserialize(t); +} + + +Any::Any(const Any& x) : m_type(NONE), m_data(NULL) { + x.beforeRead(); + *this = x; +} + + +Any::Any(double x) : m_type(NUMBER), m_simpleValue(x), m_data(NULL) { +} + + +#ifdef G3D_32BIT +Any::Any(int64 x) : m_type(NUMBER), m_simpleValue((double)x), m_data(NULL) { +} +#endif // G3D_32BIT + + +Any::Any(long x) : m_type(NUMBER), m_simpleValue((double)x), m_data(NULL) { +} + + +Any::Any(int x) : m_type(NUMBER), m_simpleValue((double)x), m_data(NULL) { +} + + +Any::Any(short x) : m_type(NUMBER), m_simpleValue((double)x), m_data(NULL) { +} + + +Any::Any(bool x) : m_type(BOOLEAN), m_simpleValue(x), m_data(NULL) { +} + + +Any::Any(const std::string& s) : m_type(STRING), m_data(Data::create(STRING)) { + *(m_data->value.s) = s; +} + + +Any::Any(const char* s) : m_type(STRING), m_data(NULL) { + if (s == NULL) { + m_type = NONE; + } else { + ensureData(); + *(m_data->value.s) = s; + } +} + + +Any::Any(Type t, const std::string& name) : m_type(t), m_data(NULL) { + alwaysAssertM(t == ARRAY || t == TABLE, "Can only create ARRAY or TABLE from Type enum."); + + ensureData(); + if (name != "") { + m_data->name = name; + } +} + + +Any::~Any() { + dropReference(); +} + + +void Any::beforeWrite() { + if (isPlaceholder()) { + // This is no longer a placeholder + m_placeholderName = ""; + } +} + +Any& Any::operator=(const Any& x) { + x.beforeRead(); + + if (this == &x) { + return *this; + } + + beforeWrite(); + + dropReference(); + + m_type = x.m_type; + m_simpleValue = x.m_simpleValue; + + if (x.m_data != NULL) { + x.m_data->referenceCount.increment(); + m_data = x.m_data; + } + + return *this; +} + + +Any& Any::operator=(double x) { + *this = Any(x); + return *this; +} + + +Any& Any::operator=(int x) { + return (*this = Any(x)); +} + + +Any& Any::operator=(bool x) { + *this = Any(x); + return *this; +} + + +Any& Any::operator=(const std::string& x) { + *this = Any(x); + return *this; +} + + +Any& Any::operator=(const char* x) { + *this = Any(x); + return *this; +} + + +Any& Any::operator=(Type t) { + switch (t) { + case NONE: + *this = Any(); + break; + + case TABLE: + case ARRAY: + *this = Any(t); + break; + + default: + alwaysAssertM(false, "Can only assign NONE, TABLE, or ARRAY Type enum."); + } + + return *this; +} + + +Any::Type Any::type() const { + beforeRead(); + return m_type; +} + + +const std::string& Any::comment() const { + beforeRead(); + + static const std::string blank; + if (m_data != NULL) { + return m_data->comment; + } else { + return blank; + } +} + + +void Any::setComment(const std::string& c) { + beforeRead(); + ensureData(); + m_data->comment = c; +} + + +bool Any::isNone() const { + beforeRead(); + return (m_type == NONE); +} + + +double Any::number() const { + beforeRead(); + verifyType(NUMBER); + return m_simpleValue.n; +} + + +const std::string& Any::string() const { + beforeRead(); + verifyType(STRING); + return *(m_data->value.s); +} + + +bool Any::boolean() const { + beforeRead(); + verifyType(BOOLEAN); + return m_simpleValue.b; +} + + +const std::string& Any::name() const { + beforeRead(); + static const std::string blank; + if (m_data != NULL) { + return m_data->name; + } else { + return blank; + } +} + + +void Any::setName(const std::string& n) { + beforeRead(); + ensureData(); + m_data->name = n; +} + + +int Any::size() const { + beforeRead(); + verifyType(ARRAY, TABLE); + switch (m_type) { + case TABLE: + return m_data->value.t->size(); + + case ARRAY: + return m_data->value.a->size(); + + default:; + return 0; + } // switch (m_type) +} + + +int Any::length() const { + beforeRead(); + return size(); +} + + +void Any::resize(int n) { + beforeRead(); + alwaysAssertM(n >= 0, "Cannot resize less than 0."); + verifyType(ARRAY); + m_data->value.a->resize(n); +} + + +void Any::clear() { + beforeRead(); + verifyType(ARRAY, TABLE); + switch (m_type) { + case ARRAY: + m_data->value.a->clear(); + break; + + case TABLE: + m_data->value.t->clear(); + break; + + default:; + } +} + + +const Any& Any::operator[](int i) const { + beforeRead(); + verifyType(ARRAY); + debugAssert(m_data != NULL); + Array<Any>& array = *(m_data->value.a); + return array[i]; +} + + +Any& Any::next() { + beforeRead(); + verifyType(ARRAY); + int n = size(); + resize(n + 1); + return (*this)[n]; +} + + +Any& Any::operator[](int i) { + beforeRead(); + verifyType(ARRAY); + debugAssert(m_data != NULL); + Array<Any>& array = *(m_data->value.a); + return array[i]; +} + + +const Array<Any>& Any::array() const { + beforeRead(); + verifyType(ARRAY); + debugAssert(m_data != NULL); + return *(m_data->value.a); +} + + +void Any::append(const Any& x0) { + beforeRead(); + verifyType(ARRAY); + debugAssert(m_data != NULL); + m_data->value.a->append(x0); +} + + +void Any::append(const Any& x0, const Any& x1) { + beforeRead(); + append(x0); + append(x1); +} + + +void Any::append(const Any& x0, const Any& x1, const Any& x2) { + beforeRead(); + append(x0); + append(x1); + append(x2); +} + + +void Any::append(const Any& x0, const Any& x1, const Any& x2, const Any& x3) { + beforeRead(); + append(x0); + append(x1); + append(x2); + append(x3); +} + + +const Table<std::string, Any>& Any::table() const { + beforeRead(); + verifyType(TABLE); + debugAssert(m_data != NULL); + return *(m_data->value.t); +} + + +const Any& Any::operator[](const std::string& x) const { + beforeRead(); + verifyType(TABLE); + debugAssert(m_data != NULL); + const Table<std::string, Any>& table = *(m_data->value.t); + Any* value = table.getPointer(x); + if (value == NULL) { + KeyNotFound e; + if (m_data) { + e.filename = m_data->source.filename; + e.line = m_data->source.line; + e.character = m_data->source.character; + } + e.key = x; + throw e; + } + return *value; +} + + +Any& Any::operator[](const std::string& key) { + beforeRead(); + verifyType(TABLE); + + bool created = false; + Any& value = m_data->value.t->getCreate(key, created); + + if (created) { + // The entry was created by this method; do not allow it to be + // read before it is written. + value.m_placeholderName = key; + + // Write source data for the value + value.ensureData(); + value.m_data->source = source(); + } + + return value; +} + + +void Any::set(const std::string& k, const Any& v) { + beforeRead(); + v.beforeRead(); + verifyType(TABLE); + debugAssert(m_data != NULL); + Table<std::string, Any>& table = *(m_data->value.t); + table.set(k, v); +} + + +const Any& Any::get(const std::string& x, const Any& defaultVal) const { + beforeRead(); + defaultVal.beforeRead(); + try { + return operator[](x); + } catch(KeyNotFound) { + return defaultVal; + } +} + + +bool Any::operator==(const Any& x) const { + beforeRead(); + x.beforeRead(); + if (m_type != x.m_type) { + return false; + } + + switch (m_type) { + case NONE: + return true; + + case BOOLEAN: + return (m_simpleValue.b == x.m_simpleValue.b); + + case NUMBER: + return (m_simpleValue.n == x.m_simpleValue.n); + + case STRING: + debugAssert(m_data != NULL); + return (*(m_data->value.s) == *(x.m_data->value.s)); + + case TABLE: { + if (size() != x.size()) { + return false; + } + debugAssert(m_data != NULL); + if (m_data->name != x.m_data->name) { + return false; + } + Table<std::string, Any>& cmptable = *( m_data->value.t); + Table<std::string, Any>& xcmptable = *(x.m_data->value.t); + for (Table<std::string,Any>::Iterator it1 = cmptable.begin(), it2 = xcmptable.begin(); + it1 != cmptable.end() && it2 != xcmptable.end(); + ++it1, ++it2) { + if (*it1 != *it2) { + return false; + } + } + return true; + } + + case ARRAY: { + if (size() != x.size()) { + return false; + } + debugAssert(m_data != NULL); + if (m_data->name != x.m_data->name) { + return false; + } + + Array<Any>& cmparray = *( m_data->value.a); + Array<Any>& xcmparray = *(x.m_data->value.a); + + for (int ii = 0; ii < size(); ++ii) { + if (cmparray[ii] != xcmparray[ii]) { + return false; + } + } + return true; + } + + default: + alwaysAssertM(false, "Unknown type."); + return false; + } // switch (m_type) + +} + + +bool Any::operator!=(const Any& x) const { + beforeRead(); + x.beforeRead(); + return !operator==(x); +} + + +static void getDeserializeSettings(TextInput::Settings& settings) { + settings.cppBlockComments = true; + settings.cppLineComments = true; + settings.otherLineComments = true; + settings.otherCommentCharacter = '#'; + settings.generateCommentTokens = true; + settings.singleQuotedStrings = false; + settings.msvcSpecials = false; + settings.caseSensitive = false; +} + + +std::string Any::unparse() const { + beforeRead(); + TextOutput::Settings settings; + TextOutput to(settings); + serialize(to); + return to.commitString(); +} + + +void Any::parse(const std::string& src) { + beforeRead(); + TextInput::Settings settings; + getDeserializeSettings(settings); + + TextInput ti(TextInput::FROM_STRING, src, settings); + deserialize(ti); +} + + +void Any::load(const std::string& filename) { + beforeRead(); + TextInput::Settings settings; + getDeserializeSettings(settings); + + TextInput ti(filename, settings); + deserialize(ti); +} + + +void Any::save(const std::string& filename) const { + beforeRead(); + TextOutput::Settings settings; + settings.wordWrap = TextOutput::Settings::WRAP_NONE; + + TextOutput to(filename,settings); + serialize(to); + to.commit(); +} + + +static bool needsQuotes(const std::string& s) { + if (! isLetter(s[0]) && (s[0] != '_')) { + return true; + } + + for (int i = 0; i < (int)s.length(); ++i) { + char c = s[i]; + + // peek character + char p = (i == (int)s.length() - 1) ? '_' : s[i + 1]; + + // Identify separators + if ((c == '-' && p == '>') || + (c == ':' && p == ':')) { + // Skip over this symbol + ++i; + continue; + } + + if (! isDigit(c) && ! isLetter(c) & (c != '.')) { + // This is an illegal character for an identifier, so we need quotes + return true; + } + } + + return false; +} + + +// TODO: if the output will fit on one line, compress tables and arrays into a single line +void Any::serialize(TextOutput& to) const { + beforeRead(); + if (m_data && ! m_data->comment.empty()) { + to.printf("\n/* %s */\n", m_data->comment.c_str()); + } + + switch (m_type) { + case NONE: + to.writeSymbol("NONE"); + break; + + case BOOLEAN: + to.writeBoolean(m_simpleValue.b); + break; + + case NUMBER: + to.writeNumber(m_simpleValue.n); + break; + + case STRING: + debugAssert(m_data != NULL); + to.writeString(*(m_data->value.s)); + break; + + case TABLE: { + debugAssert(m_data != NULL); + if (! m_data->name.empty()) { + if (needsQuotes(m_data->name)) { + to.writeString(m_data->name); + } else { + to.writeSymbol(m_data->name); + } + } + to.writeSymbol("{"); + to.writeNewline(); + to.pushIndent(); + AnyTable& table = *(m_data->value.t); + Array<std::string> keys; + table.getKeys(keys); + keys.sort(); + + for (int i = 0; i < keys.size(); ++i) { + + to.writeSymbol(keys[i]); + to.writeSymbol("="); + table[keys[i]].serialize(to); + + if (i < keys.size() - 1) { + to.writeSymbol(","); + } + to.writeNewline(); + + // Skip a line between table entries + to.writeNewline(); + } + + to.popIndent(); + to.writeSymbol("}"); + break; + } + + case ARRAY: { + debugAssert(m_data != NULL); + if (! m_data->name.empty()) { + // For arrays, leave no trailing space between the name and the paren + to.writeSymbol(format("%s(", m_data->name.c_str())); + } else { + to.writeSymbol("("); + } + to.writeNewline(); + to.pushIndent(); + Array<Any>& array = *(m_data->value.a); + for (int ii = 0; ii < size(); ++ii) { + array[ii].serialize(to); + if (ii < size() - 1) { + to.writeSymbol(","); + to.writeNewline(); + } + + // Put the close paren on an array right behind the last element + } + to.popIndent(); + to.writeSymbol(")"); + break; + } + } +} + + +void Any::deserializeComment(TextInput& ti, Token& token, std::string& comment) { + // Parse comments + while (token.type() == Token::COMMENT) { + comment += trimWhitespace(token.string()) + "\n"; + + // Allow comments to contain newlines. + do { + token = ti.read(); + comment += "\n"; + } while (token.type() == Token::NEWLINE); + } + + comment = trimWhitespace(comment); +} + +/** True if \a c is an open paren of some form */ +static bool isOpen(const char c) { + return c == '(' || c == '[' || c == '{'; +} + + +/** True if \a c is an open paren of some form */ +static bool isClose(const char c) { + return c == ')' || c == ']' || c == '}'; +} + + +/** True if \a s is a C++ name operator */ +static bool isNameOperator(const std::string& s) { + return s == "." || s == "::" || s == "->"; +} + + +void Any::deserializeName(TextInput& ti, Token& token, std::string& name) { + debugAssert(token.type() == Token::SYMBOL); + std::string s = token.string(); + while (! isOpen(s[0])) { + name += s; + + // Skip newlines and comments + token = ti.readSignificant(); + + if (token.type() != Token::SYMBOL) { + throw ParseError(ti.filename(), token.line(), token.character(), + "Expected symbol while parsing Any"); + } + s = token.string(); + } +} + + +void Any::deserialize(TextInput& ti) { + beforeRead(); + Token token = ti.read(); + deserialize(ti, token); + // Restore the last token + ti.push(token); +} + + +void Any::deserialize(TextInput& ti, Token& token) { + // Deallocate old data + dropReference(); + m_type = NONE; + m_simpleValue.b = false; + + // Skip leading newlines + while (token.type() == Token::NEWLINE) { + token = ti.read(); + } + + std::string comment; + if (token.type() == Token::COMMENT) { + deserializeComment(ti, token, comment); + } + + if (token.type() == Token::END) { + // There should never be a comment without an Any following it; even + // if the file ends with some commented out stuff, + // that should not happen after a comma, so we'd never read that + // far in a proper file. + throw ParseError(ti.filename(), token.line(), token.character(), + "File ended without a properly formed Any"); + } + + switch (token.type()) { + case Token::STRING: + m_type = STRING; + ensureData(); + *(m_data->value.s) = token.string(); + m_data->source.set(ti, token); + break; + + case Token::NUMBER: + m_type = NUMBER; + m_simpleValue.n = token.number(); + ensureData(); + m_data->source.set(ti, token); + break; + + case Token::BOOLEAN: + m_type = BOOLEAN; + m_simpleValue.b = token.boolean(); + ensureData(); + m_data->source.set(ti, token); + break; + + case Token::SYMBOL: + // Named Array, Named Table, Array, Table, or NONE + if (toUpper(token.string()) == "NONE") { + // Nothing left to do; we initialized to NONE originally + ensureData(); + m_data->source.set(ti, token); + } else { + // Array or Table + + // Parse the name + + // s must have at least one element or this would not have + // been parsed as a symbol + std::string name; + deserializeName(ti, token, name); + if (token.type() != Token::SYMBOL) { + throw ParseError(ti.filename(), token.line(), token.character(), + "Malformed Any TABLE or ARRAY; must start with [, (, or {"); + } + + if (isOpen(token.string()[0])) { + // Array or table + deserializeBody(ti, token); + } else { + throw ParseError(ti.filename(), token.line(), token.character(), + "Malformed Any TABLE or ARRAY; must start with [, (, or {"); + } + + if (! name.empty()) { + ensureData(); + m_data->name = name; + } + } // if NONE + break; + + default: + throw ParseError(ti.filename(), token.line(), token.character(), + "Unexpected token"); + + } // switch + + if (! comment.empty()) { + ensureData(); + m_data->comment = comment; + } + + if (m_type != ARRAY && m_type != TABLE) { + // Array and table already consumed their last token + token = ti.read(); + } +} + + +void Any::ensureData() { + if (m_data == NULL) { + m_data = Data::create(m_type); + } +} + + +static bool isSeparator(char c) { + return c == ',' || c == ';'; +} + + +void Any::readUntilCommaOrClose(TextInput& ti, Token& token) { + while (! ((token.type() == Token::SYMBOL) && + (isClose(token.string()[0])) || + isSeparator(token.string()[0]))) { + switch (token.type()) { + case Token::NEWLINE: + case Token::COMMENT: + // Consume + token = ti.read(); + break; + + default: + throw ParseError(ti.filename(), token.line(), token.character(), + "Expected a comma or close paren"); + } + } +} + + +void Any::deserializeBody(TextInput& ti, Token& token) { + char closeSymbol = '}'; + m_type = TABLE; + + const char c = token.string()[0]; + + if (c != '{') { + m_type = ARRAY; + // Chose the appropriate close symbol + closeSymbol = (c == '(') ? ')' : ']'; + } + + // Allocate the underlying data structure + ensureData(); + m_data->source.set(ti, token); + + // Consume the open token + token = ti.read(); + + while (! ((token.type() == Token::SYMBOL) && (token.string()[0] == closeSymbol))) { + + // Read any leading comment. This must be done here (and not in the recursive deserialize + // call) in case the body contains only a comment. + std::string comment; + deserializeComment(ti, token, comment); + + if ((token.type() == Token::SYMBOL) && (token.string()[0] == closeSymbol)) { + // We're done; this catches the case where the array is empty + break; + } + + // Pointer the value being read + Any a = NULL; + std::string key; + + if (m_type == TABLE) { + // Read the key + if (token.type() != Token::SYMBOL && token.type() != Token::STRING) { + throw ParseError(ti.filename(), token.line(), token.character(), "Expected a name"); + } + + key = token.string(); + // Consume everything up to the = sign + token = ti.readSignificant(); + + if ((token.type() != Token::SYMBOL) || (token.string() != "=")) { + throw ParseError(ti.filename(), token.line(), token.character(), "Expected ="); + } else { + // Consume (don't consume comments--we want the value pointed to by a to get those). + token = ti.read(); + } + } + a.deserialize(ti, token); + + if (! comment.empty()) { + // Prepend the comment we read earlier + a.ensureData(); + a.m_data->comment = trimWhitespace(comment + "\n" + a.m_data->comment); + } + + if (m_type == TABLE) { + set(key, a); + } else { + append(a); + } + + // Read until the comma or close paren, discarding trailing comments and newlines + readUntilCommaOrClose(ti, token); + + // Consume the comma + if (isSeparator(token.string()[0])) { + token = ti.read(); + } + } + + // Consume the close paren (to match other deserialize methods) + token = ti.read(); +} + + +Any::operator int() const { + beforeRead(); + return iRound(number()); +} + + +Any::operator float() const { + beforeRead(); + return float(number()); +} + + +Any::operator double() const { + beforeRead(); + return number(); +} + + +Any::operator bool() const { + beforeRead(); + return boolean(); +} + + +Any::operator std::string() const { + beforeRead(); + return string(); +} + + +const Any::Source& Any::source() const { + static Source s; + if (m_data) { + return m_data->source; + } else { + return s; + } +} + + +void Any::verify(bool value, const std::string& message) const { + beforeRead(); + if (! value) { + ParseError p; + if (m_data) { + p.filename = m_data->source.filename; + p.line = m_data->source.line; + p.character = m_data->source.character; + } + + if (name().empty()) { + p.message = "Parse error"; + } else { + p.message = "Parse error while reading the contents of " + name(); + } + + if (! message.empty()) { + p.message = p.message + ": " + message; + } + + throw p; + } +} + + +void Any::verifyName(const std::string& n) const { + beforeRead(); + verify(beginsWith(toUpper(name()), toUpper(n)), "Name must begin with " + n); +} + + +void Any::verifyType(Type t) const { + beforeRead(); + if (type() != t) { + verify(false, "Must have type " + toString(t)); + } +} + + +void Any::verifyType(Type t0, Type t1) const { + beforeRead(); + if (type() != t0 && type() != t1) { + verify(false, "Must have type " + toString(t0) + " or " + toString(t1)); + } +} + + +void Any::verifySize(int low, int high) const { + beforeRead(); + verifyType(ARRAY, TABLE); + if (size() < low || size() > high) { + verify(false, format("Size must be between %d and %d", low, high)); + } +} + + +void Any::verifySize(int s) const { + beforeRead(); + verifyType(ARRAY, TABLE); + if (size() != s) { + verify(false, format("Size must be %d", s)); + } +} + + +std::string Any::toString(Type t) { + switch(t) { + case NONE: return "NONE"; + case BOOLEAN: return "BOOLEAN"; + case NUMBER: return "NUMBER"; + case STRING: return "STRING"; + case ARRAY: return "ARRAY"; + case TABLE: return "TABLE"; + default: + alwaysAssertM(false, "Illegal Any::Type"); + return ""; + } +} + +} // namespace G3D + diff --git a/dep/src/g3dlite/AnyVal.cpp b/dep/src/g3dlite/AnyVal.cpp new file mode 100644 index 00000000000..7b98486523a --- /dev/null +++ b/dep/src/g3dlite/AnyVal.cpp @@ -0,0 +1,1379 @@ +/** + @file AnyVal.cpp + @author Morgan McGuire + @maintainer Morgan McGuire + @created 2006-06-11 + @edited 2008-07-14 + */ + +#include "G3D/AnyVal.h" +#include "G3D/Array.h" +#include "G3D/stringutils.h" +#include "G3D/Table.h" +#include "G3D/Vector2.h" +#include "G3D/Vector3.h" +#include "G3D/Vector4.h" +#include "G3D/Color1.h" +#include "G3D/Color3.h" +#include "G3D/Color4.h" +#include "G3D/Matrix2.h" +#include "G3D/Matrix3.h" +#include "G3D/Matrix4.h" +#include "G3D/Rect2D.h" +#include "G3D/AABox.h" +#include "G3D/CoordinateFrame.h" +#include "G3D/Quat.h" +#include "G3D/TextInput.h" +#include "G3D/TextOutput.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +AnyVal AnyVal::fromFile(const std::string& filename) { + TextInput t(filename); + return AnyVal(t); +} + + +void AnyVal::load(const std::string& filename) { + *this = fromFile(filename); +} + + +void AnyVal::save(const std::string& filename) const { + TextOutput t(filename); + serialize(t); + t.commit(); +} + + +AnyVal::AnyVal() : m_type(NIL), m_value(NULL), m_referenceCount(NULL) { +} + + +AnyVal::AnyVal(bool b) : m_type(BOOLEAN), m_value(new bool(b)), m_referenceCount(NULL) { +} + + +AnyVal::AnyVal(G3D::TextInput& t) : m_type(NIL), m_value(NULL), m_referenceCount(NULL) { + deserialize(t); +} + + +/*AnyVal::AnyVal(G3D::BinaryInput& b) { + deserialize(b); +} +*/ + +AnyVal::AnyVal(double v) : m_type(NUMBER), m_referenceCount(NULL) { + m_value = new double(v); +} + + +AnyVal::AnyVal(int v) : m_type(NUMBER), m_referenceCount(NULL) { + m_value = new double(v); +} + + +AnyVal::AnyVal(const Rect2D& v) : m_type(RECT2D), m_referenceCount(NULL) { + m_value = new Rect2D(v); +} + + +AnyVal::AnyVal(const AABox& v) : m_type(AABOX), m_referenceCount(NULL) { + m_value = new AABox(v); +} + + +AnyVal::AnyVal(const Vector2& v) : m_type(VECTOR2), m_referenceCount(NULL) { + m_value = new Vector2(v); +} + + +AnyVal::AnyVal(const Vector3& v) : m_type(VECTOR3), m_referenceCount(NULL) { + m_value = new Vector3(v); +} + + +AnyVal::AnyVal(const Vector4& v) : m_type(VECTOR4), m_referenceCount(NULL) { + m_value = new Vector4(v); +} + + +AnyVal::AnyVal(const Color1& v) : m_type(COLOR1), m_referenceCount(NULL) { + m_value = new Color1(v); +} + + +AnyVal::AnyVal(const Color3& v) : m_type(COLOR3), m_referenceCount(NULL) { + m_value = new Color3(v); +} + + +AnyVal::AnyVal(const Color4& v) : m_type(COLOR4), m_referenceCount(NULL) { + m_value = new Color4(v); +} + + +AnyVal::AnyVal(const std::string& v) : m_type(STRING), m_referenceCount(NULL) { + m_value = new std::string(v); +} + + +AnyVal::AnyVal(const char* v) : m_type(STRING), m_referenceCount(NULL) { + m_value = new std::string(v); +} + + +AnyVal::AnyVal(const Quat& v) : m_type(QUAT), m_referenceCount(NULL) { + m_value = new Quat(v); +} + + +AnyVal::AnyVal(const CoordinateFrame& v) : m_type(COORDINATEFRAME), m_referenceCount(NULL) { + m_value = new CoordinateFrame(v); +} + + +AnyVal::AnyVal(const Matrix2& v) : m_type(MATRIX2), m_referenceCount(NULL) { + m_value = new Matrix2(v); +} + +AnyVal::AnyVal(const Matrix3& v) : m_type(MATRIX3), m_referenceCount(NULL) { + m_value = new Matrix3(v); +} + + +AnyVal::AnyVal(const Matrix4& v) : m_type(MATRIX4), m_referenceCount(NULL) { + m_value = new Matrix4(v); +} + + +AnyVal::AnyVal(const AnyVal& c) : m_type(NIL), m_value(NULL), m_referenceCount(NULL) { + *this = c; +} + + +AnyVal::AnyVal(Type arrayOrTable) : m_type(NIL), m_value(NULL), m_referenceCount(new int(1)) { + // TODO: make AnyVal::createArray() + switch (arrayOrTable) { + case ARRAY: + m_type = ARRAY; + m_value = new Array<AnyVal>(); + break; + + case TABLE: + m_type = TABLE; + m_value = new Table<std::string, AnyVal>(); + break; + + default: + debugAssertM(false, "Cannot construct AnyVal from constants except ARRAY or TABLE."); + } +} + + +AnyVal::~AnyVal() { + deleteValue(); +} + + +void AnyVal::deleteValue() { + if (m_referenceCount) { + --(*m_referenceCount); + if (*m_referenceCount <= 0) { + delete m_referenceCount; + m_referenceCount = NULL; + // Pass through and delete the real object now + } else { + // Someone else is holding a reference, so we can't delete + // the object. + m_referenceCount = NULL; + return; + } + } + + switch (m_type) { + case NIL: + // Nothing to do + break; + + case NUMBER: + delete (double*)m_value; + break; + + case BOOLEAN: + delete (bool*)m_value; + break; + + case STRING: + delete (std::string*)m_value; + break; + + case RECT2D: + delete (Rect2D*)m_value; + break; + + case AABOX: + delete (AABox*)m_value; + break; + + case VECTOR2: + delete (Vector2*)m_value; + break; + + case VECTOR3: + delete (Vector3*)m_value; + break; + + case VECTOR4: + delete (Vector4*)m_value; + break; + + case MATRIX2: + delete (Matrix2*)m_value; + break; + + case MATRIX3: + delete (Matrix3*)m_value; + break; + + case MATRIX4: + delete (Matrix4*)m_value; + break; + + case QUAT: + delete (Quat*)m_value; + break; + + case COORDINATEFRAME: + delete (CoordinateFrame*)m_value; + break; + + case COLOR1: + delete (Color1*)m_value; + break; + + case COLOR3: + delete (Color3*)m_value; + break; + + case COLOR4: + delete (Color4*)m_value; + break; + + case ARRAY: + delete (Array<AnyVal>*)m_value; + break; + + case TABLE: + delete (Table<std::string, AnyVal>*)m_value; + break; + + default: + debugAssertM(false, "Internal error: no destructor for this type."); + } + + m_value = NULL; +} + + +AnyVal& AnyVal::operator=(const AnyVal& v) { + deleteValue(); + + m_type = v.m_type; + + m_referenceCount = v.m_referenceCount; + + if (isSharedType()) { + ++(*m_referenceCount); + m_value = v.m_value; + } else { + m_value = v.copyValue(); + } + + return *this; +} + + +void* AnyVal::copyValue() const { + switch (m_type) { + case NIL: + return NULL; + + case NUMBER: + return new double(*(double*)m_value); + + case BOOLEAN: + return new bool(*(bool*)m_value); + + case STRING: + return new std::string(*(std::string*)m_value); + + case RECT2D: + return new Rect2D(*(Rect2D*)m_value); + + case AABOX: + return new AABox(*(AABox*)m_value); + + case VECTOR2: + return new Vector2(*(Vector2*)m_value); + + case VECTOR3: + return new Vector3(*(Vector3*)m_value); + + case VECTOR4: + return new Vector4(*(Vector4*)m_value); + + case MATRIX2: + return new Matrix2(*(Matrix2*)m_value); + + case MATRIX3: + return new Matrix3(*(Matrix3*)m_value); + + case MATRIX4: + return new Matrix4(*(Matrix4*)m_value); + + case QUAT: + return new Quat(*(Quat*)m_value); + + case COORDINATEFRAME: + return new CoordinateFrame(*(CoordinateFrame*)m_value); + + case COLOR1: + return new Color1(*(Color1*)m_value); + + case COLOR3: + return new Color3(*(Color3*)m_value); + + case COLOR4: + return new Color4(*(Color4*)m_value); + + case ARRAY: + return new Array<AnyVal>(*(Array<AnyVal>*)m_value); + + case TABLE: + return new Table<std::string, AnyVal>(*(Table<std::string, AnyVal>*)m_value); + + default: + debugAssertM(false, "Internal error: no assignment operator for this type."); + return NULL; + } +} + +AnyVal::Type AnyVal::type() const { + return m_type; +} + + +static bool legalIdentifier(const std::string& s) { + if (s.size() == 0) { + return false; + } + + if (! isLetter(s[0]) || (s[0] == '_')) { + return false; + } + + bool ok = true; + + for (unsigned int i = 1; i < s.size(); ++i) { + ok &= isDigit(s[i]) || isLetter(s[i]) || (s[i] == '_'); + } + + return ok; +} + + +void AnyVal::serialize(G3D::TextOutput& t) const { + switch (m_type) { + case NIL: + t.writeSymbol("Nil"); + break; + + case NUMBER: + t.printf("%g", *(double*)m_value); + break; + + case BOOLEAN: + t.writeBoolean(*(bool*)m_value); + break; + + case STRING: + t.writeString(*(std::string*)m_value); + break; + + case RECT2D: + t.printf("R(%g, %g, %g, %g)", ((Rect2D*)m_value)->x0(), ((Rect2D*)m_value)->y0(), + ((Rect2D*)m_value)->width(), ((Rect2D*)m_value)->height()); + break; + + case AABOX: + t.printf("AAB(V3(%g, %g, %g), V3(%g, %g, %g))", + aabox().low().x, + aabox().low().y, + aabox().low().z, + aabox().high().x, + aabox().high().y, + aabox().high().z); + break; + + case VECTOR2: + t.printf("V2(%g, %g)", ((Vector2*)m_value)->x, ((Vector2*)m_value)->y); + break; + + case VECTOR3: + t.printf("V3(%g, %g, %g)", ((Vector3*)m_value)->x, ((Vector3*)m_value)->y, ((Vector3*)m_value)->z); + break; + + case VECTOR4: + t.printf("V4(%g, %g, %g, %g)", ((Vector4*)m_value)->x, ((Vector4*)m_value)->y, ((Vector4*)m_value)->z, ((Vector4*)m_value)->w); + break; + + case MATRIX2: + { + const Matrix2& m = *(Matrix2*)m_value; + t.printf("M2(\n"); + t.pushIndent(); + t.printf("%10.5f, %10.5f,\n%10.5f, %10.5f)", + m[0][0], m[0][1], + m[1][0], m[1][1]); + t.popIndent(); + } + break; + + case MATRIX3: + { + const Matrix3& m = *(Matrix3*)m_value; + t.printf("M3(\n"); + t.pushIndent(); + t.printf("%10.5f, %10.5f, %10.5f,\n%10.5f, %10.5f, %10.5f,\n%10.5f, %10.5f, %10.5f)", + m[0][0], m[0][1], m[0][2], + m[1][0], m[1][1], m[1][2], + m[2][0], m[2][1], m[2][2]); + t.popIndent(); + } + break; + + case MATRIX4: + { + const Matrix4& m = *(Matrix4*)m_value; + t.printf("M4(\n"); + t.pushIndent(); + t.printf( + "%10.5f, %10.5f, %10.5f, %10.5f,\n" + "%10.5f, %10.5f, %10.5f, %10.5f,\n" + "%10.5f, %10.5f, %10.5f, %10.5f,\n" + "%10.5f, %10.5f, %10.5f, %10.5f)", + m[0][0], m[0][1], m[0][2], m[0][3], + m[1][0], m[1][1], m[1][2], m[1][3], + m[2][0], m[2][1], m[2][2], m[2][3], + m[3][0], m[3][1], m[3][2], m[3][3]); + t.popIndent(); + } + break; + + case QUAT: + t.printf("Q(%g, %g, %g, %g)", ((Quat*)m_value)->x, ((Quat*)m_value)->y, ((Quat*)m_value)->z, ((Quat*)m_value)->w); + break; + + case COORDINATEFRAME: + { + const CoordinateFrame& c = *(CoordinateFrame*)m_value; + float x,y,z,yaw,pitch,roll; + c.getXYZYPRDegrees(x,y,z,yaw,pitch,roll); + t.printf("CF(V3(%g,%g,%g), %g, %g, %g)", x, y, z, yaw, pitch, roll); + /* + t.pushIndent(); + t.printf( + "CF(\n%10.5f, %10.5f, %10.5f, %10.5f,\n" + "%10.5f, %10.5f, %10.5f, %10.5f,\n" + "%10.5f, %10.5f, %10.5f, %10.5f)", + c.rotation[0][0], c.rotation[0][1], c.rotation[0][2], c.translation.x, + c.rotation[1][0], c.rotation[1][1], c.rotation[1][2], c.translation.y, + c.rotation[2][0], c.rotation[2][1], c.rotation[2][2], c.translation.z); + t.popIndent(); + */ + } + break; + + case COLOR1: + t.printf("C1(%g)", ((Color1*)m_value)->value); + break; + + case COLOR3: + t.printf("C3(%g, %g, %g)", ((Color3*)m_value)->r, ((Color3*)m_value)->g, ((Color3*)m_value)->b); + break; + + case COLOR4: + t.printf("C4(%g, %g, %g, %g)", ((Color4*)m_value)->r, ((Color4*)m_value)->g, ((Color4*)m_value)->b, ((Color4*)m_value)->a); + break; + + case ARRAY: + { + const Array<AnyVal>& a = *(Array<AnyVal>*)m_value; + t.printf("[\n"); + t.pushIndent(); + for (int i = 0; i < a.size(); ++i) { + a[i].serialize(t); + if (i != a.size() - 1) { + t.printf(", \n"); + } + } + t.printf("]"); + t.popIndent(); + } + break; + + case TABLE: + { + const Table<std::string, AnyVal>& a = *(Table<std::string, AnyVal>*)m_value; + t.printf("{\n"); + t.pushIndent(); + Table<std::string, AnyVal>::Iterator i = a.begin(); + const Table<std::string, AnyVal>::Iterator end = a.end(); + while (i != end) { + // Quote names that are not legal C++ identifiers + if (! legalIdentifier(i->key)) { + t.printf("'%s' ", i->key.c_str()); + } else { + t.writeSymbol(i->key); + } + t.printf("= "); + + i->value.serialize(t); + + if (i != end) { + t.printf("\n"); + } + ++i; + } + t.popIndent(); + t.printf("}"); + } + break; + + default: + debugAssertM(false, "Internal error: no serialize method for this type."); + } +} + + +std::string AnyVal::toString() const { + TextOutput t; + serialize(t); + std::string s; + t.commitString(s); + return s; +} + +void AnyVal::deserialize(G3D::TextInput& t) { + deleteValue(); + m_type = NIL; + m_value = NULL; + + if (! t.hasMore()) { + return; + } + + switch (t.peek().type()) { + case Token::END: + // should never get here because of the hasMore check above + return; + break; + + case Token::NUMBER: + m_type = NUMBER; + m_value = new double(t.readNumber()); + break; + + case Token::STRING: + m_type = STRING; + m_value = new std::string(t.readString()); + break; + + case Token::NEWLINE: + m_type = STRING; + m_value = new std::string(t.readNewline()); + break; + + case Token::COMMENT: + m_type = STRING; + m_value = new std::string(t.readComment()); + break; + + case Token::BOOLEAN: + m_type = BOOLEAN; + m_value = new bool(t.readBoolean()); + break; + + case Token::SYMBOL: + { + std::string s = t.readSymbol(); + if (s == "NIL") { + break; + + } else if (s == "true") { + + m_type = BOOLEAN; + m_value = new bool(true); + + } else if (s == "false") { + + m_type = BOOLEAN; + m_value = new bool(false); + + } else if (s == "R") { + + m_type = RECT2D; + t.readSymbol("("); + float x,y,w,h; + x = (float)t.readNumber(); + t.readSymbol(","); + y = (float)t.readNumber(); + t.readSymbol(","); + w = (float)t.readNumber(); + t.readSymbol(","); + h = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Rect2D(Rect2D::xywh(x, y, w, h)); + + } else if (s == "AAB") { + + m_type = AABOX; + Vector3 v[2]; + t.readSymbol("("); + for (int i = 0; i < 2; ++i) { + t.readSymbols("V3", "("); + v[i].x = (float)t.readNumber(); + t.readSymbol(","); + v[i].y = (float)t.readNumber(); + t.readSymbol(","); + v[i].z = (float)t.readNumber(); + t.readSymbol(","); + if (i == 0) { + t.readSymbol(","); + } + } + t.readSymbol(")"); + m_value = new AABox(v[0], v[1]); + + } else if (s == "V2") { + + t.readSymbol("("); + Vector2 v; + v.x = (float)t.readNumber(); + t.readSymbol(","); + v.y = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Vector2(v); + m_type = VECTOR2; + + } else if (s == "V3") { + + t.readSymbol("("); + Vector3 v; + v.x = (float)t.readNumber(); + t.readSymbol(","); + v.y = (float)t.readNumber(); + t.readSymbol(","); + v.z = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Vector3(v); + m_type = VECTOR3; + + } else if (s == "V4") { + + t.readSymbol("("); + Vector4 v; + v.x = (float)t.readNumber(); + t.readSymbol(","); + v.y = (float)t.readNumber(); + t.readSymbol(","); + v.z = (float)t.readNumber(); + t.readSymbol(","); + v.w = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Vector4(v); + m_type = VECTOR4; + + } else if (s == "M2") { + + t.readSymbol("("); + Matrix2 m; + for (int r = 0; r < 2; ++r) { + for (int c = 0; c < 2; ++c) { + m[r][c] = (float)t.readNumber(); + if ((c != 1) || (r != 1)) { + t.readSymbol(","); + } + } + } + t.readSymbol(")"); + m_value = new Matrix2(m); + m_type = MATRIX2; + + } else if (s == "M3") { + + t.readSymbol("("); + Matrix3 m; + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + m[r][c] = (float)t.readNumber(); + if ((c != 2) || (r != 2)) { + t.readSymbol(","); + } + } + } + t.readSymbol(")"); + m_value = new Matrix3(m); + m_type = MATRIX3; + + } else if (s == "M4") { + + t.readSymbol("("); + Matrix4 m; + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + m[r][c] = (float)t.readNumber(); + if ((c != 3) || (r != 3)) { + t.readSymbol(","); + } + } + } + t.readSymbol(")"); + m_value = new Matrix4(m); + m_type = MATRIX4; + + } else if (s == "Q") { + + t.readSymbol("("); + Quat q; + q.x = (float)t.readNumber(); + t.readSymbol(","); + q.y = (float)t.readNumber(); + t.readSymbol(","); + q.z = (float)t.readNumber(); + t.readSymbol(","); + q.w = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Quat(q); + m_type = QUAT; + + } else if (s == "CF") { + + t.readSymbol("("); + CoordinateFrame m; + if (t.peek().type() == Token::SYMBOL) { + // Angle format + float x, y, z, yaw, roll, pitch; + t.readSymbols("V3", "("); + x = (float)t.readNumber(); + t.readSymbol(","); + y = (float)t.readNumber(); + t.readSymbol(","); + z = (float)t.readNumber(); + t.readSymbols(")", ","); + yaw = (float)t.readNumber(); + t.readSymbol(","); + pitch = (float)t.readNumber(); + roll = 0; + if (t.peek().string() == ",") { + t.readSymbol(","); + roll = (float)t.readNumber(); + } + m = CoordinateFrame::fromXYZYPRDegrees(x, y, z, yaw, pitch, roll); + } else { + // Matrix format + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + m.rotation[r][c] = (float)t.readNumber(); + } + m.translation[r] = (float)t.readNumber(); + if (r != 2) { + t.readSymbol(","); + } + } + } + t.readSymbol(")"); + m_value = new CoordinateFrame(m); + m_type = COORDINATEFRAME; + + } else if (s == "C1") { + + t.readSymbol("("); + float v = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Color1(v); + m_type = COLOR1; + + } else if (s == "C3") { + + t.readSymbol("("); + Color3 c; + c.r = (float)t.readNumber(); + t.readSymbol(","); + c.g = (float)t.readNumber(); + t.readSymbol(","); + c.b = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Color3(c); + m_type = COLOR3; + + } else if (s == "C4") { + + t.readSymbol("("); + Color4 c; + c.r = (float)t.readNumber(); + t.readSymbol(","); + c.g = (float)t.readNumber(); + t.readSymbol(","); + c.b = (float)t.readNumber(); + t.readSymbol(","); + c.a = (float)t.readNumber(); + t.readSymbol(")"); + m_value = new Color4(c); + m_type = COLOR4; + + } else if (s == "[") { + + // Array + m_type = ARRAY; + m_value = new Array<AnyVal>(); + m_referenceCount = new int(1); + Array<AnyVal>& a = *(Array<AnyVal>*)m_value; + + Token peek = t.peek(); + while ((peek.type() != Token::SYMBOL) || (peek.string() != "]")) { + // Avoid copying large objects + a.next().deserialize(t); + + peek = t.peek(); + if (peek.type() != Token::SYMBOL) { + throw CorruptText("Expected ',' or ']'", peek); + } else if (peek.string() == ",") { + t.readSymbol(","); + } else if (peek.string() != "]") { + throw CorruptText("Missing ']'", peek); + } + } + t.readSymbol("]"); + + } else if (s == "{") { + + // Table + m_type = TABLE; + m_value = new Table<std::string, AnyVal>(); + m_referenceCount = new int(1); + Table<std::string, AnyVal>& a = *(Table<std::string, AnyVal>*)m_value; + + Token peek = t.peek(); + while ((peek.type() != Token::SYMBOL) || (peek.string() != "}")) { + + std::string key; + // Get the name + if (peek.type() == Token::SYMBOL) { + key = t.readSymbol(); + } else if (peek.extendedType() == Token::SINGLE_QUOTED_TYPE) { + key = t.readString(); + } else { + throw CorruptText("Expected name inside table", peek); + } + + t.readSymbol("="); + + // Avoid copying large values + a.set(key, AnyVal()); + a[key].deserialize(t); + + peek = t.peek(); + if ((peek.type() != Token::SYMBOL) && (peek.extendedType() != Token::SINGLE_QUOTED_TYPE)) { + throw CorruptText("Missing expected name or '}'", peek); + } + } + t.readSymbol("}"); + + } else { + throw CorruptText("Invalid value type.", t.peek()); + } // dispatch on symbol type + } // scope + break; + } +} + + +AnyVal& AnyVal::operator[](const char* key) { + return this->operator[]((std::string)key); +} + + +const AnyVal& AnyVal::operator[](const char* key) const { + return this->operator[]((std::string)key); +} + + +AnyVal& AnyVal::operator[](const std::string& key) { + if (m_type != TABLE) { + throw WrongType(TABLE, m_type); + } + + makeMutable(); + + Table<std::string, AnyVal>& t = *(Table<std::string, AnyVal>*)m_value; + + if (! t.containsKey(key)) { + t.set(key, AnyVal()); + } + + return t[key]; +} + + +const AnyVal& AnyVal::operator[](const std::string& key) const { + if (m_type != TABLE) { + throw WrongType(TABLE, m_type); + } + + const Table<std::string, AnyVal>& t = *(const Table<std::string, AnyVal>*)m_value; + + if (! t.containsKey(key)) { + throw KeyNotFound(key); + } + + return t[key]; +} + + +void AnyVal::append(const AnyVal& v) { + if (m_type != ARRAY) { + throw WrongType(ARRAY, m_type); + } + makeMutable(); + + Array<AnyVal>& a = *(Array<AnyVal>*)m_value; + a.append(v); +} + + +void AnyVal::getKeys(Array<std::string>& keys) const { + if (m_type != TABLE) { + throw WrongType(TABLE, m_type); + } + + const Table<std::string, AnyVal>& t = *(const Table<std::string, AnyVal>*)m_value; + t.getKeys(keys); +} + + +int AnyVal::size() const { + switch (m_type) { + case TABLE: + { + const Table<std::string, AnyVal>& t = *(const Table<std::string, AnyVal>*)m_value; + return t.size(); + } + + case ARRAY: + { + const Array<AnyVal>& a = *(Array<AnyVal>*)m_value; + return a.size(); + } + + default: + throw WrongType(ARRAY, m_type); + } +} + + +AnyVal& AnyVal::operator[](int i) { + if (m_type != ARRAY) { + throw WrongType(ARRAY, m_type); + } + makeMutable(); + + Array<AnyVal>& a = *(Array<AnyVal>*)m_value; + + if (i < 0) { + throw IndexOutOfBounds(i, a.size()); + } + + if (a.size() <= i) { + a.resize(i + 1); + } + + return a[i]; +} + + +const AnyVal& AnyVal::operator[](int i) const { + if (m_type != ARRAY) { + throw WrongType(ARRAY, m_type); + } + + const Array<AnyVal>& a = *(Array<AnyVal>*)m_value; + + if (a.size() <= i || i < 0) { + throw IndexOutOfBounds(i, a.size()); + } + + return a[i]; +} + + +void AnyVal::makeMutable() { + if (*m_referenceCount > 1) { + // This is a shared instance + --(*m_referenceCount); + m_referenceCount = new int(1); + m_value = copyValue(); + } +} + +bool AnyVal::boolean() const { + if (m_type != BOOLEAN) { + throw WrongType(BOOLEAN, m_type); + } + + return *(bool*)m_value; +} + + +bool AnyVal::boolean(bool defaultVal) const { + if (m_type != BOOLEAN) { + return defaultVal; + } + + return *(bool*)m_value; +} + + +const std::string& AnyVal::string() const { + if (m_type != STRING) { + throw WrongType(STRING, m_type); + } + + return *(std::string*)m_value; +} + + +const std::string& AnyVal::string(const std::string& defaultVal) const { + if (m_type != STRING) { + return defaultVal; + } else { + return *(std::string*)m_value; + } +} + + +double AnyVal::number() const { + if (m_type != NUMBER) { + throw WrongType(NUMBER, m_type); + } + + return *(double*)m_value; +} + + +double AnyVal::number(double defaultVal) const { + if (m_type != NUMBER) { + return defaultVal; + } else { + return *(double*)m_value; + } +} + + +const Rect2D& AnyVal::rect2D() const { + if (m_type != RECT2D) { + throw WrongType(RECT2D, m_type); + } + + return *(Rect2D*)m_value; +} + + +const Rect2D& AnyVal::rect2D(const Rect2D& defaultVal) const { + if (m_type != RECT2D) { + return defaultVal; + } else { + return *(Rect2D*)m_value; + } +} + + +const AABox& AnyVal::aabox() const { + if (m_type != AABOX) { + throw WrongType(AABOX, m_type); + } + + return *(AABox*)m_value; +} + + +const AABox& AnyVal::aabox(const AABox& defaultVal) const { + if (m_type != AABOX) { + return defaultVal; + } else { + return *(AABox*)m_value; + } +} + + +const Color1& AnyVal::color1() const { + if (m_type != COLOR1) { + throw WrongType(COLOR1, m_type); + } + + return *(Color1*)m_value; +} + + +const Color1& AnyVal::color1(const Color1& defaultVal) const { + if (m_type != COLOR1) { + return defaultVal; + } else { + return *(Color1*)m_value; + } +} + + +const Color3& AnyVal::color3() const { + if (m_type != COLOR3) { + throw WrongType(COLOR3, m_type); + } + + return *(Color3*)m_value; +} + + +const Color3& AnyVal::color3(const Color3& defaultVal) const { + if (m_type != COLOR3) { + return defaultVal; + } else { + return *(Color3*)m_value; + } +} + + +const Color4& AnyVal::color4() const { + if (m_type != COLOR4) { + throw WrongType(COLOR4, m_type); + } + + return *(Color4*)m_value; +} + + +const Color4& AnyVal::color4(const Color4& defaultVal) const { + if (m_type != COLOR4) { + return defaultVal; + } else { + return *(Color4*)m_value; + } +} + + +const Vector2& AnyVal::vector2() const { + if (m_type != VECTOR2) { + throw WrongType(VECTOR2, m_type); + } + + return *(Vector2*)m_value; +} + + +const Vector2& AnyVal::vector2(const Vector2& defaultVal) const { + if (m_type != VECTOR2) { + return defaultVal; + } else { + return *(Vector2*)m_value; + } +} + + +const Vector3& AnyVal::vector3() const { + if (m_type != VECTOR3) { + throw WrongType(VECTOR3, m_type); + } + + return *(Vector3*)m_value; +} + + +const Vector3& AnyVal::vector3(const Vector3& defaultVal) const { + if (m_type != VECTOR3) { + return defaultVal; + } else { + return *(Vector3*)m_value; + } +} + + +const Vector4& AnyVal::vector4() const { + if (m_type != VECTOR4) { + throw WrongType(VECTOR4, m_type); + } + + return *(Vector4*)m_value; +} + + +const Vector4& AnyVal::vector4(const Vector4& defaultVal) const { + if (m_type != VECTOR4) { + return defaultVal; + } else { + return *(Vector4*)m_value; + } +} + + +const CoordinateFrame& AnyVal::coordinateFrame() const { + if (m_type != COORDINATEFRAME) { + throw WrongType(COORDINATEFRAME, m_type); + } + + return *(CoordinateFrame*)m_value; +} + + +const CoordinateFrame& AnyVal::coordinateFrame(const CoordinateFrame& defaultVal) const { + if (m_type != COORDINATEFRAME) { + return defaultVal; + } else { + return *(CoordinateFrame*)m_value; + } +} + +const Matrix2& AnyVal::matrix2(const Matrix2& defaultVal) const { + if (m_type != MATRIX2) { + return defaultVal; + } else { + return *(Matrix2*)m_value; + } +} + + +const Matrix2& AnyVal::matrix2() const { + if (m_type != MATRIX2) { + throw WrongType(MATRIX2, m_type); + } + + return *(Matrix2*)m_value; +} + + +const Matrix3& AnyVal::matrix3(const Matrix3& defaultVal) const { + if (m_type != MATRIX3) { + return defaultVal; + } else { + return *(Matrix3*)m_value; + } +} + + +const Matrix3& AnyVal::matrix3() const { + if (m_type != MATRIX3) { + throw WrongType(MATRIX3, m_type); + } + + return *(Matrix3*)m_value; +} + + +const Matrix4& AnyVal::matrix4(const Matrix4& defaultVal) const { + if (m_type != MATRIX4) { + return defaultVal; + } else { + return *(Matrix4*)m_value; + } +} + + +const Matrix4& AnyVal::matrix4() const { + if (m_type != MATRIX4) { + throw WrongType(MATRIX4, m_type); + } + + return *(Matrix4*)m_value; +} + + +const Quat& AnyVal::quat(const Quat& defaultVal) const { + if (m_type != QUAT) { + return defaultVal; + } else { + return *(Quat*)m_value; + } +} + + +const Quat& AnyVal::quat() const { + if (m_type != QUAT) { + throw WrongType(QUAT, m_type); + } + + return *(Quat*)m_value; +} + + +const AnyVal& AnyVal::get(const std::string& key, const AnyVal& defaultVal) const { + if (m_type != TABLE) { + return defaultVal; + } + + const Table<std::string, AnyVal>& t = *(const Table<std::string, AnyVal>*)m_value; + + if (t.containsKey(key)) { + return t[key]; + } else { + return defaultVal; + } +} + + +const AnyVal& AnyVal::get(const std::string& key) const { + if (m_type != TABLE) { + throw WrongType(TABLE, m_type); + } + + const Table<std::string, AnyVal>& t = *(const Table<std::string, AnyVal>*)m_value; + + if (t.containsKey(key)) { + return t[key]; + } else { + throw KeyNotFound(key); + } +} + + +const AnyVal& AnyVal::get(int i, const AnyVal& defaultVal) const { + if (m_type != ARRAY) { + return defaultVal; + } + + const Array<AnyVal>& a = *(const Array<AnyVal>*)m_value; + + if ((i >= 0) && (i < a.size())) { + return a[i]; + } else { + return defaultVal; + } +} + + +const AnyVal& AnyVal::get(int i) const { + if (m_type != ARRAY) { + throw WrongType(ARRAY, m_type); + } + + const Array<AnyVal>& a = *(const Array<AnyVal>*)m_value; + + if ((i >= 0) && (i < a.size())) { + return a[i]; + } else { + throw IndexOutOfBounds(i, a.size()); + } +} + +} diff --git a/dep/src/g3dlite/AreaMemoryManager.cpp b/dep/src/g3dlite/AreaMemoryManager.cpp new file mode 100644 index 00000000000..00cb33dc91f --- /dev/null +++ b/dep/src/g3dlite/AreaMemoryManager.cpp @@ -0,0 +1,87 @@ +/** + @file AreaMemoryManager.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2009-01-20 + @edited 2009-01-20 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/AreaMemoryManager.h" +#include "G3D/System.h" + +namespace G3D { + +AreaMemoryManager::Buffer::Buffer(size_t size) : m_size(size), m_used(0) { + // Allocate space for a lot of buffers. + m_first = (uint8*)::malloc(m_size); +} + + +AreaMemoryManager::Buffer::~Buffer() { + ::free(m_first); +} + + +void* AreaMemoryManager::Buffer::alloc(size_t s) { + if (s + m_used > m_size) { + return NULL; + } else { + void* old = m_first + m_used; + m_used += s; + return old; + } +} + + +bool AreaMemoryManager::isThreadsafe() const { + return false; +} + + +AreaMemoryManager::Ref AreaMemoryManager::create(size_t sizeHint) { + return new AreaMemoryManager(sizeHint); +} + + +AreaMemoryManager::AreaMemoryManager(size_t sizeHint) : m_sizeHint(sizeHint) { + debugAssert(sizeHint > 0); +} + + +AreaMemoryManager::~AreaMemoryManager() { + deallocateAll(); +} + + +size_t AreaMemoryManager::bytesAllocated() const { + return m_sizeHint * m_bufferArray.size(); +} + + +void* AreaMemoryManager::alloc(size_t s) { + void* n = (m_bufferArray.size() > 0) ? m_bufferArray.last()->alloc(s) : NULL; + if (n == NULL) { + // This buffer is full + m_bufferArray.append(new Buffer(max(s, m_sizeHint))); + return m_bufferArray.last()->alloc(s); + } else { + return n; + } +} + + +void AreaMemoryManager::free(void* x) { + // Intentionally empty; we block deallocate +} + + +void AreaMemoryManager::deallocateAll() { + m_bufferArray.deleteAll(); + m_bufferArray.clear(); +} + +} diff --git a/dep/src/g3dlite/BinaryFormat.cpp b/dep/src/g3dlite/BinaryFormat.cpp new file mode 100644 index 00000000000..d3991378f45 --- /dev/null +++ b/dep/src/g3dlite/BinaryFormat.cpp @@ -0,0 +1,81 @@ +/** + @file BinaryFormat.cpp + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2005-06-10 + @edited 2005-06-10 + */ + +#include "G3D/BinaryFormat.h" + +namespace G3D { + +int32 byteSize(BinaryFormat f) { + switch (f) { + case BOOL8_BINFMT: + case UINT8_BINFMT: + case INT8_BINFMT: + return 1; + + case UINT16_BINFMT: + case INT16_BINFMT: + return 2; + + case FLOAT16_BINFMT: + return 2; + + case UINT32_BINFMT: + case INT32_BINFMT: + case FLOAT32_BINFMT: + return 4; + + case FLOAT64_BINFMT: + case UINT64_BINFMT: + case INT64_BINFMT: + return 8; + + case INT128_BINFMT: + case UINT128_BINFMT: + return 16; + + case VECTOR2_BINFMT: + return 2 * 4; + + case VECTOR2INT16_BINFMT: + return 2 * 2; + + case VECTOR3_BINFMT: + return 3 * 4; + + case VECTOR3INT16_BINFMT: + return 3 * 2; + + case VECTOR4_BINFMT: + return 4 * 4; + + case VECTOR4INT16_BINFMT: + return 4 * 4; + + case COLOR3_BINFMT: + return 3 * 4; + + case COLOR3UINT8_BINFMT: + return 3 * 1; + + case COLOR3INT16_BINFMT: + return 3 * 2; + + case COLOR4_BINFMT: + return 4 * 4; + + case COLOR4UINT8_BINFMT: + return 4 * 1; + + case COLOR4INT16_BINFMT: + return 4 * 2; + + default: + return -1; + } +} +} diff --git a/dep/src/g3dlite/BinaryInput.cpp b/dep/src/g3dlite/BinaryInput.cpp new file mode 100644 index 00000000000..65a9976fe04 --- /dev/null +++ b/dep/src/g3dlite/BinaryInput.cpp @@ -0,0 +1,568 @@ +/** + @file BinaryInput.cpp + + @author Morgan McGuire, graphics3d.com + Copyright 2001-2007, Morgan McGuire. All rights reserved. + + @created 2001-08-09 + @edited 2005-02-24 + + + <PRE> + { + BinaryOutput b("c:/tmp/test.b", BinaryOutput::LITTLE_ENDIAN); + + float f = 3.1415926; + int i = 1027221; + std::string s = "Hello World!"; + + b.writeFloat32(f); + b.writeInt32(i); + b.writeString(s); + b.commit(); + + + BinaryInput in("c:/tmp/test.b", BinaryInput::LITTLE_ENDIAN); + + debugAssert(f == in.readFloat32()); + int ii = in.readInt32(); + debugAssert(i == ii); + debugAssert(s == in.readString()); + } + </PRE> + */ + +#include "G3D/platform.h" +#include "G3D/BinaryInput.h" +#include "G3D/Array.h" +#include "G3D/fileutils.h" +#include "G3D/Log.h" +#include <zlib.h> + +#include <cstring> + +namespace G3D { + +void BinaryInput::readBool8(std::vector<bool>& out, int64 n) { + out.resize((int)n); + // std::vector optimizes bool in a way that prevents fast reading + for (int64 i = 0; i < n ; ++i) { + out[i] = readBool8(); + } +} + + +void BinaryInput::readBool8(Array<bool>& out, int64 n) { + out.resize(n); + readBool8(out.begin(), n); +} + + +#define IMPLEMENT_READER(ucase, lcase)\ +void BinaryInput::read##ucase(std::vector<lcase>& out, int64 n) {\ + out.resize(n);\ + read##ucase(&out[0], n);\ +}\ +\ +\ +void BinaryInput::read##ucase(Array<lcase>& out, int64 n) {\ + out.resize(n);\ + read##ucase(out.begin(), n);\ +} + + +IMPLEMENT_READER(UInt8, uint8) +IMPLEMENT_READER(Int8, int8) +IMPLEMENT_READER(UInt16, uint16) +IMPLEMENT_READER(Int16, int16) +IMPLEMENT_READER(UInt32, uint32) +IMPLEMENT_READER(Int32, int32) +IMPLEMENT_READER(UInt64, uint64) +IMPLEMENT_READER(Int64, int64) +IMPLEMENT_READER(Float32, float32) +IMPLEMENT_READER(Float64, float64) + +#undef IMPLEMENT_READER + +// Data structures that are one byte per element can be +// directly copied, regardles of endian-ness. +#define IMPLEMENT_READER(ucase, lcase)\ +void BinaryInput::read##ucase(lcase* out, int64 n) {\ + if (sizeof(lcase) == 1) {\ + readBytes(out, n);\ + } else {\ + for (int64 i = 0; i < n ; ++i) {\ + out[i] = read##ucase();\ + }\ + }\ +} + +IMPLEMENT_READER(Bool8, bool) +IMPLEMENT_READER(UInt8, uint8) +IMPLEMENT_READER(Int8, int8) + +#undef IMPLEMENT_READER + + +#define IMPLEMENT_READER(ucase, lcase)\ +void BinaryInput::read##ucase(lcase* out, int64 n) {\ + if (m_swapBytes) {\ + for (int64 i = 0; i < n; ++i) {\ + out[i] = read##ucase();\ + }\ + } else {\ + readBytes(out, sizeof(lcase) * n);\ + }\ +} + + +IMPLEMENT_READER(UInt16, uint16) +IMPLEMENT_READER(Int16, int16) +IMPLEMENT_READER(UInt32, uint32) +IMPLEMENT_READER(Int32, int32) +IMPLEMENT_READER(UInt64, uint64) +IMPLEMENT_READER(Int64, int64) +IMPLEMENT_READER(Float32, float32) +IMPLEMENT_READER(Float64, float64) + +#undef IMPLEMENT_READER + +void BinaryInput::loadIntoMemory(int64 startPosition, int64 minLength) { + // Load the next section of the file + debugAssertM(m_filename != "<memory>", "Read past end of file."); + + int64 absPos = m_alreadyRead + m_pos; + + if (m_bufferLength < minLength) { + // The current buffer isn't big enough to hold the chunk we want to read. + // This happens if there was little memory available during the initial constructor + // read but more memory has since been freed. + m_bufferLength = minLength; + debugAssert(m_freeBuffer); + m_buffer = (uint8*)System::realloc(m_buffer, m_bufferLength); + if (m_buffer == NULL) { + throw "Tried to read a larger memory chunk than could fit in memory. (2)"; + } + } + + m_alreadyRead = startPosition; + +# ifdef G3D_WIN32 + FILE* file = fopen(m_filename.c_str(), "rb"); + debugAssert(file); + int ret = fseek(file, (off_t)m_alreadyRead, SEEK_SET); + debugAssert(ret == 0); + size_t toRead = (size_t)G3D::min(m_bufferLength, m_length - m_alreadyRead); + ret = fread(m_buffer, 1, toRead, file); + debugAssert(ret == toRead); + fclose(file); + file = NULL; + +# else + FILE* file = fopen(m_filename.c_str(), "rb"); + debugAssert(file); + int ret = fseeko(file, (off_t)m_alreadyRead, SEEK_SET); + debugAssert(ret == 0); + size_t toRead = (size_t)G3D::min<int64>(m_bufferLength, m_length - m_alreadyRead); + ret = fread(m_buffer, 1, toRead, file); + debugAssert((size_t)ret == (size_t)toRead); + fclose(file); + file = NULL; +# endif + + m_pos = absPos - m_alreadyRead; + debugAssert(m_pos >= 0); +} + + + +const bool BinaryInput::NO_COPY = false; + +static bool needSwapBytes(G3DEndian fileEndian) { + return (fileEndian != System::machineEndian()); +} + + +/** Helper used by the constructors for decompression */ +static uint32 readUInt32(const uint8* data, bool swapBytes) { + if (swapBytes) { + uint8 out[4]; + out[0] = data[3]; + out[1] = data[2]; + out[2] = data[1]; + out[3] = data[0]; + return *((uint32*)out); + } else { + return *((uint32*)data); + } +} + + +void BinaryInput::setEndian(G3DEndian e) { + m_fileEndian = e; + m_swapBytes = needSwapBytes(m_fileEndian); +} + + +BinaryInput::BinaryInput( + const uint8* data, + int64 dataLen, + G3DEndian dataEndian, + bool compressed, + bool copyMemory) : + m_filename("<memory>"), + m_bitPos(0), + m_bitString(0), + m_beginEndBits(0), + m_alreadyRead(0), + m_bufferLength(0), + m_pos(0) { + + m_freeBuffer = copyMemory || compressed; + + setEndian(dataEndian); + + if (compressed) { + // Read the decompressed size from the first 4 bytes + m_length = G3D::readUInt32(data, m_swapBytes); + + debugAssert(m_freeBuffer); + m_buffer = (uint8*)System::alignedMalloc(m_length, 16); + + unsigned long L = m_length; + // Decompress with zlib + int64 result = uncompress(m_buffer, (unsigned long*)&L, data + 4, dataLen - 4); + m_length = L; + m_bufferLength = L; + debugAssert(result == Z_OK); (void)result; + + } else { + m_length = dataLen; + m_bufferLength = m_length; + if (! copyMemory) { + debugAssert(!m_freeBuffer); + m_buffer = const_cast<uint8*>(data); + } else { + debugAssert(m_freeBuffer); + m_buffer = (uint8*)System::alignedMalloc(m_length, 16); + System::memcpy(m_buffer, data, dataLen); + } + } +} + + +BinaryInput::BinaryInput( + const std::string& filename, + G3DEndian fileEndian, + bool compressed) : + m_filename(filename), + m_bitPos(0), + m_bitString(0), + m_beginEndBits(0), + m_alreadyRead(0), + m_length(0), + m_bufferLength(0), + m_buffer(NULL), + m_pos(0), + m_freeBuffer(true) { + + setEndian(fileEndian); + + // Update global file tracker + _internal::currentFilesUsed.insert(m_filename); + + + if (! fileExists(m_filename, false)) { + std::string zipfile; + std::string internalfile; + if (zipfileExists(m_filename, zipfile, internalfile)) { + // Load from zipfile + void* v; + size_t s; + zipRead(filename, v, s); + m_buffer = reinterpret_cast<uint8*>(v); + m_bufferLength = m_length = s; + if (compressed) { + decompress(); + } + m_freeBuffer = true; + } else { + Log::common()->printf("Warning: File not found: %s\n", m_filename.c_str()); + } + return; + } + + // Figure out how big the file is and verify that it exists. + m_length = fileLength(m_filename); + + // Read the file into memory + FILE* file = fopen(m_filename.c_str(), "rb"); + + if (! file || (m_length == -1)) { + throw format("File not found: \"%s\"", m_filename.c_str()); + return; + } + + if (! compressed && (m_length > INITIAL_BUFFER_LENGTH)) { + // Read only a subset of the file so we don't consume + // all available memory. + m_bufferLength = INITIAL_BUFFER_LENGTH; + } else { + // Either the length is fine or the file is compressed + // and requires us to read the whole thing for zlib. + m_bufferLength = m_length; + } + + debugAssert(m_freeBuffer); + m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16); + if (m_buffer == NULL) { + if (compressed) { + throw "Not enough memory to load compressed file. (1)"; + } + + // Try to allocate a small array; not much memory is available. + // Give up if we can't allocate even 1k. + while ((m_buffer == NULL) && (m_bufferLength > 1024)) { + m_bufferLength /= 2; + m_buffer = (uint8*)System::alignedMalloc(m_bufferLength, 16); + } + } + debugAssert(m_buffer); + + fread(m_buffer, m_bufferLength, sizeof(int8), file); + fclose(file); + file = NULL; + + if (compressed) { + if (m_bufferLength != m_length) { + throw "Not enough memory to load compressed file. (2)"; + } + + decompress(); + } +} + +void BinaryInput::decompress() { + // Decompress + // Use the existing buffer as the source, allocate + // a new buffer to use as the destination. + + int64 tempLength = m_length; + m_length = G3D::readUInt32(m_buffer, m_swapBytes); + + // The file couldn't have better than 500:1 compression + alwaysAssertM(m_length < m_bufferLength * 500, "Compressed file header is corrupted"); + + uint8* tempBuffer = m_buffer; + m_buffer = (uint8*)System::alignedMalloc(m_length, 16); + + debugAssert(m_buffer); + debugAssert(isValidHeapPointer(tempBuffer)); + debugAssert(isValidHeapPointer(m_buffer)); + + unsigned long L = m_length; + int64 result = uncompress(m_buffer, &L, tempBuffer + 4, tempLength - 4); + m_length = L; + m_bufferLength = m_length; + + debugAssertM(result == Z_OK, "BinaryInput/zlib detected corruption in " + m_filename); + (void)result; + + System::alignedFree(tempBuffer); +} + + +void BinaryInput::readBytes(void* bytes, int64 n) { + prepareToRead(n); + debugAssert(isValidPointer(bytes)); + + memcpy(bytes, m_buffer + m_pos, n); + m_pos += n; +} + + +BinaryInput::~BinaryInput() { + + if (m_freeBuffer) { + System::alignedFree(m_buffer); + } + m_buffer = NULL; +} + + +uint64 BinaryInput::readUInt64() { + prepareToRead(8); + uint8 out[8]; + + if (m_swapBytes) { + out[0] = m_buffer[m_pos + 7]; + out[1] = m_buffer[m_pos + 6]; + out[2] = m_buffer[m_pos + 5]; + out[3] = m_buffer[m_pos + 4]; + out[4] = m_buffer[m_pos + 3]; + out[5] = m_buffer[m_pos + 2]; + out[6] = m_buffer[m_pos + 1]; + out[7] = m_buffer[m_pos + 0]; + } else { + *(uint64*)out = *(uint64*)(m_buffer + m_pos); + } + + m_pos += 8; + return *(uint64*)out; +} + + +std::string BinaryInput::readString(int64 n) { + prepareToRead(n); + debugAssertM((m_pos + n) <= m_length, "Read past end of file"); + + char *s = (char*)System::alignedMalloc(n + 1, 16); + assert(s != NULL); + + memcpy(s, m_buffer + m_pos, n); + // There may not be a null, so make sure + // we add one. + s[n] = '\0'; + + std::string out = s; + System::alignedFree(s); + s = NULL; + + m_pos += n; + + return out; + +} + + +std::string BinaryInput::readString() { + int64 n = 0; + + if ((m_pos + m_alreadyRead + n) < (m_length - 1)) { + prepareToRead(1); + } + + if ( ((m_pos + m_alreadyRead + n) < (m_length - 1)) && + (m_buffer[m_pos + n] != '\0')) { + + ++n; + while ( ((m_pos + m_alreadyRead + n) < (m_length - 1)) && + (m_buffer[m_pos + n] != '\0')) { + + prepareToRead(1); + ++n; + } + } + + // Consume NULL + ++n; + + return readString(n); +} + + +std::string BinaryInput::readStringEven() { + std::string x = readString(); + if (hasMore() && (G3D::isOdd(x.length() + 1))) { + skip(1); + } + return x; +} + + +std::string BinaryInput::readString32() { + int len = readUInt32(); + return readString(len); +} + + +Vector4 BinaryInput::readVector4() { + float x = readFloat32(); + float y = readFloat32(); + float z = readFloat32(); + float w = readFloat32(); + return Vector4(x, y, z, w); +} + + +Vector3 BinaryInput::readVector3() { + float x = readFloat32(); + float y = readFloat32(); + float z = readFloat32(); + return Vector3(x, y, z); +} + + +Vector2 BinaryInput::readVector2() { + float x = readFloat32(); + float y = readFloat32(); + return Vector2(x, y); +} + + +Color4 BinaryInput::readColor4() { + float r = readFloat32(); + float g = readFloat32(); + float b = readFloat32(); + float a = readFloat32(); + return Color4(r, g, b, a); +} + + +Color3 BinaryInput::readColor3() { + float r = readFloat32(); + float g = readFloat32(); + float b = readFloat32(); + return Color3(r, g, b); +} + + +void BinaryInput::beginBits() { + debugAssert(m_beginEndBits == 0); + m_beginEndBits = 1; + m_bitPos = 0; + + debugAssertM(hasMore(), "Can't call beginBits when at the end of a file"); + m_bitString = readUInt8(); +} + + +uint32 BinaryInput::readBits(int numBits) { + debugAssert(m_beginEndBits == 1); + + uint32 out = 0; + + const int total = numBits; + while (numBits > 0) { + if (m_bitPos > 7) { + // Consume a new byte for reading. We do this at the beginning + // of the loop so that we don't try to read past the end of the file. + m_bitPos = 0; + m_bitString = readUInt8(); + } + + // Slide the lowest bit of the bitString into + // the correct position. + out |= (m_bitString & 1) << (total - numBits); + + // Shift over to the next bit + m_bitString = m_bitString >> 1; + ++m_bitPos; + --numBits; + } + + return out; +} + + +void BinaryInput::endBits() { + debugAssert(m_beginEndBits == 1); + if (m_bitPos == 0) { + // Put back the last byte we read + --m_pos; + } + m_beginEndBits = 0; + m_bitPos = 0; +} + +} diff --git a/dep/src/g3dlite/BinaryOutput.cpp b/dep/src/g3dlite/BinaryOutput.cpp new file mode 100644 index 00000000000..2de46c6d4bb --- /dev/null +++ b/dep/src/g3dlite/BinaryOutput.cpp @@ -0,0 +1,522 @@ +/** + @file BinaryOutput.cpp + + @author Morgan McGuire, graphics3d.com + Copyright 2002-2007, Morgan McGuire, All rights reserved. + + @created 2002-02-20 + @edited 2008-01-07 + */ + +#include "G3D/platform.h" +#include "G3D/BinaryOutput.h" +#include "G3D/fileutils.h" +#include "G3D/stringutils.h" +#include "G3D/Array.h" +#include <zlib.h> + +#include <cstring> + +// Largest memory buffer that the system will use for writing to +// disk. After this (or if the system runs out of memory) +// chunks of the file will be dumped to disk. +// +// Currently 400 MB +#define MAX_BINARYOUTPUT_BUFFER_SIZE 400000000 + +namespace G3D { + +void BinaryOutput::writeBool8(const std::vector<bool>& out, int n) { + for (int i = 0; i < n; ++i) { + writeBool8(out[i]); + } +} + + +void BinaryOutput::writeBool8(const Array<bool>& out, int n) { + writeBool8(out.getCArray(), n); +} + +#define IMPLEMENT_WRITER(ucase, lcase)\ +void BinaryOutput::write##ucase(const std::vector<lcase>& out, int n) {\ + write##ucase(&out[0], n);\ +}\ +\ +\ +void BinaryOutput::write##ucase(const Array<lcase>& out, int n) {\ + write##ucase(out.getCArray(), n);\ +} + + +IMPLEMENT_WRITER(UInt8, uint8) +IMPLEMENT_WRITER(Int8, int8) +IMPLEMENT_WRITER(UInt16, uint16) +IMPLEMENT_WRITER(Int16, int16) +IMPLEMENT_WRITER(UInt32, uint32) +IMPLEMENT_WRITER(Int32, int32) +IMPLEMENT_WRITER(UInt64, uint64) +IMPLEMENT_WRITER(Int64, int64) +IMPLEMENT_WRITER(Float32, float32) +IMPLEMENT_WRITER(Float64, float64) + +#undef IMPLEMENT_WRITER + +// Data structures that are one byte per element can be +// directly copied, regardles of endian-ness. +#define IMPLEMENT_WRITER(ucase, lcase)\ +void BinaryOutput::write##ucase(const lcase* out, int n) {\ + if (sizeof(lcase) == 1) {\ + writeBytes((void*)out, n);\ + } else {\ + for (int i = 0; i < n ; ++i) {\ + write##ucase(out[i]);\ + }\ + }\ +} + +IMPLEMENT_WRITER(Bool8, bool) +IMPLEMENT_WRITER(UInt8, uint8) +IMPLEMENT_WRITER(Int8, int8) + +#undef IMPLEMENT_WRITER + + +#define IMPLEMENT_WRITER(ucase, lcase)\ +void BinaryOutput::write##ucase(const lcase* out, int n) {\ + if (m_swapBytes) {\ + for (int i = 0; i < n; ++i) {\ + write##ucase(out[i]);\ + }\ + } else {\ + writeBytes((const void*)out, sizeof(lcase) * n);\ + }\ +} + + +IMPLEMENT_WRITER(UInt16, uint16) +IMPLEMENT_WRITER(Int16, int16) +IMPLEMENT_WRITER(UInt32, uint32) +IMPLEMENT_WRITER(Int32, int32) +IMPLEMENT_WRITER(UInt64, uint64) +IMPLEMENT_WRITER(Int64, int64) +IMPLEMENT_WRITER(Float32, float32) +IMPLEMENT_WRITER(Float64, float64) + +#undef IMPLEMENT_WRITER + + +void BinaryOutput::reallocBuffer(size_t bytes, size_t oldBufferLen) { + //debugPrintf("reallocBuffer(%d, %d)\n", bytes, oldBufferLen); + + size_t newBufferLen = (int)(m_bufferLen * 1.5) + 100; + uint8* newBuffer = NULL; + + if ((m_filename == "<memory>") || (newBufferLen < MAX_BINARYOUTPUT_BUFFER_SIZE)) { + // We're either writing to memory (in which case we *have* to try and allocate) + // or we've been asked to allocate a reasonable size buffer. + + //debugPrintf(" realloc(%d)\n", newBufferLen); + newBuffer = (uint8*)System::realloc(m_buffer, newBufferLen); + if (newBuffer != NULL) { + m_maxBufferLen = newBufferLen; + } + } + + if ((newBuffer == NULL) && (bytes > 0)) { + // Realloc failed; we're probably out of memory. Back out + // the entire call and try to dump some data to disk. + m_bufferLen = oldBufferLen; + reserveBytesWhenOutOfMemory(bytes); + } else { + m_buffer = newBuffer; + debugAssert(isValidHeapPointer(m_buffer)); + } +} + + +void BinaryOutput::reserveBytesWhenOutOfMemory(size_t bytes) { + if (m_filename == "<memory>") { + throw "Out of memory while writing to memory in BinaryOutput (no RAM left)."; + } else if ((int)bytes > (int)m_maxBufferLen) { + throw "Out of memory while writing to disk in BinaryOutput (could not create a large enough buffer)."; + } else { + + // Dump the contents to disk. In order to enable seeking backwards, + // we keep the last 10 MB in memory. + int writeBytes = m_bufferLen - 10 * 1024 * 1024; + + if (writeBytes < m_bufferLen / 3) { + // We're going to write less than 1/3 of the file; + // give up and just write the whole thing. + writeBytes = m_bufferLen; + } + debugAssert(writeBytes > 0); + + //debugPrintf("Writing %d bytes to disk\n", writeBytes); + + const char* mode = (m_alreadyWritten > 0) ? "ab" : "wb"; + FILE* file = fopen(m_filename.c_str(), mode); + debugAssert(file); + + size_t count = fwrite(m_buffer, 1, writeBytes, file); + debugAssert((int)count == writeBytes); (void)count; + + fclose(file); + file = NULL; + + // Record that we saved this data. + m_alreadyWritten += writeBytes; + m_bufferLen -= writeBytes; + m_pos -= writeBytes; + + debugAssert(m_bufferLen < m_maxBufferLen); + debugAssert(m_bufferLen >= 0); + debugAssert(m_pos >= 0); + debugAssert(m_pos <= m_bufferLen); + + // Shift the unwritten data back appropriately in the buffer. + debugAssert(isValidHeapPointer(m_buffer)); + System::memcpy(m_buffer, m_buffer + writeBytes, m_bufferLen); + debugAssert(isValidHeapPointer(m_buffer)); + + // *now* we allocate bytes (there should presumably be enough + // space in the buffer; if not, we'll come back through this + // code and dump the last 10MB to disk as well. Note that the + // bytes > maxBufferLen case above would already have triggered + // if this call couldn't succeed. + reserveBytes(bytes); + } +} + + +BinaryOutput::BinaryOutput() { + m_alreadyWritten = 0; + m_swapBytes = false; + m_pos = 0; + m_filename = "<memory>"; + m_buffer = NULL; + m_bufferLen = 0; + m_maxBufferLen = 0; + m_beginEndBits = 0; + m_bitString = 0; + m_bitPos = 0; + m_ok = true; + m_committed = false; +} + + +BinaryOutput::BinaryOutput( + const std::string& filename, + G3DEndian fileEndian) { + + m_pos = 0; + m_alreadyWritten = 0; + setEndian(fileEndian); + m_filename = filename; + m_buffer = NULL; + m_bufferLen = 0; + m_maxBufferLen = 0; + m_beginEndBits = 0; + m_bitString = 0; + m_bitPos = 0; + m_committed = false; + + m_ok = true; + /** Verify ability to write to disk */ + commit(false); + m_committed = false; +} + + +void BinaryOutput::reset() { + debugAssert(m_beginEndBits == 0); + alwaysAssertM(m_filename == "<memory>", + "Can only reset a BinaryOutput that writes to memory."); + + // Do not reallocate, just clear the size of the buffer. + m_pos = 0; + m_alreadyWritten = 0; + m_bufferLen = 0; + m_beginEndBits = 0; + m_bitString = 0; + m_bitPos = 0; + m_committed = false; +} + + +BinaryOutput::~BinaryOutput() { + debugAssert((m_buffer == NULL) || isValidHeapPointer(m_buffer)); + System::free(m_buffer); + m_buffer = NULL; + m_bufferLen = 0; + m_maxBufferLen = 0; +} + + +void BinaryOutput::setEndian(G3DEndian fileEndian) { + m_fileEndian = fileEndian; + m_swapBytes = (fileEndian != System::machineEndian()); +} + + +bool BinaryOutput::ok() const { + return m_ok; +} + + +void BinaryOutput::compress() { + if (m_alreadyWritten > 0) { + throw "Cannot compress huge files (part of this file has already been written to disk)."; + } + + // Old buffer size + int L = m_bufferLen; + uint8* convert = (uint8*)&L; + + // Zlib requires the output buffer to be this big + unsigned long newSize = iCeil(m_bufferLen * 1.01) + 12; + uint8* temp = (uint8*)System::malloc(newSize); + int result = compress2(temp, &newSize, m_buffer, m_bufferLen, 9); + + debugAssert(result == Z_OK); (void)result; + + // Write the header + if (m_swapBytes) { + m_buffer[0] = convert[3]; + m_buffer[1] = convert[2]; + m_buffer[2] = convert[1]; + m_buffer[3] = convert[0]; + } else { + m_buffer[0] = convert[0]; + m_buffer[1] = convert[1]; + m_buffer[2] = convert[2]; + m_buffer[3] = convert[3]; + } + + // Write the data + if ((int64)newSize + 4 > (int64)m_maxBufferLen) { + m_maxBufferLen = newSize + 4; + m_buffer = (uint8*)System::realloc(m_buffer, m_maxBufferLen); + } + m_bufferLen = newSize + 4; + System::memcpy(m_buffer + 4, temp, newSize); + m_pos = m_bufferLen; + + System::free(temp); +} + + +void BinaryOutput::commit(bool flush) { + debugAssertM(! m_committed, "Cannot commit twice"); + m_committed = true; + debugAssertM(m_beginEndBits == 0, "Missing endBits before commit"); + + // Make sure the directory exists. + std::string root, base, ext, path; + Array<std::string> pathArray; + parseFilename(m_filename, root, pathArray, base, ext); + + path = root + stringJoin(pathArray, '/'); + if (! fileExists(path, false)) { + createDirectory(path); + } + + const char* mode = (m_alreadyWritten > 0) ? "ab" : "wb"; + + FILE* file = fopen(m_filename.c_str(), mode); + + m_ok = (file != NULL) && m_ok; + + if (m_ok) { + debugAssertM(file, std::string("Could not open '") + m_filename + "'"); + + if (m_buffer != NULL) { + m_alreadyWritten += m_bufferLen; + + int success = fwrite(m_buffer, m_bufferLen, 1, file); + (void)success; + debugAssertM(success == 1, std::string("Could not write to '") + m_filename + "'"); + } + if (flush) { + fflush(file); + } + fclose(file); + file = NULL; + } +} + + +void BinaryOutput::commit( + uint8* out) { + debugAssertM(! m_committed, "Cannot commit twice"); + m_committed = true; + + System::memcpy(out, m_buffer, m_bufferLen); +} + + +void BinaryOutput::writeUInt16(uint16 u) { + reserveBytes(2); + + uint8* convert = (uint8*)&u; + + if (m_swapBytes) { + m_buffer[m_pos] = convert[1]; + m_buffer[m_pos + 1] = convert[0]; + } else { + *(uint16*)(m_buffer + m_pos) = u; + } + + m_pos += 2; +} + + +void BinaryOutput::writeUInt32(uint32 u) { + reserveBytes(4); + + uint8* convert = (uint8*)&u; + + debugAssert(m_beginEndBits == 0); + + if (m_swapBytes) { + m_buffer[m_pos] = convert[3]; + m_buffer[m_pos + 1] = convert[2]; + m_buffer[m_pos + 2] = convert[1]; + m_buffer[m_pos + 3] = convert[0]; + } else { + *(uint32*)(m_buffer + m_pos) = u; + } + + m_pos += 4; +} + + +void BinaryOutput::writeUInt64(uint64 u) { + reserveBytes(8); + + uint8* convert = (uint8*)&u; + + if (m_swapBytes) { + m_buffer[m_pos] = convert[7]; + m_buffer[m_pos + 1] = convert[6]; + m_buffer[m_pos + 2] = convert[5]; + m_buffer[m_pos + 3] = convert[4]; + m_buffer[m_pos + 4] = convert[3]; + m_buffer[m_pos + 5] = convert[2]; + m_buffer[m_pos + 6] = convert[1]; + m_buffer[m_pos + 7] = convert[0]; + } else { + *(uint64*)(m_buffer + m_pos) = u; + } + + m_pos += 8; +} + + +void BinaryOutput::writeString(const char* s) { + // +1 is because strlen doesn't count the null + int len = strlen(s) + 1; + + debugAssert(m_beginEndBits == 0); + reserveBytes(len); + System::memcpy(m_buffer + m_pos, s, len); + m_pos += len; +} + + +void BinaryOutput::writeStringEven(const char* s) { + // +1 is because strlen doesn't count the null + int len = strlen(s) + 1; + + reserveBytes(len); + System::memcpy(m_buffer + m_pos, s, len); + m_pos += len; + + // Pad with another NULL + if ((len % 2) == 1) { + writeUInt8(0); + } +} + + +void BinaryOutput::writeString32(const char* s) { + writeUInt32(strlen(s) + 1); + writeString(s); +} + + +void BinaryOutput::writeVector4(const Vector4& v) { + writeFloat32(v.x); + writeFloat32(v.y); + writeFloat32(v.z); + writeFloat32(v.w); +} + + +void BinaryOutput::writeVector3(const Vector3& v) { + writeFloat32(v.x); + writeFloat32(v.y); + writeFloat32(v.z); +} + + +void BinaryOutput::writeVector2(const Vector2& v) { + writeFloat32(v.x); + writeFloat32(v.y); +} + + +void BinaryOutput::writeColor4(const Color4& v) { + writeFloat32(v.r); + writeFloat32(v.g); + writeFloat32(v.b); + writeFloat32(v.a); +} + + +void BinaryOutput::writeColor3(const Color3& v) { + writeFloat32(v.r); + writeFloat32(v.g); + writeFloat32(v.b); +} + + +void BinaryOutput::beginBits() { + debugAssertM(m_beginEndBits == 0, "Already in beginBits...endBits"); + m_bitString = 0x00; + m_bitPos = 0; + m_beginEndBits = 1; +} + + +void BinaryOutput::writeBits(uint32 value, int numBits) { + + while (numBits > 0) { + // Extract the current bit of value and + // insert it into the current byte + m_bitString |= (value & 1) << m_bitPos; + ++m_bitPos; + value = value >> 1; + --numBits; + + if (m_bitPos > 7) { + // We've reached the end of this byte + writeUInt8(m_bitString); + m_bitString = 0x00; + m_bitPos = 0; + } + } +} + + +void BinaryOutput::endBits() { + debugAssertM(m_beginEndBits == 1, "Not in beginBits...endBits"); + if (m_bitPos > 0) { + writeUInt8(m_bitString); + } + m_bitString = 0; + m_bitPos = 0; + m_beginEndBits = 0; +} + +} diff --git a/dep/src/g3dlite/Box.cpp b/dep/src/g3dlite/Box.cpp index 725a7e95c3a..f7c112ae3a5 100644 --- a/dep/src/g3dlite/Box.cpp +++ b/dep/src/g3dlite/Box.cpp @@ -2,7 +2,7 @@ @file Box.cpp Box class - @maintainer Morgan McGuire, matrix@graphics3d.com + @maintainer Morgan McGuire, http://graphics.cs.williams.edu @created 2001-06-02 @edited 2006-02-05 @@ -27,10 +27,56 @@ namespace G3D { Box::Box() { } + Box::Box(const AABox& b) { init(b.low(), b.high()); } +Box::Box(class BinaryInput& b) { + deserialize(b); +} + + +void Box::serialize(class BinaryOutput& b) const { + int i; + for (i = 0; i < 8; ++i) { + _corner[i].serialize(b); + } + + // Other state can be reconstructed +} + + +void Box::deserialize(class BinaryInput& b) { + int i; + + _center = Vector3::zero(); + for (i = 0; i < 8; ++i) { + _corner[i].deserialize(b); + _center += _corner[i]; + } + + _center = _center / 8; + + // Reconstruct other state from the corners + _axis[0] = _corner[5] - _corner[4]; + _axis[1] = _corner[7] - _corner[4]; + _axis[2] = _corner[0] - _corner[4]; + + for (i = 0; i < 3; ++i) { + _extent[i] = _axis[i].magnitude(); + _axis[i] /= _extent[i]; + } + + _volume = _extent.x * _extent.y * _extent.z; + + _area = 2 * + (_extent.x * _extent.y + + _extent.y * _extent.z + + _extent.z * _extent.x); +} + + Box::Box( const Vector3& min, const Vector3& max) { @@ -43,6 +89,11 @@ void Box::init( const Vector3& min, const Vector3& max) { + debugAssert( + (min.x <= max.x) && + (min.y <= max.y) && + (min.z <= max.z)); + setMany(0, 1, 2, 3, z, max); setMany(4, 5, 6, 7, z, min); @@ -58,23 +109,40 @@ void Box::init( _axis[1] = Vector3::unitY(); _axis[2] = Vector3::unitZ(); - _volume = _extent.x * _extent.y * _extent.z; - _area = 2 * + if (_extent.isFinite()) { + _volume = _extent.x * _extent.y * _extent.z; + } else { + _volume = G3D::finf(); + } + + debugAssert(! isNaN(_extent.x)); + + _area = 2 * (_extent.x * _extent.y + _extent.y * _extent.z + _extent.z * _extent.x); - _center = (max + min) / 2; + _center = (max + min) * 0.5f; + + // If the extent is infinite along an axis, make the center zero to avoid NaNs + for (int i = 0; i < 3; ++i) { + if (! G3D::isFinite(_extent[i])) { + _center[i] = 0.0f; + } + } } + float Box::volume() const { return _volume; } -float Box::surfaceArea() const { + +float Box::area() const { return _area; } + void Box::getLocalFrame(CoordinateFrame& frame) const { frame.rotation = Matrix3( @@ -85,12 +153,14 @@ void Box::getLocalFrame(CoordinateFrame& frame) const { frame.translation = _center; } + CoordinateFrame Box::localFrame() const { CoordinateFrame out; getLocalFrame(out); return out; } + void Box::getFaceCorners(int f, Vector3& v0, Vector3& v1, Vector3& v2, Vector3& v3) const { switch (f) { case 0: @@ -122,45 +192,29 @@ void Box::getFaceCorners(int f, Vector3& v0, Vector3& v1, Vector3& v2, Vector3& } } -bool Box::culledBy( - const Array<Plane>& plane, - int& cullingPlaneIndex, - const uint32 inMask, - uint32& outMask) const { - - return culledBy(plane.getCArray(), plane.size(), cullingPlaneIndex, inMask, outMask); -} - -bool Box::culledBy( - const Array<Plane>& plane, - int& cullingPlaneIndex, - const uint32 inMask) const { - return culledBy(plane.getCArray(), plane.size(), cullingPlaneIndex, inMask); -} -int32 Box::dummy = 0; +int Box::dummy = 0; bool Box::culledBy( - const class Plane* plane, - int numPlanes, + const Array<Plane>& plane, int& cullingPlane, const uint32 _inMask, uint32& childMask) const { uint32 inMask = _inMask; - assert(numPlanes < 31); + assert(plane.size() < 31); childMask = 0; // See if there is one plane for which all of the - // vertices are in the negative half space. - for (int p = 0; p < numPlanes; p++) { - - // Only test planes that are not masked - if ((inMask & 1) != 0) { + // vertices are in the negative half space. + for (int p = 0; p < plane.size(); ++p) { - Vector3 corner; + // Only test planes that are not masked + if ((inMask & 1) != 0) { + + Vector3 corner; int numContained = 0; int v = 0; @@ -168,83 +222,84 @@ bool Box::culledBy( // We can early-out only if we have found one point on each // side of the plane (i.e. if we are straddling). That // occurs when (numContained < v) && (numContained > 0) - for (v = 0; (v < 8) && ((numContained == v) || (numContained == 0)); ++v) { - if (plane[p].halfSpaceContains(getCorner(v))) { + for (v = 0; (v < 8) && ((numContained == v) || (numContained == 0)); ++v) { + if (plane[p].halfSpaceContains(_corner[v])) { ++numContained; } - } + } - if (numContained == 0) { - // Plane p culled the box - cullingPlane = p; + if (numContained == 0) { + // Plane p culled the box + cullingPlane = p; // The caller should not recurse into the children, // since the parent is culled. If they do recurse, // make them only test against this one plane, which // will immediately cull the volume. childMask = 1 << p; - return true; + return true; } else if (numContained < v) { // The bounding volume straddled the plane; we have // to keep testing against this plane childMask |= (1 << p); } - } + } // Move on to the next bit. - inMask = inMask >> 1; + inMask = inMask >> 1; } // None of the planes could cull this box - cullingPlane = -1; + cullingPlane = -1; return false; } + bool Box::culledBy( - const class Plane* plane, - int numPlanes, - int& cullingPlane, - const uint32 _inMask) const { + const Array<Plane>& plane, + int& cullingPlane, + const uint32 _inMask) const { - uint32 inMask = _inMask; - assert(numPlanes < 31); + uint32 inMask = _inMask; + assert(plane.size() < 31); // See if there is one plane for which all of the - // vertices are in the negative half space. - for (int p = 0; p < numPlanes; p++) { + // vertices are in the negative half space. + for (int p = 0; p < plane.size(); ++p) { - // Only test planes that are not masked - if ((inMask & 1) != 0) { - - bool culled = true; + // Only test planes that are not masked + if ((inMask & 1) != 0) { + + bool culled = true; int v; - // Assume this plane culls all points. See if there is a point - // not culled by the plane... early out when at least one point + // Assume this plane culls all points. See if there is a point + // not culled by the plane... early out when at least one point // is in the positive half space. - for (v = 0; (v < 8) && culled; ++v) { - culled = ! plane[p].halfSpaceContains(getCorner(v)); - } + for (v = 0; (v < 8) && culled; ++v) { + culled = ! plane[p].halfSpaceContains(corner(v)); + } - if (culled) { - // Plane p culled the box - cullingPlane = p; + if (culled) { + // Plane p culled the box + cullingPlane = p; - return true; + return true; } - } + } // Move on to the next bit. - inMask = inMask >> 1; + inMask = inMask >> 1; } // None of the planes could cull this box - cullingPlane = -1; + cullingPlane = -1; return false; } + bool Box::contains( const Vector3& point) const { @@ -264,7 +319,7 @@ bool Box::contains( Vector3 osPoint = M.inverse() * (point - _corner[0]); return - (osPoint.x >= 0) && + (osPoint.x >= 0) && (osPoint.y >= 0) && (osPoint.z >= 0) && (osPoint.x <= 1) && @@ -274,47 +329,51 @@ bool Box::contains( #undef setMany -#if 0 + void Box::getRandomSurfacePoint(Vector3& P, Vector3& N) const { float aXY = _extent.x * _extent.y; float aYZ = _extent.y * _extent.z; float aZX = _extent.z * _extent.x; - float r = (float)random(0, aXY + aYZ + aZX); + float r = (float)uniformRandom(0, aXY + aYZ + aZX); // Choose evenly between positive and negative face planes - float d = (random(0, 1) < 0.5f) ? -1.0f : 1.0f; + float d = (uniformRandom(0, 1) < 0.5f) ? -1.0f : 1.0f; // The probability of choosing a given face is proportional to // its area. if (r < aXY) { - P = _axis[0] * (float)random(-0.5, 0.5) * _extent.x + - _axis[1] * (float)random(-0.5, 0.5) * _extent.y + + P = _axis[0] * (float)uniformRandom(-0.5, 0.5) * _extent.x + + _axis[1] * (float)uniformRandom(-0.5, 0.5) * _extent.y + _center + _axis[2] * d * _extent.z * 0.5f; N = _axis[2] * d; } else if (r < aYZ) { - P = _axis[1] * (float)random(-0.5, 0.5) * _extent.y + - _axis[2] * (float)random(-0.5, 0.5) * _extent.z + + P = _axis[1] * (float)uniformRandom(-0.5, 0.5) * _extent.y + + _axis[2] * (float)uniformRandom(-0.5, 0.5) * _extent.z + _center + _axis[0] * d * _extent.x * 0.5f; N = _axis[0] * d; } else { - P = _axis[2] * (float)random(-0.5, 0.5) * _extent.z + - _axis[0] *(float) random(-0.5, 0.5) * _extent.x + + P = _axis[2] * (float)uniformRandom(-0.5, 0.5) * _extent.z + + _axis[0] *(float) uniformRandom(-0.5, 0.5) * _extent.x + _center + _axis[1] * d * _extent.y * 0.5f; N = _axis[1] * d; } } + Vector3 Box::randomInteriorPoint() const { Vector3 sum = _center; for (int a = 0; a < 3; ++a) { - sum += _axis[a] * (float)random(-0.5, 0.5) * _extent[a]; + sum += _axis[a] * (float)uniformRandom(-0.5, 0.5) * _extent[a]; } return sum; } -#endif + +Box Box::inf() { + return Box(-Vector3::inf(), Vector3::inf()); +} void Box::getBounds(class AABox& aabb) const { @@ -330,5 +389,5 @@ void Box::getBounds(class AABox& aabb) const { aabb = AABox(lo, hi); } -} // namespace +} // namespace diff --git a/dep/src/g3dlite/Box2D.cpp b/dep/src/g3dlite/Box2D.cpp new file mode 100644 index 00000000000..ea5a47af1a9 --- /dev/null +++ b/dep/src/g3dlite/Box2D.cpp @@ -0,0 +1,113 @@ +/** + @file Box.cpp + Box class + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2001-06-02 + @edited 2008-12-27 +*/ + +#include "G3D/Box2D.h" +#include "G3D/CoordinateFrame.h" +#include "G3D/Rect2D.h" + +namespace G3D { + +bool Box2D::overlaps1Way(const Box2D& other) const { + for (int a = 0; a < 2; ++a) { + + float t = other.m_corner[0].dot(m_axisin[a]); + + // Find the extent of box 2 on m_axisin a + float tMin = t; + float tMax = t; + + for (int c = 1; c < 4; ++c) { + t = other.m_corner[c].dot(m_axisin[a]); + + if (t < tMin) { + tMin = t; + } else if (t > tMax) { + tMax = t; + } + } + + // We have to subtract off the origin + + // See if [tMin, tMax] intersects [0, 1] + if ((tMin > 1 + origin[a]) || (tMax < origin[a])) { + // There was no intersection along this dimension; + // the boxes cannot possibly overlap. + return false; + } + } + + // There was no dimension along which there is no intersection. + // Therefore the boxes overlap. + return true; +} + + +void Box2D::computeAxes() { + m_axis[0] = m_corner[1] - m_corner[0]; + m_axis[1] = m_corner[3] - m_corner[0]; + + // Make the length of each m_axisin = 1/edge length so we know any + // dot product must be less than 1 to fall within the edge. + float len[2]; + for (int a = 0; a < 2; ++a) { + float lenSq = m_axis[a].squaredLength(); + m_axisin[a] = m_axis[a] / lenSq; + origin[a] = m_corner[0].dot(m_axisin[a]); + len[a] = sqrt(lenSq); + m_axis[a] /= len[a]; + } + + // w * h + m_area = len[0] * len[1]; + + + m_center = (m_corner[0] + m_corner[2]) * 0.5f; +} + + +Box2D::Box2D(const Vector2& center, float w, float h, float angle) { + Vector2 X( cos(angle), sin(angle)); + Vector2 Y(-sin(angle), cos(angle)); + + X *= w / 2; + Y *= h / 2; + + m_corner[0] = center - X - Y; + m_corner[1] = center + X - Y; + m_corner[2] = center + X + Y; + m_corner[3] = center - X + Y; + + computeAxes(); +} + + +Box2D::Box2D(const AABox2D& b) { + for (int i = 0; i < 4; ++i) { + m_corner[i] = b.corner(i); + } + + computeAxes(); +} + + +Box2D::Box2D(const Vector2& min, const Vector2& max) { + *this = Box2D(Rect2D::xyxy(min, max)); +} + + +Box2D::Box2D(const CFrame& frame, Box2D& b) { + for (int i = 0; i < 4; ++i) { + m_corner[i] = frame.pointToWorldSpace(Vector3(b.corner(i), 0)).xy(); + } + computeAxes(); +} + + +} // G3D diff --git a/dep/src/g3dlite/BumpMapPreprocess.cpp b/dep/src/g3dlite/BumpMapPreprocess.cpp new file mode 100644 index 00000000000..20281caf8cb --- /dev/null +++ b/dep/src/g3dlite/BumpMapPreprocess.cpp @@ -0,0 +1,43 @@ +/** + \file BumpMapPreprocess.cpp + + \maintainer Morgan McGuire, http://graphics.cs.williams.edu + + \created 2010-01-28 + \edited 2010-01-28 + + Copyright 2000-2010, Morgan McGuire. + All rights reserved. + */ +#include "G3D/BumpMapPreprocess.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +BumpMapPreprocess::BumpMapPreprocess(const Any& any) { + *this = BumpMapPreprocess(); + for (Any::AnyTable::Iterator it = any.table().begin(); it.hasMore(); ++it) { + const std::string& key = toLower(it->key); + if (key == "lowpassfilter") { + lowPassFilter = it->value; + } else if (key == "zextentpixels") { + zExtentPixels = it->value; + } else if (key == "scalezbynz") { + scaleZByNz = it->value; + } else { + any.verify(false, "Illegal key: " + it->key); + } + } +} + + +BumpMapPreprocess::operator Any() const { + Any any(Any::TABLE, "BumpMapPreprocess"); + any["lowPassFilter"] = lowPassFilter; + any["zExtentPixels"] = zExtentPixels; + any["scaleZByNz"] = scaleZByNz; + return any; +} + +} diff --git a/dep/src/g3dlite/CMakeLists.txt b/dep/src/g3dlite/CMakeLists.txt index 8f0a6191623..0a548e44f8b 100644 --- a/dep/src/g3dlite/CMakeLists.txt +++ b/dep/src/g3dlite/CMakeLists.txt @@ -2,19 +2,48 @@ ########### next target ############### SET(g3dlite_STAT_SRCS - AABox.cpp - Box.cpp - Crypto.cpp - format.cpp - Matrix3.cpp - Plane.cpp - System.cpp - Triangle.cpp - Vector3.cpp - Vector4.cpp + AABox.cpp + Box.cpp + Crypto.cpp + format.cpp + Matrix3.cpp + Plane.cpp + System.cpp + Triangle.cpp + Vector3.cpp + Vector4.cpp + debugAssert.cpp + fileutils.cpp + g3dmath.cpp + g3dfnmatch.cpp + prompt.cpp + stringutils.cpp + Any.cpp + BinaryFormat.cpp + BinaryInput.cpp + BinaryOutput.cpp + Capsule.cpp + CollisionDetection.cpp + CoordinateFrame.cpp + Cylinder.cpp + Line.cpp + LineSegment.cpp + Log.cpp + Matrix4.cpp + MemoryManager.cpp + Quat.cpp + Random.cpp + Ray.cpp + ReferenceCount.cpp + Sphere.cpp + TextInput.cpp + TextOutput.cpp + UprightFrame.cpp + Vector2.cpp ) include_directories( + ${CMAKE_SOURCE_DIR}/dep/include ${CMAKE_SOURCE_DIR}/dep/include/g3dlite ) diff --git a/dep/src/g3dlite/Capsule.cpp b/dep/src/g3dlite/Capsule.cpp new file mode 100644 index 00000000000..2ad3891c960 --- /dev/null +++ b/dep/src/g3dlite/Capsule.cpp @@ -0,0 +1,179 @@ +/** + @file Capsule.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-02-07 + @edited 2005-08-18 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/Capsule.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/LineSegment.h" +#include "G3D/Sphere.h" +#include "G3D/CoordinateFrame.h" +#include "G3D/Line.h" +#include "G3D/AABox.h" + +namespace G3D { + +Capsule::Capsule(class BinaryInput& b) { + deserialize(b); +} + + +Capsule::Capsule() { +} + + +Capsule::Capsule(const Vector3& _p1, const Vector3& _p2, float _r) + : p1(_p1), p2(_p2), _radius(_r) { +} + + +void Capsule::serialize(class BinaryOutput& b) const { + p1.serialize(b); + p2.serialize(b); + b.writeFloat64(_radius); +} + + +void Capsule::deserialize(class BinaryInput& b) { + p1.deserialize(b); + p2.deserialize(b); + _radius = b.readFloat64(); +} + + +Line Capsule::axis() const { + return Line::fromTwoPoints(p1, p2); +} + + +float Capsule::volume() const { + return + // Sphere volume + pow(_radius, 3) * pi() * 4 / 3 + + + // Cylinder volume + pow(_radius, 2) * (p1 - p2).magnitude(); +} + + +float Capsule::area() const { + + return + // Sphere area + pow(_radius, 2) * 4 * pi() + + + // Cylinder area + twoPi() * _radius * (p1 - p2).magnitude(); +} + + +void Capsule::getBounds(AABox& out) const { + Vector3 min = p1.min(p2) - (Vector3(1, 1, 1) * _radius); + Vector3 max = p1.max(p2) + (Vector3(1, 1, 1) * _radius); + + out = AABox(min, max); +} + + +bool Capsule::contains(const Vector3& p) const { + return LineSegment::fromTwoPoints(p1, p2).distanceSquared(p) <= square(radius()); +} + + +void Capsule::getRandomSurfacePoint(Vector3& p, Vector3& N) const { + float h = height(); + float r = radius(); + + // Create a random point on a standard capsule and then rotate to the global frame. + + // Relative areas + float capRelArea = sqrt(r) / 2.0f; + float sideRelArea = r * h; + + float r1 = uniformRandom(0, capRelArea * 2 + sideRelArea); + + if (r1 < capRelArea * 2) { + + // Select a point uniformly at random on a sphere + N = Sphere(Vector3::zero(), 1).randomSurfacePoint(); + p = N * r; + p.y += sign(p.y) * h / 2.0f; + } else { + // Side + float a = uniformRandom(0, (float)twoPi()); + N.x = cos(a); + N.y = 0; + N.z = sin(a); + p.x = N.x * r; + p.z = N.y * r; + p.y = uniformRandom(-h / 2.0f, h / 2.0f); + } + + // Transform to world space + CoordinateFrame cframe; + getReferenceFrame(cframe); + + p = cframe.pointToWorldSpace(p); + N = cframe.normalToWorldSpace(N); +} + + +void Capsule::getReferenceFrame(CoordinateFrame& cframe) const { + cframe.translation = center(); + + Vector3 Y = (p1 - p2).direction(); + Vector3 X = (abs(Y.dot(Vector3::unitX())) > 0.9) ? Vector3::unitY() : Vector3::unitX(); + Vector3 Z = X.cross(Y).direction(); + X = Y.cross(Z); + cframe.rotation.setColumn(0, X); + cframe.rotation.setColumn(1, Y); + cframe.rotation.setColumn(2, Z); +} + + +Vector3 Capsule::randomInteriorPoint() const { + float h = height(); + float r = radius(); + + // Create a random point in a standard capsule and then rotate to the global frame. + + Vector3 p; + + float hemiVolume = pi() * (r*r*r) * 4 / 6.0; + float cylVolume = pi() * square(r) * h; + + float r1 = uniformRandom(0, 2.0 * hemiVolume + cylVolume); + + if (r1 < 2.0 * hemiVolume) { + + p = Sphere(Vector3::zero(), r).randomInteriorPoint(); + + p.y += sign(p.y) * h / 2.0f; + + } else { + + // Select a point uniformly at random on a disk + float a = uniformRandom(0, (float)twoPi()); + float r2 = sqrt(uniformRandom(0, 1)) * r; + + p = Vector3(cos(a) * r2, + uniformRandom(-h / 2.0f, h / 2.0f), + sin(a) * r2); + } + + // Transform to world space + CoordinateFrame cframe; + getReferenceFrame(cframe); + + return cframe.pointToWorldSpace(p); +} + +} // namespace diff --git a/dep/src/g3dlite/CollisionDetection.cpp b/dep/src/g3dlite/CollisionDetection.cpp new file mode 100644 index 00000000000..77eef0a5500 --- /dev/null +++ b/dep/src/g3dlite/CollisionDetection.cpp @@ -0,0 +1,2455 @@ +/** + @file CollisionDetection.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @cite Bounce direction based on Paul Nettle's ftp://ftp.3dmaileffects.com/pub/FluidStudios/CollisionDetection/Fluid_Studios_Generic_Collision_Detection_for_Games_Using_Ellipsoids.pdf and comments by Max McGuire. Ray-sphere code by Eric Haines. + + @created 2001-11-24 + @edited 2008-12-29 + */ + +#include "G3D/CoordinateFrame.h" +#include "G3D/platform.h" +#include "G3D/CollisionDetection.h" +#include "G3D/debugAssert.h" +#include "G3D/vectorMath.h" +#include "G3D/Capsule.h" +#include "G3D/Plane.h" +#include "G3D/Line.h" +#include "G3D/LineSegment.h" +#include "G3D/Sphere.h" +#include "G3D/Box.h" +#include "G3D/Triangle.h" +#include "G3D/Vector3.h" +#include "G3D/AABox.h" + +#ifdef _MSC_VER +// Turn on fast floating-point optimizations +#pragma float_control( push ) +#pragma fp_contract( on ) +#pragma fenv_access( off ) +#pragma float_control( except, off ) +#pragma float_control( precise, off ) +#endif + + +namespace G3D { + +bool CollisionDetection::ignoreBool; +Vector3 CollisionDetection::ignore; +Array<Vector3> CollisionDetection::ignoreArray; + + + +Vector3 CollisionDetection::separatingAxisForSolidBoxSolidBox( + const int separatingAxisIndex, + const Box & box1, + const Box & box2) { + debugAssert(separatingAxisIndex >= 0); + debugAssert(separatingAxisIndex < 15); + Vector3 axis; + if (separatingAxisIndex < 3) { + axis = box1.axis(separatingAxisIndex); + } else if (separatingAxisIndex < 6) { + axis = box2.axis(separatingAxisIndex - 3); + } else { + int box1Index = (separatingAxisIndex - 6) / 3; + int box2Index = (separatingAxisIndex - 6) % 3; + axis = cross(box1.axis(box1Index), box2.axis(box2Index)); + } + return axis; +} + +#ifdef _MSC_VER +# pragma warning (push) +# pragma warning (disable : 4244) +#endif + +float CollisionDetection::projectedDistanceForSolidBoxSolidBox( + const int separatingAxisIndex, + const Vector3 & a, + const Vector3 & b, + const Vector3 & D, + const double* c, + const double* ca, + const double* ad, + const double* bd) +{ + (void)D; + + float R0 = 0.0f; + float R1 = 0.0f; + float R = 0.0f; + switch (separatingAxisIndex) { + case 0: + // A0 + R0 = a[0]; + R1 = b[0] * ca[0] + b[1] * ca[1] + b[2] * ca[2]; + R = fabs(ad[0]); + break; + case 1: + // A1 + R0 = a[1]; + R1 = b[0] * ca[3] + b[1] * ca[4] + b[2] * ca[5]; + R = fabs(ad[1]); + break; + case 2: + // A2 + R0 = a[2]; + R1 = b[0] * ca[6] + b[1] * ca[7] + b[2] * ca[8]; + R = fabs(ad[2]); + break; + case 3: + // B0 + R0 = a[0] * ca[0] + a[1] * ca[3] + a[2] * ca[6]; + R1 = b[0]; + R = fabs(bd[0]); + break; + case 4: + // B1 + R0 = a[0] * ca[1] + a[1] * ca[4] + a[2] * ca[7]; + R1 = b[1]; + R = fabs(bd[1]); + break; + case 5: + // B2 + R0 = a[0] * ca[2] + a[1] * ca[5] + a[2] * ca[8]; + R1 = b[2]; + R = fabs(bd[2]); + break; + case 6: + // A0 x B0 + R0 = a[1] * ca[6] + a[2] * ca[3]; + R1 = b[1] * ca[2] + b[2] * ca[1]; + R = fabs(c[3] * ad[2] - c[6] * ad[1]); + break; + case 7: + // A0 x B1 + R0 = a[1] * ca[7] + a[2] * ca[4]; + R1 = b[0] * ca[2] + b[2] * ca[0]; + R = fabs(c[4] * ad[2] - c[7] * ad[1]); + break; + case 8: + // A0 x B2 + R0 = a[1] * ca[8] + a[2] * ca[5]; + R1 = b[0] * ca[1] + b[1] * ca[0]; + R = fabs(c[5] * ad[2] - c[8] * ad[1]); + break; + case 9: + // A1 x B0 + R0 = a[0] * ca[6] + a[2] * ca[0]; + R1 = b[1] * ca[5] + b[2] * ca[4]; + R = fabs(c[6] * ad[0] - c[0] * ad[2]); + break; + case 10: + // A1 x B1 + R0 = a[0] * ca[7] + a[2] * ca[1]; + R1 = b[0] * ca[5] + b[2] * ca[3]; + R = fabs(c[7] * ad[0] - c[1] * ad[2]); + break; + case 11: + // A1 x B2 + R0 = a[0] * ca[8] + a[2] * ca[2]; + R1 = b[0] * ca[4] + b[1] * ca[3]; + R = fabs(c[8] * ad[0] - c[2] * ad[2]); + break; + case 12: + // A2 x B0 + R0 = a[0] * ca[3] + a[1] * ca[0]; + R1 = b[1] * ca[8] + b[2] * ca[7]; + R = fabs(c[0] * ad[1] - c[3] * ad[0]); + break; + case 13: + // A2 x B1 + R0 = a[0] * ca[4] + a[1] * ca[1]; + R1 = b[0] * ca[8] + b[2] * ca[6]; + R = fabs(c[1] * ad[1] - c[4] * ad[0]); + break; + case 14: + // A2 x B2 + R0 = a[0] * ca[5] + a[1] * ca[2]; + R1 = b[0] * ca[7] + b[1] * ca[6]; + R = fabs(c[2] * ad[1] - c[5] * ad[0]); + break; + default: + debugAssertM(false, "fell through switch statement"); + } + + return (R - (R0 + R1)); +} + + +bool CollisionDetection::parallelAxisForSolidBoxSolidBox( + const double* ca, + const double epsilon, + int & axis1, + int & axis2) { + const double parallelDot = 1.0 - epsilon; + for (int i = 0; i < 9; i++) { + if (ca[i] >= parallelDot) { + axis1 = i / 3; + axis2 = i % 3; + return true; + } + } + return false; +} + + + + +void CollisionDetection::fillSolidBoxSolidBoxInfo( + const Box & box1, + const Box & box2, + Vector3 & a, + Vector3 & b, + Vector3 & D, + double* c, + double* ca, + double* ad, + double* bd) { + // length between center and each side of box1 and box2 + a = box1.extent() * 0.5; + b = box2.extent() * 0.5; + + // difference between centers of box1 and box2 + D = box2.center() - box1.center(); + + // store the value of all possible dot products between the + // axes of box1 and box2, c_{row, col} in the Eberly paper + // corresponds to c[row * 3 + col] for this 9 element array. + // + // c[] holds signed values, ca[] hold absolute values + for (int i = 0; i < 9; i++) { + c[i] = dot(box1.axis(i / 3), box2.axis(i % 3)); + ca[i] = fabs(c[i]); + } + + // store all possible dot products between the axes of box1 and D, + // as well as the axes of box2 and D + for (int i = 0; i < 3; i++) { + ad[i] = dot(box1.axis(i), D); + bd[i] = dot(box2.axis(i), D); + } +} + + + +bool CollisionDetection::conservativeBoxBoxTest( + const Vector3 & a, const Vector3 & b, const Vector3 & D) { + // do a quick bounding sphere test because it is relatively + // cheap, (three dot products, two sqrts, and a few others) + double boxRadius1 = a.magnitude(); + double boxRadius2 = b.magnitude(); + return (D.squaredMagnitude() < square(boxRadius1 + boxRadius2)); +} + + + + +bool CollisionDetection::fixedSolidBoxIntersectsFixedSolidBox( + const Box& box1, + const Box& box2, + const int lastSeparatingAxis) { + // for explanations of the variable please refer to the + // paper and fillSolidBoxSolidBoxInfo() + Vector3 a; + Vector3 b; + Vector3 D; + double c[9]; + double ca[9]; + double ad[3]; + double bd[3]; + + fillSolidBoxSolidBoxInfo(box1, box2, a, b, D, c, ca, ad, bd); + + int dummy1, dummy2; + bool parallelAxes = parallelAxisForSolidBoxSolidBox(ca, 0.00001, + dummy1, dummy2); + + // check the separating axis from the last time step + if (lastSeparatingAxis != -1 && + (lastSeparatingAxis < 6 || !parallelAxes)) { + double projectedDistance = projectedDistanceForSolidBoxSolidBox( + lastSeparatingAxis, a, b, D, c, ca, ad, bd); + + // the separating axis from the last time step is still + // valid, the boxes do not intersect + if (projectedDistance > 0.0) { + return false; + } + } + + // test if the boxes can be separated by a plane normal to + // any of the three axes of box1, any of the three axes of box2, + // or any of the 9 possible cross products of axes from box1 + // and box2 + for (int i = 0; i < 15; i++) { + // do not need to check edge-edge cases if any two of + // the axes are parallel + if (parallelAxes && i == 6) { + return true; + } + + double projectedDistance = + projectedDistanceForSolidBoxSolidBox(i, a, b, D, c, ca, ad, bd); + + // found a separating axis, the boxes do not intersect + if (projectedDistance > 0.0) { + return false; + } + } + + return true; +} + + + +void CollisionDetection::closestPointsBetweenLineAndLine( + const Line & line1, + const Line & line2, + Vector3 & closest1, + Vector3 & closest2) { + // TODO make accessors for Line that don't make a copy of data + Vector3 P0 = line1.point(); + Vector3 u = line1.direction(); + Vector3 Q0 = line2.point(); + Vector3 v = line2.direction(); + Vector3 w0 = P0 - Q0; + + // a = 1.0, c = 1.0 + double b = dot(u, v); + double d = dot(u, w0); + double e = dot(v, w0); + double D = 1.0 - b * b; + double sc, tc; + + static const double epsilon = 0.00001; + + if (D < epsilon) { + // lines are parallel, choose P0 as one point, find the point + // on line2 that is closest to P0 + sc = 0.0; + tc = (b > 1.0) ? (d / b) : (e / 1.0); + } else { + // lines are not parallel + sc = (b * e - 1.0 * d) / D; + tc = (1.0 * e - b * d) / D; + } + + closest1 = P0 + (sc * u); + closest2 = Q0 + (tc * v); +} + + + +float CollisionDetection::penetrationDepthForFixedBoxFixedBox( + const Box& box1, + const Box& box2, + Array<Vector3>& contactPoints, + Array<Vector3>& contactNormals, + const int lastSeparatingAxis) { + + contactPoints.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + contactNormals.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + + Vector3 a; + Vector3 b; + Vector3 D; + double c[9]; + double ca[9]; + double ad[3]; + double bd[3]; + + debugAssert(lastSeparatingAxis >= -1); + debugAssert(lastSeparatingAxis < 15); + + fillSolidBoxSolidBoxInfo(box1, box2, a, b, D, c, ca, ad, bd); + + int axis1, axis2; + bool parallelAxes = parallelAxisForSolidBoxSolidBox(ca, 0.00001, + axis1, axis2); + + + // check the separating axis from the last time step + if (lastSeparatingAxis != -1 && + (lastSeparatingAxis < 6 || !parallelAxes)) { + float projectedDistance = projectedDistanceForSolidBoxSolidBox( + lastSeparatingAxis, a, b, D, c, ca, ad, bd); + + // the separating axis from the last time step is still + // valid, the boxes do not intersect + if (projectedDistance > 0.0) { + return -projectedDistance; + } + } + + // test if the boxes can be separated by a plane normal to + // any of the three axes of box1, any of the three axes of box2, + // (test 9 possible cross products later) + float penetration = -finf(); + int penetrationAxisIndex = -1; + + for (int i = 0; i < 6; i++) { + float projectedDistance = + projectedDistanceForSolidBoxSolidBox(i, a, b, D, c, ca, ad, bd); + + // found a separating axis, the boxes do not intersect + if (projectedDistance > 0.0) { + return -projectedDistance; + } + + // keep track of the axis that is least violated + if (projectedDistance > penetration) { + penetration = projectedDistance; + penetrationAxisIndex = i; + } + } + + + // for each edge-edge case we have to adjust the magnitude of + // penetration since we did not include the dot(L, L) denominator + // that can be smaller than 1.0 for the edge-edge cases. + if (!parallelAxes) { + double edgeDistances[9]; + + // run through edge-edge cases to see if we can find a separating axis + for (int i = 6; i < 15; i++) { + float projectedDistance = + projectedDistanceForSolidBoxSolidBox(i, a, b, D, c, ca, ad, bd); + + // found a separating axis, the boxes do not intersect, + // correct magnitude and return projected distance + if (projectedDistance > 0.0) { + Vector3 L = separatingAxisForSolidBoxSolidBox(i, box1, box2); + projectedDistance /= dot(L, L); + return -projectedDistance; + } + + edgeDistances[i - 6] = projectedDistance; + } + + // no separating axis found, the boxes do intersect, + // correct the magnitudes of the projectedDistance values + for (int i = 6; i < 15; i++) { + // find the negative penetration value with the smallest magnitude, + // the adjustment done for the edge-edge cases only increases + // magnitude by dividing by a number smaller than 1 and greater than 0 + float projectedDistance = (float)edgeDistances[i - 6]; + if (projectedDistance > penetration) { + Vector3 L = separatingAxisForSolidBoxSolidBox(i, box1, box2); + projectedDistance /= dot(L, L); + if (projectedDistance > penetration) { + penetration = projectedDistance; + penetrationAxisIndex = i; + } + } + } + } + + // get final separating axis vector + Vector3 L = separatingAxisForSolidBoxSolidBox(penetrationAxisIndex, + box1, box2); + + // set L to be the normal that faces away from box1 + if (dot(L, D) < 0) { + L = -L; + } + + Vector3 contactPoint; + + if (penetrationAxisIndex < 6) { + // vertex to face collision, find deepest colliding vertex + const Box* vertexBox; + const Box* faceBox; + Vector3 faceNormal = L; + + // L will be the outward facing normal for the faceBox + if (penetrationAxisIndex < 3) { + faceBox = & box1; + vertexBox = & box2; + if (dot(L, D) < 0) { + faceNormal = -L; + } + } else { + faceBox = & box2; + vertexBox = & box1; + if (dot(L, D) > 0) { + faceNormal = -L; + } + } + + // find the vertex that is farthest away in the direction + // face normal direction + int deepestPointIndex = 0; + float deepestPointDot = dot(faceNormal, vertexBox->corner(0)); + for (int i = 1; i < 8; i++) { + float dotProduct = dot(faceNormal, vertexBox->corner(i)); + if (dotProduct < deepestPointDot) { + deepestPointDot = dotProduct; + deepestPointIndex = i; + } + } + + // return the point half way between the deepest point and the + // contacting face + contactPoint = vertexBox->corner(deepestPointIndex) + + (-penetration * 0.5 * faceNormal); + } else { + // edge-edge case, find the two ege lines + int edge1 = (penetrationAxisIndex - 6) / 3; + int edge2 = (penetrationAxisIndex - 6) % 3; + Vector3 linePoint1 = box1.center(); + Vector3 linePoint2 = box2.center(); + Vector3 lineDir1; + Vector3 lineDir2; + + // find edge line by finding the edge axis, and the + // other two axes that are closest to the other box + for (int i = 0; i < 3; i++ ) { + if (i == edge1) { + lineDir1 = box1.axis(i); + } else { + Vector3 axis = box1.axis(i); + if (dot(axis, L) < 0) { + axis = -axis; + } + linePoint1 += axis * a[i]; + } + + if (i == edge2) { + lineDir2 = box2.axis(i); + } else { + Vector3 axis = box2.axis(i); + if (dot(axis, L) > 0) { + axis = -axis; + } + linePoint2 += axis * b[i]; + } + } + + // make lines from the two closest edges, and find + // the points that on each line that are closest to the other + Line line1 = Line::fromPointAndDirection(linePoint1, lineDir1); + Line line2 = Line::fromPointAndDirection(linePoint2, lineDir2); + Vector3 closest1; + Vector3 closest2; + + closestPointsBetweenLineAndLine(line1, line2, closest1, closest2); + + // take the average of the two closest edge points for the final + // contact point + contactPoint = (closest1 + closest2) * 0.5; + } + + contactPoints.push(contactPoint); + contactNormals.push(L); + + return -penetration; + +} + + + + +float CollisionDetection::penetrationDepthForFixedSphereFixedBox( + const Sphere& sphere, + const Box& box, + Array<Vector3>& contactPoints, + Array<Vector3>& contactNormals) { + + contactPoints.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + contactNormals.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + + // In its local coordinate frame, the box measures + // 2 * halfExtent[a] along dimesion a. + Vector3 halfExtent(box.extent(0), box.extent(1), box.extent(2)); + halfExtent *= 0.5f; + + CoordinateFrame boxFrame; + box.getLocalFrame(boxFrame); + + // Transform the sphere to the box's coordinate frame. + Vector3 center = boxFrame.pointToObjectSpace(sphere.center); + + // Find the square of the distance from the sphere to the box + + + // Distance along each axis from the closest side of the box + // to the sphere center. Negative values are *inside* the box. + Vector3 distOutsideBox; + + // Divide space up into the 27 regions corresponding + // to {+|-|0}X, {+|-|0}Y, {+|-|0}Z and classify the + // sphere center into one of them. + Vector3 centerRegion; + + // In the edge collision case, the edge is between vertices + // (constant + variable) and (constant - variable). + Vector3 constant, variable; + + int numNonZero = 0; + + // Iterate over axes + for (int a = 0; a < 3; ++a) { + // For each (box side), see which direction the sphere + // is outside the box (positive or negative). Add the + // square of that distance to the total distance from + // the box. + + float distanceFromLow = -halfExtent[a] - center[a]; + float distanceFromHigh = center[a] - halfExtent[a]; + + if (fabsf(distanceFromLow) < fabsf(distanceFromHigh)) { + distOutsideBox[a] = distanceFromLow; + } else { + distOutsideBox[a] = distanceFromHigh; + } + + if (distanceFromLow < 0.0) { + if (distanceFromHigh < 0.0) { + // Inside the box + centerRegion[a] = 0.0; + variable[a] = 1.0; + } else { + // Off the high side + centerRegion[a] = 1.0; + constant[a] = halfExtent[a]; + ++numNonZero; + } + } else if (distanceFromHigh < 0.0) { + // Off the low side + centerRegion[a] = -1.0; + constant[a] = -halfExtent[a]; + ++numNonZero; + } else { + debugAssertM(false, + "distanceFromLow and distanceFromHigh cannot both be positive"); + } + } + + // Squared distance between the outside of the box and the + // sphere center. + float d2 = Vector3::zero().max(distOutsideBox).squaredMagnitude(); + + if (d2 > square(sphere.radius)) { + // There is no penetration because the distance is greater + // than the radius of the sphere. This is the common case + // and we quickly exit. + return -1; + } + + // We know there is some penetration but need to classify it. + // + // Examine the region that contains the center of the sphere. If + // there is exactly one non-zero axis, the collision is with a + // plane. If there are exactly two non-zero axes, the collision + // is with an edge. If all three axes are non-zero, the collision is + // with a vertex. If there are no non-zero axes, the center is inside + // the box. + + double depth = -1; + switch (numNonZero) { + case 3: // Vertex collision + // The collision point is the vertex at constant, the normal + // is the vector from there to the sphere center. + contactNormals.append(boxFrame.normalToWorldSpace(constant - center)); + contactPoints.append(boxFrame.pointToWorldSpace(constant)); + depth = sphere.radius - sqrt(d2); + break; + + case 2: // Edge collision + { + // TODO: unwrapping the edge constructor and closest point + // code will probably make it faster. + + // Determine the edge + Line line = Line::fromPointAndDirection(constant, variable); + + // Penetration depth: + depth = sphere.radius - sqrt(d2); + + // The contact point is the closes point to the sphere on the line + Vector3 X = line.closestPoint(center); + contactNormals.append(boxFrame.normalToWorldSpace(X - center).direction()); + contactPoints.append(boxFrame.pointToWorldSpace(X)); + } + break; + + case 1: // Plane collision + { + // The plane normal is the centerRegion vector, + // so the sphere normal is the negative. Take + // it to world space from box-space. + + // Center region doesn't need to be normalized because + // it is known to contain only one non-zero value + // and that value is +/- 1. + Vector3 N = boxFrame.normalToWorldSpace(-centerRegion); + contactNormals.append(N); + + // Penetration depth: + depth = sphere.radius - sqrtf(d2); + + // Compute the contact point from the penetration depth + contactPoints.append(sphere.center + N * (sphere.radius - depth)); + } + break; + + case 0: // Volume collision + + // The sphere center is inside the box. This is an easy case + // to handle. Note that all axes of distOutsideBox must + // be negative. + + // Arbitratily choose the sphere center as a contact point + contactPoints.append(sphere.center); + + // Find the least-negative penetration axis. + // + // We could have computed this during the loop over the axes, + // but since volume collisions are rare (they only occur with + // large time steps), this case will seldom be executed and + // should not be optimized at the expense of the others. + if (distOutsideBox.x > distOutsideBox.y) { + if (distOutsideBox.x > distOutsideBox.z) { + // Smallest penetration on x-axis + // Chose normal based on which side we're closest to. + // Keep in mind that this is a normal to the sphere, + // so it is the inverse of the box normal. + if (center.x > 0) { + contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitX())); + } else { + contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitX())); + } + depth = -distOutsideBox.x; + } else { + // Smallest penetration on z-axis + goto ZAXIS; + } + } else if (distOutsideBox.y > distOutsideBox.z) { + // Smallest penetration on y-axis + // Chose normal based on which side we're closest to. + // Keep in mind that this is a normal to the sphere, + // so it is the inverse of the box normal. + if (center.y > 0) { + contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitY())); + } else { + contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitY())); + } + depth = -distOutsideBox.y; + } else { + // Smallest on z-axis +ZAXIS: + // Chose normal based on which side we're closest to. + // Keep in mind that this is a normal to the sphere, + // so it is the inverse of the box normal. + if (center.z > 0) { + contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitZ())); + } else { + contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitZ())); + } + depth = -distOutsideBox.z; + } + break; + + default: + debugAssertM(false, "Fell through switch"); + break; + } + + return depth; +} + + +float CollisionDetection::penetrationDepthForFixedSphereFixedSphere( + const Sphere& sphereA, + const Sphere& sphereB, + Array<Vector3>& contactPoints, + Array<Vector3>& contactNormals) { + + Vector3 axis = sphereB.center - sphereA.center; + double radius = sphereA.radius + sphereB.radius; + double mag = axis.magnitude(); + axis /= mag; + double depth = -(mag - radius); + + contactPoints.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + contactNormals.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + + if (depth >= 0) { + contactPoints.append(sphereA.center + axis * (sphereA.radius - depth / 2)); + contactNormals.append(axis); + } + + return depth; +} + + +float CollisionDetection::penetrationDepthForFixedSphereFixedPlane( + const Sphere& sphereA, + const Plane& planeB, + Array<Vector3>& contactPoints, + Array<Vector3>& contactNormals) { + + Vector3 N; + double d; + + planeB.getEquation(N, d); + + double depth = -(sphereA.center.dot(N) + d - sphereA.radius); + + contactPoints.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + contactNormals.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + + if (depth >= 0) { + contactPoints.append(N * (depth - sphereA.radius) + sphereA.center); + contactNormals.append(N); + } + + return depth; +} + + +float CollisionDetection::penetrationDepthForFixedBoxFixedPlane( + const Box& box, + const Plane& plane, + Array<Vector3>& contactPoints, + Array<Vector3>& contactNormals) { + + Vector3 N; + double d; + + plane.getEquation(N, d); + + contactPoints.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + contactNormals.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); + + float lowest = finf(); + for (int i = 0; i < 8; ++i) { + const Vector3 vertex = box.corner(i); + + float x = vertex.dot(N) + (float)d; + + if (x <= 0) { + // All vertices below the plane should be contact points. + contactPoints.append(vertex); + contactNormals.append(-N); + } + + lowest = min(lowest, x); + } + + // Depth should be a positive number + return -lowest; +} + + +float CollisionDetection::collisionTimeForMovingPointFixedPlane( + const Vector3& point, + const Vector3& velocity, + const Plane& plane, + Vector3& location, + Vector3& outNormal) { + + // Solve for the time at which normal.dot(point + velocity) + d == 0. + double d; + Vector3 normal; + plane.getEquation(normal, d); + + float vdotN = velocity.dot(normal); + float pdotN = point.dot(normal); + + if (fuzzyEq(pdotN + d, 0)) { + // The point is *in* the plane. + location = point; + outNormal = normal; + return 0; + } + + if (vdotN >= 0) { + // no collision will occur + location = Vector3::inf(); + return finf(); + } + + float t = -(pdotN + d) / vdotN; + if (t < 0) { + location = Vector3::inf(); + return finf(); + } else { + location = point + velocity * t; + outNormal = normal; + return t; + } +} + +bool __fastcall CollisionDetection::rayAABox( + const Ray& ray, + const Vector3& invDir, + const AABox& box, + const Vector3& boxCenter, + float boundingRadiusSquared, + Vector3& location, + bool& inside) { + + debugAssertM(fabs(ray.direction().squaredLength() - 1.0f) < 0.01f, format("Length = %f", ray.direction().length())); + { + // Pre-emptive partial bounding sphere test + const Vector3 L(boxCenter - ray.origin()); + float d = L.dot(ray.direction()); + + float L2 = L.dot(L); + float D2 = square(d); + float M2 = L2 - D2; + + if (((d < 0) && (L2 > boundingRadiusSquared)) || (M2 > boundingRadiusSquared)) { + inside = false; + return false; + } + // Passing here does not mean that the ray hits the bounding sphere; + // we would still have to perform more expensive tests to determine + // that. + } + + inside = true; + const Vector3& MinB = box.low(); + const Vector3& MaxB = box.high(); + Vector3 MaxT(-1.0f, -1.0f, -1.0f); + + // Find candidate planes. + for (int i = 0; i < 3; ++i) { + if (ray.origin()[i] < MinB[i]) { + location[i] = MinB[i]; + inside = false; + + // Calculate T distances to candidate planes + if (ray.direction()[i] != 0) { + MaxT[i] = (MinB[i] - ray.origin()[i]) * invDir[i]; + } + } else if (ray.origin()[i] > MaxB[i]) { + location[i] = MaxB[i]; + inside = false; + + // Calculate T distances to candidate planes + if (ray.direction()[i] != 0) { + MaxT[i] = (MaxB[i] - ray.origin()[i]) * invDir[i]; + } + } + } + + if (inside) { + // Ray origin inside bounding box + location = ray.origin(); + return true; + } + + // Get largest of the maxT's for final choice of intersection + int WhichPlane = 0; + if (MaxT[1] > MaxT[WhichPlane]) { + WhichPlane = 1; + } + + if (MaxT[2] > MaxT[WhichPlane]) { + WhichPlane = 2; + } + + // Check final candidate actually inside box + if (MaxT[WhichPlane] < 0.0f) { + // Miss the box + return false; + } + + for (int i = 0; i < 3; ++i) { + if (i != WhichPlane) { + location[i] = ray.origin()[i] + MaxT[WhichPlane] * ray.direction()[i]; + if ((location[i] < MinB[i]) || + (location[i] > MaxB[i])) { + // On this plane we're outside the box extents, so + // we miss the box + return false; + } + } + } + + return true; +} + +float CollisionDetection::collisionTimeForMovingPointFixedSphere( + const Vector3& point, + const Vector3& velocity, + const Sphere& sphere, + Vector3& location, + Vector3& outNormal, + bool solid) { + + if (solid && sphere.contains(point)) { + location = point; + outNormal = (point - sphere.center).direction(); + return 0.0f; + } + + float speed = velocity.magnitude(); + const Vector3& direction = velocity / speed; + + // length of the axis between the start and the sphere + const Vector3& L = sphere.center - point; + float d = L.dot(direction); + + float L2 = L.dot(L); + float R2 = square(sphere.radius); + float D2 = square(d); + + if ((d < 0.0f) && (L2 > R2)) { + location = Vector3::inf(); + return finf(); + } + + const float M2 = L2 - D2; + + if (M2 > R2) { + location = Vector3::inf(); + return finf(); + } + + float q = sqrt(R2 - M2); + float time; + + if (L2 > R2) { + time = d - q; + } else { + time = d + q; + } + + time /= speed; + + location = point + velocity * time; + outNormal = (location - sphere.center).direction(); + + return time; +} + + +float CollisionDetection::collisionTimeForMovingSphereFixedSphere( + const Sphere& movingSphere, + const Vector3& velocity, + const Sphere& fixedSphere, + Vector3& location, + Vector3& outNormal) { + + const Vector3& sep = (fixedSphere.center - movingSphere.center); + float sepLen = sep.squaredLength(); + if (sepLen < square(movingSphere.radius + fixedSphere.radius)) { + // Interpenetrating + outNormal = sep.directionOrZero(); + location = fixedSphere.center - outNormal * fixedSphere.radius; + return 0; + } + + float time = collisionTimeForMovingPointFixedSphere + (movingSphere.center, velocity, + Sphere(fixedSphere.center, fixedSphere.radius + movingSphere.radius), + location, outNormal); + + if (time < finf()) { + // Location is now the center of the moving sphere at the collision time. + // Adjust for the size of the moving sphere. Two spheres always collide + // along a line between their centers. + location += (location - fixedSphere.center) * movingSphere.radius / fixedSphere.radius; + } + + return time; +} + + +/* +float CollisionDetection::collisionTimeForMovingPointFixedTriangle( + const Vector3& point, + const Vector3& velocity, + const Triangle& triangle, + Vector3& outLocation, + Vector3& outNormal) { + + double time = collisionTimeForMovingPointFixedPlane(point, velocity, triangle.plane(), outLocation, outNormal); + + if (time == finf()) { + // No collision with the plane of the triangle. + return finf(); + } + + if (isPointInsideTriangle(triangle.vertex(0), triangle.vertex(1), triangle.vertex(2), triangle.normal(), outLocation, triangle.primaryAxis())) { + // Collision occured inside the triangle + return time; + } else { + // Missed the triangle + outLocation = Vector3::inf(); + return finf(); + } +}*/ + +/* +float CollisionDetection::collisionTimeForMovingPointFixedTriangle( + const Vector3& orig, + const Vector3& dir, + const Vector3& vert0, + const Vector3& vert1, + const Vector3& vert2) { + + // Barycenteric coords + double u, v; + #define EPSILON 0.000001 + #define CROSS(dest,v1,v2) \ + dest[0]=v1[1]*v2[2]-v1[2]*v2[1]; \ + dest[1]=v1[2]*v2[0]-v1[0]*v2[2]; \ + dest[2]=v1[0]*v2[1]-v1[1]*v2[0]; + + #define DOT(v1,v2) (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2]) + + #define SUB(dest,v1,v2) \ + dest[0]=v1[0]-v2[0]; \ + dest[1]=v1[1]-v2[1]; \ + dest[2]=v1[2]-v2[2]; + + double edge1[3], edge2[3], tvec[3], pvec[3], qvec[3]; + + // find vectors for two edges sharing vert0 + SUB(edge1, vert1, vert0); + SUB(edge2, vert2, vert0); + + // begin calculating determinant - also used to calculate U parameter + CROSS(pvec, dir, edge2); + + // if determinant is near zero, ray lies in plane of triangle + const double det = DOT(edge1, pvec); + + if (det < EPSILON) { + return finf(); + } + + // calculate distance from vert0 to ray origin + SUB(tvec, orig, vert0); + + // calculate U parameter and test bounds + u = DOT(tvec, pvec); + if ((u < 0.0) || (u > det)) { + // Hit the plane outside the triangle + return finf(); + } + + // prepare to test V parameter + CROSS(qvec, tvec, edge1); + + // calculate V parameter and test bounds + v = DOT(dir, qvec); + if ((v < 0.0) || (u + v > det)) { + // Hit the plane outside the triangle + return finf(); + } + + // calculate t, scale parameters, ray intersects triangle + // If we want u,v, we can compute this + // double t = DOT(edge2, qvec); + //const double inv_det = 1.0 / det; + //t *= inv_det; + //u *= inv_det; + //v *= inv_det; + // return t; + + // Case where we don't need correct (u, v): + + const double t = DOT(edge2, qvec); + + if (t >= 0) { + // Note that det must be positive + return t / det; + } else { + // We had to travel backwards in time to intersect + return finf(); + } + + #undef EPSILON + #undef CROSS + #undef DOT + #undef SUB +} +*/ + +float CollisionDetection::collisionTimeForMovingPointFixedBox( + const Vector3& point, + const Vector3& velocity, + const Box& box, + Vector3& location, + Vector3& outNormal) { + + double bestTime; + + Vector3 normal; + Vector3 v[4]; + + // Prime the loop + int f = 0; + box.getFaceCorners(f, v[0], v[1], v[2], v[3]); + bestTime = collisionTimeForMovingPointFixedRectangle(point, velocity, v[0], v[1], v[2], v[3], location, normal); + outNormal = normal; + + // Check other faces + for (f = 1; f < 6; ++f) { + Vector3 pos; + box.getFaceCorners(f, v[0], v[1], v[2], v[3]); + float time = collisionTimeForMovingPointFixedRectangle(point, velocity, v[0], v[1], v[2], v[3], pos, normal); + if (time < bestTime) { + bestTime = time; + outNormal = normal; + location = pos; + } + } + + return bestTime; +} + + +float CollisionDetection::collisionTimeForMovingPointFixedAABox( + const Vector3& origin, + const Vector3& dir, + const AABox& box, + Vector3& location, + bool& Inside, + Vector3& normal) { + + if (collisionLocationForMovingPointFixedAABox(origin, dir, box, location, Inside, normal)) { + return (location - origin).magnitude(); + } else { + return (float)finf(); + } +} + + +bool CollisionDetection::collisionLocationForMovingPointFixedAABox( + const Vector3& origin, + const Vector3& dir, + const AABox& box, + Vector3& location, + bool& Inside, + Vector3& normal) { + + // Integer representation of a floating-point value. + #define IR(x) ((uint32&)x) + + Inside = true; + const Vector3& MinB = box.low(); + const Vector3& MaxB = box.high(); + Vector3 MaxT(-1.0f, -1.0f, -1.0f); + + // Find candidate planes. + for (int i = 0; i < 3; ++i) { + if (origin[i] < MinB[i]) { + location[i] = MinB[i]; + Inside = false; + + // Calculate T distances to candidate planes + if (IR(dir[i])) { + MaxT[i] = (MinB[i] - origin[i]) / dir[i]; + } + } else if (origin[i] > MaxB[i]) { + location[i] = MaxB[i]; + Inside = false; + + // Calculate T distances to candidate planes + if (IR(dir[i])) { + MaxT[i] = (MaxB[i] - origin[i]) / dir[i]; + } + } + } + + if (Inside) { + // Ray origin inside bounding box + location = origin; + return false; + } + + // Get largest of the maxT's for final choice of intersection + int WhichPlane = 0; + if (MaxT[1] > MaxT[WhichPlane]) { + WhichPlane = 1; + } + + if (MaxT[2] > MaxT[WhichPlane]) { + WhichPlane = 2; + } + + // Check final candidate actually inside box + if (IR(MaxT[WhichPlane]) & 0x80000000) { + // Miss the box + return false; + } + + for (int i = 0; i < 3; ++i) { + if (i != WhichPlane) { + location[i] = origin[i] + MaxT[WhichPlane] * dir[i]; + if ((location[i] < MinB[i]) || + (location[i] > MaxB[i])) { + // On this plane we're outside the box extents, so + // we miss the box + return false; + } + } + } + + // Choose the normal to be the plane normal facing into the ray + normal = Vector3::zero(); + normal[WhichPlane] = (dir[WhichPlane] > 0) ? -1.0 : 1.0; + + return true; + + #undef IR +} + + + +float CollisionDetection::collisionTimeForMovingPointFixedRectangle( + const Vector3& point, + const Vector3& velocity, + const Vector3& v0, + const Vector3& v1, + const Vector3& v2, + const Vector3& v3, + Vector3& location, + Vector3& outNormal) { + + Plane plane = Plane(v0, v1, v2); + + float time = collisionTimeForMovingPointFixedPlane(point, velocity, plane, location, outNormal); + + if (time == finf()) { + // No collision is ever going to happen + return time; + } + + if (isPointInsideRectangle(v0, v1, v2, v3, plane.normal(), location)) { + // The intersection point is inside the rectangle; that is the location where + // the point hits the rectangle. + return time; + } else { + return finf(); + } +} + +/** Used by findRayCapsuleIntersection. + @cite From magic software http://www.magic-software.com/Source/Intersection3D/MgcIntr3DLinCap.cpp */ +static int findRayCapsuleIntersectionAux( + const Vector3& rkOrigin, + const Vector3& rkDirection, + const Capsule& rkCapsule, + double afT[2]) { + + Vector3 capsuleDirection = rkCapsule.point(1) - rkCapsule.point(0); + + // set up quadratic Q(t) = a*t^2 + 2*b*t + c + Vector3 kU, kV, kW = capsuleDirection; + float fWLength = kW.unitize(); + Vector3::generateOrthonormalBasis(kU, kV, kW); + Vector3 kD(kU.dot(rkDirection), kV.dot(rkDirection), kW.dot(rkDirection)); + float fDLength = kD.unitize(); + + float fEpsilon = 1e-6f; + + float fInvDLength = 1.0f/fDLength; + Vector3 kDiff = rkOrigin - rkCapsule.point(0); + Vector3 kP(kU.dot(kDiff),kV.dot(kDiff),kW.dot(kDiff)); + float fRadiusSqr = square(rkCapsule.radius()); + + float fInv, fA, fB, fC, fDiscr, fRoot, fT, fTmp; + + // Is the velocity parallel to the capsule direction? (or zero) + if ((abs(kD.z) >= 1.0f - fEpsilon) || (fDLength < fEpsilon)) { + + float fAxisDir = rkDirection.dot(capsuleDirection); + + fDiscr = fRadiusSqr - kP.x*kP.x - kP.y*kP.y; + if ((fAxisDir < 0) && (fDiscr >= 0.0f)) { + // Velocity anti-parallel to the capsule direction + fRoot = sqrt(fDiscr); + afT[0] = (kP.z + fRoot)*fInvDLength; + afT[1] = -(fWLength - kP.z + fRoot)*fInvDLength; + return 2; + } else if ((fAxisDir > 0) && (fDiscr >= 0.0f)) { + // Velocity parallel to the capsule direction + fRoot = sqrt(fDiscr); + afT[0] = -(kP.z + fRoot)*fInvDLength; + afT[1] = (fWLength - kP.z + fRoot)*fInvDLength; + return 2; + } else { + // sphere heading wrong direction, or no velocity at all + return 0; + } + } + + // test intersection with infinite cylinder + fA = kD.x*kD.x + kD.y*kD.y; + fB = kP.x*kD.x + kP.y*kD.y; + fC = kP.x*kP.x + kP.y*kP.y - fRadiusSqr; + fDiscr = fB*fB - fA*fC; + if (fDiscr < 0.0f) { + // line does not intersect infinite cylinder + return 0; + } + + int iQuantity = 0; + + if (fDiscr > 0.0f) { + // line intersects infinite cylinder in two places + fRoot = sqrt(fDiscr); + fInv = 1.0f/fA; + fT = (-fB - fRoot)*fInv; + fTmp = kP.z + fT*kD.z; + if ((0.0f <= fTmp) && (fTmp <= fWLength)) { + afT[iQuantity] = fT * fInvDLength; + iQuantity++; + } + + fT = (-fB + fRoot)*fInv; + fTmp = kP.z + fT*kD.z; + + if ((0.0f <= fTmp) && (fTmp <= fWLength)) { + afT[iQuantity++] = fT*fInvDLength; + } + + if (iQuantity == 2) { + // line intersects capsule wall in two places + return 2; + } + } else { + // line is tangent to infinite cylinder + fT = -fB/fA; + fTmp = kP.z + fT*kD.z; + if ((0.0f <= fTmp) && (fTmp <= fWLength)) { + afT[0] = fT*fInvDLength; + return 1; + } + } + + // test intersection with bottom hemisphere + // fA = 1 + fB += kP.z*kD.z; + fC += kP.z*kP.z; + fDiscr = fB*fB - fC; + if (fDiscr > 0.0f) { + fRoot = sqrt(fDiscr); + fT = -fB - fRoot; + fTmp = kP.z + fT*kD.z; + if (fTmp <= 0.0f) { + afT[iQuantity++] = fT*fInvDLength; + if (iQuantity == 2) { + return 2; + } + } + + fT = -fB + fRoot; + fTmp = kP.z + fT*kD.z; + if (fTmp <= 0.0f) { + afT[iQuantity++] = fT*fInvDLength; + if (iQuantity == 2) { + return 2; + } + } + } else if (fDiscr == 0.0f) { + fT = -fB; + fTmp = kP.z + fT*kD.z; + if (fTmp <= 0.0f) { + afT[iQuantity++] = fT*fInvDLength; + if (iQuantity == 2) { + return 2; + } + } + } + + // test intersection with top hemisphere + // fA = 1 + fB -= kD.z*fWLength; + fC += fWLength*(fWLength - 2.0f*kP.z); + + fDiscr = fB*fB - fC; + if (fDiscr > 0.0f) { + fRoot = sqrt(fDiscr); + fT = -fB - fRoot; + fTmp = kP.z + fT*kD.z; + if (fTmp >= fWLength) { + afT[iQuantity++] = fT*fInvDLength; + if (iQuantity == 2) { + return 2; + } + } + + fT = -fB + fRoot; + fTmp = kP.z + fT*kD.z; + if (fTmp >= fWLength) { + afT[iQuantity++] = fT*fInvDLength; + if (iQuantity == 2) { + return 2; + } + } + } else if (fDiscr == 0.0f) { + fT = -fB; + fTmp = kP.z + fT*kD.z; + if (fTmp >= fWLength) { + afT[iQuantity++] = fT*fInvDLength; + if (iQuantity == 2) { + return 2; + } + } + } + + return iQuantity; +} + + +/** Used by collisionTimeForMovingPointFixedCapsule. + @cite From magic software http://www.magic-software.com/Source/Intersection3D/MgcIntr3DLinCap.cpp + + @param rkRay The ray + @param rkCapsule The capsule + @param riQuantity The number of intersections found + @param akPoint The intersections found + @return True if there is at least one intersection + */ +static bool findRayCapsuleIntersection( + const Ray& rkRay, + const Capsule& rkCapsule, + int& riQuantity, + Vector3 akPoint[2]) { + + double afT[2]; + riQuantity = findRayCapsuleIntersectionAux(rkRay.origin(), rkRay.direction(), rkCapsule, afT); + + // Only return intersections that occur in the future + int iClipQuantity = 0; + int i; + for (i = 0; i < riQuantity; ++i) { + if (afT[i] >= 0.0f) { + akPoint[iClipQuantity] = rkRay.origin() + afT[i] * rkRay.direction(); + ++iClipQuantity; + } + } + + riQuantity = iClipQuantity; + return (riQuantity > 0); +} + +float CollisionDetection::collisionTimeForMovingPointFixedCapsule( + const Vector3& _point, + const Vector3& velocity, + const Capsule& capsule, + Vector3& location, + Vector3& outNormal) { + + float timeScale = velocity.magnitude(); + + if (timeScale == 0.0f) { + timeScale = 1; + } + + Vector3 direction = velocity / timeScale; + int numIntersections; + Vector3 intersection[2]; + findRayCapsuleIntersection(Ray::fromOriginAndDirection(_point, direction), capsule, numIntersections, intersection); + + if (numIntersections == 2) { + // A collision can only occur if there are two intersections. If there is one + // intersection, that one is exiting the capsule. + + // Find the entering intersection (the first one that occurs). + float d0 = (intersection[0] - _point).squaredMagnitude(); + float d1 = (intersection[1] - _point).squaredMagnitude(); + + // Compute the surface normal (if we aren't ignoring the result) + if (&outNormal != &ignore) { + Vector3 p2 = LineSegment::fromTwoPoints(capsule.point(0), capsule.point(1)).closestPoint(_point); + outNormal = (_point - p2).direction(); + } + + if (d0 > d1) { + location = intersection[1]; + return sqrt(d1) / timeScale; + } else { + location = intersection[0]; + return sqrt(d0) / timeScale; + } + } else { + // No entering intersection discovered; return no intersection. + location = Vector3::inf(); + return finf(); + } +} + + +float CollisionDetection::collisionTimeForMovingSphereFixedPlane( + const Sphere& sphere, + const Vector3& velocity, + const Plane& plane, + Vector3& location, + Vector3& outNormal) { + + if (sphere.radius == 0) { + // Optimization for zero radius sphere + return collisionTimeForMovingPointFixedPlane(sphere.center, velocity, plane, location, outNormal); + } + + // The collision point on the sphere will be the point at + // center - (radius * normal). Collisions only occur when + // the sphere is travelling into the plane. + + double d; + plane.getEquation(outNormal, d); + + double vdotN = velocity.dot(outNormal); + + if (fuzzyGt(vdotN, 0)) { + // No collision when the sphere is moving towards a backface. + location = Vector3::inf(); + return (float)finf(); + } + + float cdotN = sphere.center.dot(outNormal); + + // Distance from the center to the plane + float distance = cdotN + (float)d; + + // Where is the collision on the sphere? + Vector3 point = sphere.center - (sphere.radius * outNormal); + + if (fuzzyLe(G3D::abs(distance), sphere.radius)) { + // Already interpenetrating + location = sphere.center - distance * outNormal; + return 0; + } else { + return collisionTimeForMovingPointFixedPlane(point, velocity, plane, location, outNormal); + } + +} + + +float CollisionDetection::collisionTimeForMovingSphereFixedTriangle( + const class Sphere& sphere, + const Vector3& velocity, + const Triangle& triangle, + Vector3& outLocation, + float b[3]) { + + Vector3 dummy; + float time = collisionTimeForMovingSphereFixedPlane(sphere, velocity, triangle.plane(), + outLocation, dummy); + + if (time == finf()) { + // No collision is ever going to happen + return time; + } + + // We will hit the plane of the triangle at *time*. See if + // the intersection point actually is within the triangle. + + if (isPointInsideTriangle(triangle.vertex(0), triangle.vertex(1), triangle.vertex(2), triangle.normal(), + outLocation, b, triangle.primaryAxis())) { + + // The intersection point is inside the triangle; that is the location where + // the sphere hits the triangle. + +# ifdef G3D_DEBUG + { + // Internal consistency checks + debugAssertM(b[0] >= 0.0 && b[0] <= 1.0f, "Intersection is outside triangle."); + debugAssertM(b[1] >= 0.0 && b[1] <= 1.0f, "Intersection is outside triangle."); + debugAssertM(b[2] >= 0.0 && b[2] <= 1.0f, "Intersection is outside triangle."); + Vector3 blend = + b[0] * triangle.vertex(0) + + b[1] * triangle.vertex(1) + + b[2] * triangle.vertex(2); + debugAssertM(blend.fuzzyEq(outLocation), "Barycentric coords don't match intersection."); + // Call again so that we can debug the problem + // isPointInsideTriangle(triangle.vertex(0), triangle.vertex(1), triangle.vertex(2), triangle.normal(), + // outLocation, b, triangle.primaryAxis()); + } +# endif + + return time; + } + + // The collision (if it exists) is with a point on the triangle perimeter. + // Switch over to moving the triangle towards a fixed sphere and see at what time + // they will hit. + + // Closest point on the triangle to the sphere intersection with the plane. + int edgeIndex; + const Vector3& point = closestPointOnTrianglePerimeter(triangle._vertex, triangle.edgeDirection, + triangle.edgeMagnitude, outLocation, edgeIndex); + + float t = 0; + if (! sphere.contains(point)) { + // The point is outside the sphere--see when it will hit + t = collisionTimeForMovingPointFixedSphere(point, -velocity, sphere, dummy, dummy); + } + + if (t < finf()) { + outLocation = point; + // Compute Barycentric coords + + // Index of the next vertex + static const int next[] = {1, 2, 0}; + + // Project along the edge in question. + // Avoid sqrt by taking advantage of the existing edgeDirection unit vector. + b[next[edgeIndex]] = (outLocation - triangle._vertex[edgeIndex]).dot + (triangle.edgeDirection[edgeIndex]) / triangle.edgeMagnitude[edgeIndex]; + + b[edgeIndex] = 1.0f - b[next[edgeIndex]]; + + b[next[next[edgeIndex]]] = 0.0f; + +# ifdef G3D_DEBUG + { + // Internal consistency checks + for (int i = 0; i < 3; ++i) { + debugAssertM(fuzzyGe(b[i], 0.0f) && fuzzyLe(b[i], 1.0f), "Intersection is outside triangle."); + } + Vector3 blend = + b[0] * triangle.vertex(0) + + b[1] * triangle.vertex(1) + + b[2] * triangle.vertex(2); + debugAssertM(blend.fuzzyEq(outLocation), + format("Barycentric coords don't match intersection. %s != %s", + blend.toString().c_str(), + outLocation.toString().c_str())); + + // Call again so that we can debug the problem + collisionTimeForMovingPointFixedSphere(point, -velocity, sphere, dummy, dummy); + } +# endif + + // Due to tiny roundoffs, these values might be slightly out of bounds. + // Ensure that they are legal. Note that the above debugging code + // verifies that we are not clamping truly illegal values. + for (int i = 0; i < 3; ++i) { + b[i] = clamp(b[i], 0.0f, 1.0f); + } + } + + // The collision occured at the point, if it occured. The normal + // was the plane normal, computed above. + + return t; +} + + +float CollisionDetection::collisionTimeForMovingSphereFixedRectangle( + const Sphere& sphere, + const Vector3& velocity, + const Vector3& v0, + const Vector3& v1, + const Vector3& v2, + const Vector3& v3, + Vector3& location, + Vector3& outNormal) { + + Plane plane(v0, v1, v2); + + float time = collisionTimeForMovingSphereFixedPlane(sphere, velocity, plane, location, outNormal); + + if (time == finf()) { + // No collision is ever going to happen + return time; + } + + if (isPointInsideRectangle(v0, v1, v2, v3, plane.normal(), location)) { + // The intersection point is inside the rectangle; that is the location where + // the sphere hits the rectangle. + return time; + } + + // Switch over to moving the rectangle towards a fixed sphere and see at what time + // they will hit. + + Vector3 point = closestPointToRectanglePerimeter(v0, v1, v2, v3, sphere.center); + + Vector3 dummy; + double t = collisionTimeForMovingPointFixedSphere(point, -velocity, sphere, location, dummy); + + // Normal is the plane normal, location is the original location of the point. + location = point; + + return t; +} + + +float CollisionDetection::collisionTimeForMovingSphereFixedBox( + const Sphere& sphere, + const Vector3& velocity, + const Box& box, + Vector3& location, + Vector3& outNormal) { + + if (fixedSolidSphereIntersectsFixedSolidBox(sphere, box)) { + // TODO: Compute more useful location and normal? + location = sphere.center; + outNormal = Vector3::zero(); + return 0; + } + + float bestTime; + + Vector3 v[4]; + int f = 0; + box.getFaceCorners(f, v[0], v[1], v[2], v[3]); + bestTime = collisionTimeForMovingSphereFixedRectangle(sphere, velocity, v[0], v[1], v[2], v[3], location, outNormal); + + for (f = 1; f < 6; ++f) { + Vector3 pos, normal; + box.getFaceCorners(f, v[0], v[1], v[2], v[3]); + float time = collisionTimeForMovingSphereFixedRectangle(sphere, velocity, v[0], v[1], v[2], v[3], pos, normal); + if (time < bestTime) { + bestTime = time; + location = pos; + outNormal = normal; + } + } + + return bestTime; +} + + +float CollisionDetection::collisionTimeForMovingSphereFixedCapsule( + const Sphere& sphere, + const Vector3& velocity, + const Capsule& capsule, + Vector3& location, + Vector3& outNormal) { + + (void)outNormal; + + Capsule _capsule(capsule.point(0), capsule.point(1), capsule.radius() + sphere.radius); + + Vector3 normal; + double time = collisionTimeForMovingPointFixedCapsule(sphere.center, velocity, _capsule, location, normal); + + if (time < finf()) { + // Location is now the position of the center of the sphere at the time of collision. + // We have to adjust the collision location for the size of the sphere. + location -= sphere.radius * normal; + } + + return time; +} + + +Vector3 CollisionDetection::bounceDirection( + const Sphere& sphere, + const Vector3& velocity, + const float collisionTime, + const Vector3& collisionLocation, + const Vector3& collisionNormal) { + + // Location when the collision occurs + Vector3 sphereLocation = sphere.center + velocity * collisionTime; + + Vector3 normal = (sphereLocation - collisionLocation); + if (fuzzyEq(normal.squaredMagnitude(), 0)) { + normal = collisionNormal; + } else { + normal.unitize(); + } + + Vector3 direction = velocity.direction(); + + // Reflect direction about the normal + return direction - 2.0 * normal * normal.dot(direction); +} + + +Vector3 CollisionDetection::slideDirection( + const Sphere& sphere, + const Vector3& velocity, + const float collisionTime, + const Vector3& collisionLocation) { + + Vector3 sphereLocation = sphere.center + velocity * collisionTime; + Vector3 normal = (sphereLocation - collisionLocation).direction(); + Vector3 direction = velocity.direction(); + + // subtract off the part in the direction away from the normal. + return direction - normal * normal.dot(direction); +} + + +Vector3 CollisionDetection::closestPointOnLineSegment( + const Vector3& v0, + const Vector3& v1, + const Vector3& point) { + + const Vector3& edge = (v1 - v0); + float edgeLength = edge.magnitude(); + + if (edgeLength == 0) { + // The line segment is a point + return v0; + } + + return closestPointOnLineSegment(v0, v1, edge / edgeLength, edgeLength, point); +} + + +Vector3 CollisionDetection::closestPointOnLineSegment( + const Vector3& v0, + const Vector3& v1, + const Vector3& edgeDirection, + const float edgeLength, + const Vector3& point) { + + debugAssert((v1 - v0).direction().fuzzyEq(edgeDirection)); + debugAssert(fuzzyEq((v1 - v0).magnitude(), edgeLength)); + + // Vector towards the point + const Vector3& c = point - v0; + + // Projected onto the edge itself + float t = edgeDirection.dot(c); + + if (t <= 0) { + // Before the start + return v0; + } else if (t >= edgeLength) { + // After the end + return v1; + } else { + // At distance t along the edge + return v0 + edgeDirection * t; + } +} + + +Vector3 CollisionDetection::closestPointOnTrianglePerimeter( + const Vector3& v0, + const Vector3& v1, + const Vector3& v2, + const Vector3& point) { + + Vector3 v[3] = {v0, v1, v2}; + Vector3 edgeDirection[3] = {(v1 - v0), (v2 - v1), (v0 - v2)}; + float edgeLength[3]; + + for (int i = 0; i < 3; ++i) { + edgeLength[i] = edgeDirection[i].magnitude(); + edgeDirection[i] /= edgeLength[i]; + } + + int edgeIndex; + return closestPointOnTrianglePerimeter(v, edgeDirection, edgeLength, point, edgeIndex); +} + + +Vector3 CollisionDetection::closestPointOnTrianglePerimeter( + const Vector3 v[3], + const Vector3 edgeDirection[3], + const float edgeLength[3], + const Vector3& point, + int& edgeIndex) { + + // Closest point on segment from v[i] to v[i + 1] + Vector3 r[3]; + + // Distance squared from r[i] to point + float d[3]; + + // Index of the next point + static const int next[] = {1, 2, 0}; + + for (int i = 0; i < 3; ++i) { + r[i] = closestPointOnLineSegment(v[i], v[next[i]], edgeDirection[i], edgeLength[i], point); + d[i] = (r[i] - point).squaredMagnitude(); + } + + if (d[0] < d[1]) { + if (d[0] < d[2]) { + // Between v0 and v1 + edgeIndex = 0; + } else { + // Between v2 and v0 + edgeIndex = 2; + } + } else { + if (d[1] < d[2]) { + // Between v1 and v2 + edgeIndex = 1; + } else { + // Between v2 and v0 + edgeIndex = 2; + } + } + +# ifdef G3D_DEBUG + { + Vector3 diff = r[edgeIndex] - v[edgeIndex]; + debugAssertM(fuzzyEq(diff.direction().dot(edgeDirection[edgeIndex]), 1.0f) || + diff.fuzzyEq(Vector3::zero()), "Point not on correct triangle edge"); + float frac = diff.dot(edgeDirection[edgeIndex])/edgeLength[edgeIndex]; + debugAssertM(frac >= -0.000001, "Point off low side of edge."); + debugAssertM(frac <= 1.000001, "Point off high side of edge."); + } +# endif + + return r[edgeIndex]; +} + + +bool CollisionDetection::isPointInsideTriangle( + const Vector3& v0, + const Vector3& v1, + const Vector3& v2, + const Vector3& normal, + const Vector3& point, + float b[3], + Vector3::Axis primaryAxis) { + + if (primaryAxis == Vector3::DETECT_AXIS) { + primaryAxis = normal.primaryAxis(); + } + + // Check that the point is within the triangle using a Barycentric + // coordinate test on a two dimensional plane. + int i, j; + + switch (primaryAxis) { + case Vector3::X_AXIS: + i = Vector3::Y_AXIS; + j = Vector3::Z_AXIS; + break; + + case Vector3::Y_AXIS: + i = Vector3::Z_AXIS; + j = Vector3::X_AXIS; + break; + + case Vector3::Z_AXIS: + i = Vector3::X_AXIS; + j = Vector3::Y_AXIS; + break; + + default: + // This case is here to supress a warning on Linux + i = j = 0; + debugAssertM(false, "Should not get here."); + break; + } + + // See if all barycentric coordinates are non-negative + + // 2D area via cross product +# define AREA2(d, e, f) (((e)[i] - (d)[i]) * ((f)[j] - (d)[j]) - ((f)[i] - (d)[i]) * ((e)[j] - (d)[j])) + + // Area of the polygon + float area = AREA2(v0, v1, v2); + if (area == 0) { + // This triangle has zero area, so the point must not + // be in it unless the triangle point is the test point. + return (v0 == point); + } + + debugAssert(area != 0); + + float invArea = 1.0f / area; + + // (avoid normalization until absolutely necessary) + b[0] = AREA2(point, v1, v2) * invArea; + + if ((b[0] < 0.0f) || (b[0] > 1.0f)) { + return false; + } + + b[1] = AREA2(v0, point, v2) * invArea; + if ((b[1] < 0.0f) || (b[1] > 1.0f)) { + return false; + } + + b[2] = 1.0f - b[0] - b[1]; + +# undef AREA2 + + return (b[2] >= 0.0f) && (b[2] <= 1.0f); +} + + +bool CollisionDetection::isPointInsideRectangle( + const Vector3& v0, + const Vector3& v1, + const Vector3& v2, + const Vector3& v3, + const Vector3& normal, + const Vector3& point) { + + return isPointInsideTriangle(v0, v1, v2, normal, point) || + isPointInsideTriangle(v2, v3, v0, normal, point); +} + + +Vector3 CollisionDetection::closestPointToRectanglePerimeter( + const Vector3& v0, + const Vector3& v1, + const Vector3& v2, + const Vector3& v3, + const Vector3& point) { + + Vector3 r0 = closestPointOnLineSegment(v0, v1, point); + Vector3 r1 = closestPointOnLineSegment(v1, v2, point); + Vector3 r2 = closestPointOnLineSegment(v2, v3, point); + Vector3 r3 = closestPointOnLineSegment(v3, v0, point); + + double d0 = (r0 - point).squaredMagnitude(); + double d1 = (r1 - point).squaredMagnitude(); + double d2 = (r2 - point).squaredMagnitude(); + double d3 = (r3 - point).squaredMagnitude(); + + if (d0 < d1) { + if (d0 < d2) { + if (d0 < d3) { + return r0; + } else { + return r3; + } + } else { + if (d2 < d3) { + return r2; + } else { + return r3; + } + } + } else { + if (d1 < d2) { + if (d1 < d3) { + return r1; + } else { + return r3; + } + } else { + if (d2 < d3) { + return r2; + } else { + return r3; + } + } + } +} + + +Vector3 CollisionDetection::closestPointToRectangle( + const Vector3& v0, + const Vector3& v1, + const Vector3& v2, + const Vector3& v3, + const Vector3& point) { + + Plane plane(v0, v1, v2); + + // Project the point into the plane + double a, b, c, d; + plane.getEquation(a, b, c, d); + + double distance = a*point.x + b*point.y + c*point.z + d; + Vector3 planePoint = point - distance * plane.normal(); + + if (isPointInsideRectangle(v0, v1, v2, v3, plane.normal(), planePoint)) { + return planePoint; + } else { + return closestPointToRectanglePerimeter(v0, v1, v2, v3, planePoint); + } +} + + +bool CollisionDetection::fixedSolidSphereIntersectsFixedSolidSphere( + const Sphere& sphere1, + const Sphere& sphere2) { + + return (sphere1.center - sphere2.center).squaredMagnitude() < square(sphere1.radius + sphere2.radius); +} + + +bool CollisionDetection::fixedSolidSphereIntersectsFixedSolidBox( + const Sphere& sphere, + const Box& box) { + + // If the center of the sphere is within the box, the whole + // sphere is within the box. + if (box.contains(sphere.center)) { + return true; + } + + float r2 = square(sphere.radius); + + // Find the closest point on the surface of the box to the sphere. If + // this point is within the sphere's radius, they intersect. + int f; + for (f = 0; f < 6; ++f) { + Vector3 v0, v1, v2, v3; + box.getFaceCorners(f, v0, v1, v2, v3); + if ((closestPointToRectangle(v0, v1, v2, v3, sphere.center) - sphere.center).squaredMagnitude() <= r2) { + return true; + } + } + + return false; +} + + +bool CollisionDetection::movingSpherePassesThroughFixedBox( + const Sphere& sphere, + const Vector3& velocity, + const Box& box, + double timeLimit) { + + // If they intersect originally, they definitely pass through each other. + if (fixedSolidSphereIntersectsFixedSolidBox(sphere, box)) { + return true; + } + + // See if the sphere hits the box during the time period. + Vector3 dummy1, dummy2; + + return (collisionTimeForMovingSphereFixedBox(sphere, velocity, box, dummy1, dummy2) < timeLimit); +} + + +bool CollisionDetection::movingSpherePassesThroughFixedSphere( + const Sphere& sphere, + const Vector3& velocity, + const Sphere& fixedSphere, + double timeLimit) { + + if (fixedSolidSphereIntersectsFixedSolidSphere(sphere, fixedSphere)) { + return true; + } + + // Extend the fixed sphere by the radius of the moving sphere + Sphere bigFixed(fixedSphere.center, fixedSphere.radius + sphere.radius); + Vector3 dummy1, dummy2; + + // If the sphere collides with the other sphere during the time limit, it passes through + return (collisionTimeForMovingPointFixedSphere(sphere.center, velocity, bigFixed, dummy1, dummy2) < timeLimit); +} + + + +bool CollisionDetection::fixedSolidSphereIntersectsFixedTriangle( + const Sphere& sphere, + const Triangle& triangle) { + + // How far is the sphere from the plane of the triangle + const Plane& plane = triangle.plane(); + + // Does the closest point to the sphere center lie within the triangle? + Vector3 v = plane.closestPoint(sphere.center); + + // Is the closest point to the plane within the sphere? + if ((v - sphere.center).squaredLength() <= square(sphere.radius)) { + // Is it also within the triangle? + float b[3]; + if (isPointInsideTriangle(triangle.vertex(0), triangle.vertex(1), triangle.vertex(2), triangle.normal(), + v, b, triangle.primaryAxis())){ + // The closest point is inside the triangle + return true; + } + } + + // ignored + int edgeIndex; + + v = closestPointOnTrianglePerimeter(triangle._vertex, triangle.edgeDirection, triangle.edgeMagnitude, sphere.center, edgeIndex); + + // Is the closest point within the sphere? + return ((v - sphere.center).squaredLength() <= square(sphere.radius)); +} + + +//////////////////////////////////////////////////////////////////////////////// +// AABB-triangle overlap test code based on Tomas Akenine-Möller's +// http://www.cs.lth.se/home/Tomas_Akenine_Moller/code/tribox3.txt +// Ported 2008-12-28 + +#define X 0 +#define Y 1 +#define Z 2 + +#define FINDMINMAX(x0, x1, x2, min, max) \ + min = max = x0; \ + if(x1<min) min=x1;\ + if(x1>max) max=x1;\ + if(x2<min) min=x2;\ + if(x2>max) max=x2; + +static bool planeBoxOverlap(const Vector3& normal, const Vector3& vert, const Vector3& maxbox) { + Vector3 vmin, vmax; + float v; + + // for each axis + for(int a = 0; a < 3; ++a) { + v = vert[a]; + + if (normal[a] > 0.0f) { + vmin[a] = -maxbox[a] - v; + vmax[a] = maxbox[a] - v; + } else { + vmin[a] = maxbox[a] - v; + vmax[a] = -maxbox[a] - v; + } + } + + if (normal.dot(vmin) > 0.0f) { + return false; + } else if (normal.dot(vmax) >= 0.0f) { + return true; + } else { + return false; + } +} + +/*======================== X-tests ========================*/ + +#define AXISTEST_X01(a, b, fa, fb) \ + p0 = a*v0[Y] - b*v0[Z]; \ + p2 = a*v2[Y] - b*v2[Z]; \ + if(p0<p2) {min=p0; max=p2;} else {min=p2; max=p0;} \ + rad = fa * boxhalfsize[Y] + fb * boxhalfsize[Z]; \ + if(min>rad || max<-rad) return false; + + +#define AXISTEST_X2(a, b, fa, fb) \ + p0 = a*v0[Y] - b*v0[Z]; \ + p1 = a*v1[Y] - b*v1[Z]; \ + if(p0<p1) {min=p0; max=p1;} else {min=p1; max=p0;} \ + rad = fa * boxhalfsize[Y] + fb * boxhalfsize[Z]; \ + if(min>rad || max<-rad) return false; + +/*======================== Y-tests ========================*/ + +#define AXISTEST_Y02(a, b, fa, fb) \ + p0 = -a*v0[X] + b*v0[Z]; \ + p2 = -a*v2[X] + b*v2[Z]; \ + if(p0<p2) {min=p0; max=p2;} else {min=p2; max=p0;} \ + rad = fa * boxhalfsize[X] + fb * boxhalfsize[Z]; \ + if(min>rad || max<-rad) return false; + +#define AXISTEST_Y1(a, b, fa, fb) \ + p0 = -a*v0[X] + b*v0[Z]; \ + p1 = -a*v1[X] + b*v1[Z]; \ + if(p0<p1) {min=p0; max=p1;} else {min=p1; max=p0;} \ + rad = fa * boxhalfsize[X] + fb * boxhalfsize[Z]; \ + if(min>rad || max<-rad) return false; + +/*======================== Z-tests ========================*/ + +#define AXISTEST_Z12(a, b, fa, fb) \ + p1 = a*v1[X] - b*v1[Y]; \ + p2 = a*v2[X] - b*v2[Y]; \ + if(p2<p1) {min=p2; max=p1;} else {min=p1; max=p2;} \ + rad = fa * boxhalfsize[X] + fb * boxhalfsize[Y]; \ + if(min>rad || max<-rad) return false; + +#define AXISTEST_Z0(a, b, fa, fb) \ + p0 = a*v0[X] - b*v0[Y]; \ + p1 = a*v1[X] - b*v1[Y]; \ + if(p0<p1) {min=p0; max=p1;} else {min=p1; max=p0;} \ + rad = fa * boxhalfsize[X] + fb * boxhalfsize[Y]; \ + if(min>rad || max<-rad) return false; + +bool CollisionDetection::fixedSolidBoxIntersectsFixedTriangle( + const AABox& box, const Triangle& tri) { + + // use separating axis theorem to test overlap between triangle and box + // need to test for overlap in these directions: + // 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle + // we do not even need to test these) + // 2) normal of the triangle + // 3) crossproduct(edge from tri, {x,y,z}-direction) + // this gives 3x3=9 more tests + + // This is the fastest branch (on Sun). + // Move the triangle to the object space of the box + // Triangle vertices in box object space + + const Vector3& boxcenter = box.center(); + const Vector3& boxhalfsize = box.extent() * 0.5f; + + const Vector3& v0 = tri.vertex(0) - boxcenter; + const Vector3& v1 = tri.vertex(1) - boxcenter; + const Vector3& v2 = tri.vertex(2) - boxcenter; + + // Compute triangle edges in object space + const Vector3& e0 = v1 - v0; + const Vector3& e1 = v2 - v1; + const Vector3& e2 = v0 - v2; + + // Bullet 3: + // test the 9 tests first (this was faster) + float min,max,p0,p1,p2,rad; + Vector3 fe; + + fe = abs(e0); + AXISTEST_X01(e0[Z], e0[Y], fe[Z], fe[Y]); + AXISTEST_Y02(e0[Z], e0[X], fe[Z], fe[X]); + AXISTEST_Z12(e0[Y], e0[X], fe[Y], fe[X]); + + fe = abs(e1); + AXISTEST_X01(e1[Z], e1[Y], fe[Z], fe[Y]); + AXISTEST_Y02(e1[Z], e1[X], fe[Z], fe[X]); + AXISTEST_Z0 (e1[Y], e1[X], fe[Y], fe[X]); + + fe = abs(e2); + AXISTEST_X2 (e2[Z], e2[Y], fe[Z], fe[Y]); + AXISTEST_Y1 (e2[Z], e2[X], fe[Z], fe[X]); + AXISTEST_Z12(e2[Y], e2[X], fe[Y], fe[X]); + + // Bullet 1: + // first test overlap in the {x,y,z}-directions + // find min, max of the triangle each direction, and test for overlap in + // that direction -- this is equivalent to testing a minimal AABB around + // the triangle against the AABB + + // test in X-direction + FINDMINMAX(v0[X],v1[X],v2[X],min,max); + if (min > boxhalfsize[X] || max < -boxhalfsize[X]) { + return false; + } + + // test in Y-direction + FINDMINMAX(v0[Y],v1[Y],v2[Y],min,max); + if (min > boxhalfsize[Y] || max < -boxhalfsize[Y]) { + return false; + } + + // test in Z-direction + FINDMINMAX(v0[Z],v1[Z],v2[Z],min,max); + if (min > boxhalfsize[Z] || max < -boxhalfsize[Z]) { + return false; + } + + // Bullet 2: + // test if the box intersects the plane of the triangle + // compute plane equation of triangle: normal*x+d=0 + + if (! planeBoxOverlap(tri.normal(), v0, boxhalfsize)) { + return false; + } + + // box and triangle overlap + return true; +} +#undef X +#undef Y +#undef Z + +//////////////////////////////////////////////////////////////////////////////// + + +} // namespace + +#ifdef _MSC_VER +// Turn off fast floating-point optimizations +#pragma float_control( pop ) +#pragma warning (pop) +#endif diff --git a/dep/src/g3dlite/Color1.cpp b/dep/src/g3dlite/Color1.cpp new file mode 100644 index 00000000000..04f3f9412b1 --- /dev/null +++ b/dep/src/g3dlite/Color1.cpp @@ -0,0 +1,58 @@ +/** + @file Color1.cpp + + Color class. + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-30 + @edited 2009-03-27 + */ + +#include "G3D/platform.h" +#include "G3D/Color1.h" +#include "G3D/Color1uint8.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Color3.h" + +namespace G3D { + +const Color1& Color1::one() { + static const Color1 x(1.0f); + return x; +} + + +const Color1& Color1::zero() { + const static Color1 x(0.0f); + return x; +} + + +Color1::Color1(BinaryInput& bi) { + deserialize(bi); +} + + +Color3 Color1::rgb() const { + return Color3(value, value, value); +} + + +void Color1::deserialize(BinaryInput& bi) { + value = bi.readFloat32(); +} + + +void Color1::serialize(BinaryOutput& bo) const { + bo.writeFloat32(value); +} + + +Color1::Color1(const class Color1uint8& other) { + value = other.value / 255.0f; +} + +} // namespace G3D + diff --git a/dep/src/g3dlite/Color1uint8.cpp b/dep/src/g3dlite/Color1uint8.cpp new file mode 100644 index 00000000000..21cd564ba92 --- /dev/null +++ b/dep/src/g3dlite/Color1uint8.cpp @@ -0,0 +1,38 @@ +/** + @file Color1uint8.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-30 + @edited 2007-01-30 + */ + +#include "G3D/platform.h" +#include "G3D/g3dmath.h" +#include "G3D/Color1uint8.h" +#include "G3D/Color1.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +Color1uint8::Color1uint8(const class Color1& c) : value(iClamp(iFloor(c.value * 256), 0, 255)) { +} + + +Color1uint8::Color1uint8(class BinaryInput& bi) { + deserialize(bi); +} + + +void Color1uint8::serialize(class BinaryOutput& bo) const { + bo.writeUInt8(value); +} + + +void Color1uint8::deserialize(class BinaryInput& bi) { + value = bi.readUInt8(); +} + + +} diff --git a/dep/src/g3dlite/Color3.cpp b/dep/src/g3dlite/Color3.cpp new file mode 100644 index 00000000000..deb0bd87ee7 --- /dev/null +++ b/dep/src/g3dlite/Color3.cpp @@ -0,0 +1,384 @@ +/** + @file Color3.cpp + + Color class. + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2001-06-02 + @edited 2010-01-28 + */ + +#include "G3D/platform.h" +#include <stdlib.h> +#include "G3D/Color3.h" +#include "G3D/Vector3.h" +#include "G3D/format.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Color3uint8.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +Color3::Color3(const Any& any) { + *this = Color3::zero(); + any.verifyName("Color3"); + std::string name = toLower(any.name()); + + switch (any.type()) { + case Any::TABLE: + + for (Any::AnyTable::Iterator it = any.table().begin(); it.hasMore(); ++it) { + const std::string& key = toLower(it->key); + if (key == "r") { + r = it->value; + } else if (key == "g") { + g = it->value; + } else if (key == "b") { + b = it->value; + } else { + any.verify(false, "Illegal key: " + it->key); + } + } + break; + + case Any::ARRAY: + if (name == "color3") { + any.verifySize(3); + r = any[0]; + g = any[1]; + b = any[2]; + } else if (name == "color3::one") { + any.verifySize(0); + *this = one(); + } else if (name == "color3::zero") { + any.verifySize(0); + *this = zero(); + } else if (name == "color3::fromargb") { + *this = Color3::fromARGB((int)any[0].number()); + } else { + any.verify(false, "Expected Color3 constructor"); + } + break; + + default: + any.verify(false, "Bad Color3 constructor"); + } +} + + +Color3::operator Any() const { + Any a(Any::ARRAY, "Color3"); + a.append(r, g, b); + return a; +} + + +Color3 Color3::ansiMap(uint32 i) { + static const Color3 map[] = + {Color3::black(), Color3::red() * 0.75f, Color3::green() * 0.75f, Color3::yellow() * 0.75f, + Color3::blue() * 0.75f, Color3::purple() * 0.75f, Color3::cyan() * 0.75f, Color3::white() * 0.75f, + Color3::white() * 0.90f, Color3::red(), Color3::green(), Color3::yellow(), Color3::blue(), + Color3::purple(), Color3::cyan(), Color3::white()}; + + return map[i & 15]; +} + + +Color3 Color3::pastelMap(uint32 i) { + uint32 x = Crypto::crc32(&i, sizeof(uint32)); + // Create fairly bright, saturated colors + Vector3 v(((x >> 22) & 1023) / 1023.0f, + (((x >> 11) & 2047) / 2047.0f) * 0.5f + 0.25f, + ((x & 2047) / 2047.0f) * 0.75f + 0.25f); + return Color3::fromHSV(v); +} + + +const Color3& Color3::red() { + static Color3 c(1.0f, 0.0f, 0.0f); + return c; +} + + +const Color3& Color3::green() { + static Color3 c(0.0f, 1.0f, 0.0f); + return c; +} + + +const Color3& Color3::blue() { + static Color3 c(0.0f, 0.0f, 1.0f); + return c; +} + + +const Color3& Color3::purple() { + static Color3 c(0.7f, 0.0f, 1.0f); + return c; +} + + +const Color3& Color3::cyan() { + static Color3 c(0.0f, 0.7f, 1.0f); + return c; +} + + +const Color3& Color3::yellow() { + static Color3 c(1.0f, 1.0f, 0.0f); + return c; +} + + +const Color3& Color3::brown() { + static Color3 c(0.5f, 0.5f, 0.0f); + return c; +} + + +const Color3& Color3::orange() { + static Color3 c(1.0f, 0.5f, 0.0f); + return c; +} + + +const Color3& Color3::black() { + static Color3 c(0.0f, 0.0f, 0.0f); + return c; +} + +const Color3& Color3::zero() { + static Color3 c(0.0f, 0.0f, 0.0f); + return c; +} + + +const Color3& Color3::one() { + static Color3 c(1.0f, 1.0f, 1.0f); + return c; +} + + +const Color3& Color3::gray() { + static Color3 c(0.7f, 0.7f, 0.7f); + return c; +} + + +const Color3& Color3::white() { + static Color3 c(1, 1, 1); + return c; +} + + +bool Color3::isFinite() const { + return G3D::isFinite(r) && G3D::isFinite(g) && G3D::isFinite(b); +} + + +Color3::Color3(BinaryInput& bi) { + deserialize(bi); +} + + +void Color3::deserialize(BinaryInput& bi) { + r = bi.readFloat32(); + g = bi.readFloat32(); + b = bi.readFloat32(); +} + + +void Color3::serialize(BinaryOutput& bo) const { + bo.writeFloat32(r); + bo.writeFloat32(g); + bo.writeFloat32(b); +} + + +const Color3& Color3::wheelRandom() { + static const Color3 colorArray[8] = + {Color3::blue(), Color3::red(), Color3::green(), + Color3::orange(), Color3::yellow(), + Color3::cyan(), Color3::purple(), Color3::brown()}; + + return colorArray[iRandom(0, 7)]; +} + + +size_t Color3::hashCode() const { + unsigned int rhash = (*(int*)(void*)(&r)); + unsigned int ghash = (*(int*)(void*)(&g)); + unsigned int bhash = (*(int*)(void*)(&b)); + + return rhash + (ghash * 37) + (bhash * 101); +} + + +Color3::Color3(const Vector3& v) { + r = v.x; + g = v.y; + b = v.z; +} + + +Color3::Color3(const class Color3uint8& other) { + r = other.r / 255.0f; + g = other.g / 255.0f; + b = other.b / 255.0f; +} + + +Color3 Color3::fromARGB(uint32 x) { + return Color3((float)((x >> 16) & 0xFF), (float)((x >> 8) & 0xFF), (float)(x & 0xFF)) / 255.0f; +} + +//---------------------------------------------------------------------------- + + +Color3 Color3::random() { + return Color3(uniformRandom(), + uniformRandom(), + uniformRandom()).direction(); +} + +//---------------------------------------------------------------------------- +Color3& Color3::operator/= (float fScalar) { + if (fScalar != 0.0f) { + float fInvScalar = 1.0f / fScalar; + r *= fInvScalar; + g *= fInvScalar; + b *= fInvScalar; + } else { + r = (float)G3D::finf(); + g = (float)G3D::finf(); + b = (float)G3D::finf(); + } + + return *this; +} + +//---------------------------------------------------------------------------- +float Color3::unitize (float fTolerance) { + float fLength = length(); + + if ( fLength > fTolerance ) { + float fInvLength = 1.0f / fLength; + r *= fInvLength; + g *= fInvLength; + b *= fInvLength; + } else { + fLength = 0.0f; + } + + return fLength; +} + +//---------------------------------------------------------------------------- +Color3 Color3::fromHSV(const Vector3& _hsv) { + debugAssertM((_hsv.x <= 1.0f && _hsv.x >= 0.0f) + && (_hsv.y <= 1.0f && _hsv.y >= 0.0f) + && ( _hsv.z <= 1.0f && _hsv.z >= 0.0f), "H,S,V must be between [0,1]"); + const int i = iMin(5, G3D::iFloor(6.0 * _hsv.x)); + const float f = 6.0f * _hsv.x - i; + const float m = _hsv.z * (1.0f - (_hsv.y)); + const float n = _hsv.z * (1.0f - (_hsv.y * f)); + const float k = _hsv.z * (1.0f - (_hsv.y * (1 - f))); + switch(i) { + case 0: + return Color3(_hsv.z, k, m); + + case 1: + return Color3(n, _hsv.z, m); + + case 2: + return Color3(m, _hsv.z, k); + + case 3: + return Color3(m, n, _hsv.z); + + case 4: + return Color3(k, m, _hsv.z); + + case 5: + return Color3(_hsv.z, m, n); + + default: + debugAssertM(false, "fell through switch.."); + } + return Color3::black(); +} + + +Vector3 Color3::toHSV(const Color3& _rgb) { + debugAssertM((_rgb.r <= 1.0f && _rgb.r >= 0.0f) + && (_rgb.g <= 1.0f && _rgb.g >= 0.0f) + && (_rgb.b <= 1.0f && _rgb.b >= 0.0f), "R,G,B must be between [0,1]"); + Vector3 hsv = Vector3::zero(); + hsv.z = G3D::max(G3D::max(_rgb.r, _rgb.g), _rgb.b); + if (G3D::fuzzyEq(hsv.z, 0.0f)) { + return hsv; + } + + const float x = G3D::min(G3D::min(_rgb.r, _rgb.g), _rgb.b); + hsv.y = (hsv.z - x) / hsv.z; + + if (G3D::fuzzyEq(hsv.y, 0.0f)) { + return hsv; + } + + Vector3 rgbN; + rgbN.x = (hsv.z - _rgb.r) / (hsv.z - x); + rgbN.y = (hsv.z - _rgb.g) / (hsv.z - x); + rgbN.z = (hsv.z - _rgb.b) / (hsv.z - x); + + if (_rgb.r == hsv.z) { // note from the max we know that it exactly equals one of the three. + hsv.x = (_rgb.g == x)? 5.0f + rgbN.z : 1.0f - rgbN.y; + } else if (_rgb.g == hsv.z) { + hsv.x = (_rgb.b == x)? 1.0f + rgbN.x : 3.0f - rgbN.z; + } else { + hsv.x = (_rgb.r == x)? 3.0f + rgbN.y : 5.0f - rgbN.x; + } + + hsv.x /= 6.0f; + + return hsv; +} + +Color3 Color3::jetColorMap(const float& val) { + debugAssertM(val <= 1.0f && val >= 0.0f , "value should be in [0,1]"); + + //truncated triangles where sides have slope 4 + Color3 jet; + + jet.r = G3D::min(4.0f * val - 1.5f,-4.0f * val + 4.5f) ; + jet.g = G3D::min(4.0f * val - 0.5f,-4.0f * val + 3.5f) ; + jet.b = G3D::min(4.0f * val + 0.5f,-4.0f * val + 2.5f) ; + + + jet.r = G3D::clamp(jet.r, 0.0f, 1.0f); + jet.g = G3D::clamp(jet.g, 0.0f, 1.0f); + jet.b = G3D::clamp(jet.b, 0.0f, 1.0f); + + return jet; +} + + + + + +std::string Color3::toString() const { + return G3D::format("(%g, %g, %g)", r, g, b); +} + +//---------------------------------------------------------------------------- + +Color3 Color3::rainbowColorMap(float hue) { + return fromHSV(Vector3(hue, 1.0f, 1.0f)); +} + + +}; // namespace + diff --git a/dep/src/g3dlite/Color3uint8.cpp b/dep/src/g3dlite/Color3uint8.cpp new file mode 100644 index 00000000000..a744710c752 --- /dev/null +++ b/dep/src/g3dlite/Color3uint8.cpp @@ -0,0 +1,45 @@ +/** + @file Color3uint8.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-04-07 + @edited 2006-01-07 + */ + +#include "G3D/platform.h" +#include "G3D/g3dmath.h" +#include "G3D/Color3uint8.h" +#include "G3D/Color3.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +Color3uint8::Color3uint8(const class Color3& c) { + r = iMin(255, iFloor(c.r * 256)); + g = iMin(255, iFloor(c.g * 256)); + b = iMin(255, iFloor(c.b * 256)); +} + + +Color3uint8::Color3uint8(class BinaryInput& bi) { + deserialize(bi); +} + + +void Color3uint8::serialize(class BinaryOutput& bo) const { + bo.writeUInt8(r); + bo.writeUInt8(g); + bo.writeUInt8(b); +} + + +void Color3uint8::deserialize(class BinaryInput& bi) { + r = bi.readUInt8(); + g = bi.readUInt8(); + b = bi.readUInt8(); +} + + +} diff --git a/dep/src/g3dlite/Color4.cpp b/dep/src/g3dlite/Color4.cpp new file mode 100644 index 00000000000..eab09eb9c7e --- /dev/null +++ b/dep/src/g3dlite/Color4.cpp @@ -0,0 +1,192 @@ +/** + @file Color4.cpp + + Color class. + + @author Morgan McGuire, http://graphics.cs.williams.edu + @cite Portions by Laura Wollstadt, graphics3d.com + @cite Portions based on Dave Eberly's Magic Software Library at http://www.magic-software.com + + + @created 2002-06-25 + @edited 2009-11-10 + */ + +#include <stdlib.h> +#include "G3D/Color4.h" +#include "G3D/Color4uint8.h" +#include "G3D/Vector4.h" +#include "G3D/format.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +Color4::Color4(const Any& any) { + *this = Color4::zero(); + any.verifyName("Color4"); + + if (any.type() == Any::TABLE) { + for (Any::AnyTable::Iterator it = any.table().begin(); it.hasMore(); ++it) { + const std::string& key = toLower(it->key); + if (key == "r") { + r = it->value; + } else if (key == "g") { + g = it->value; + } else if (key == "b") { + b = it->value; + } else if (key == "a") { + a = it->value; + } else { + any.verify(false, "Illegal key: " + it->key); + } + } + } else if (toLower(any.name()) == "color4") { + r = any[0]; + g = any[1]; + b = any[2]; + a = any[3]; + } else { + any.verifyName("Color4::fromARGB"); + *this = Color4::fromARGB((int)any[0].number()); + } +} + + +Color4::operator Any() const { + Any any(Any::ARRAY, "Color4"); + any.append(r, g, b, a); + return any; +} + + +const Color4& Color4::one() { + const static Color4 x(1.0f, 1.0f, 1.0f, 1.0f); + return x; +} + + +const Color4& Color4::zero() { + static Color4 c(0.0f, 0.0f, 0.0f, 0.0f); + return c; +} + + +const Color4& Color4::inf() { + static Color4 c((float)G3D::finf(), (float)G3D::finf(), (float)G3D::finf(), (float)G3D::finf()); + return c; +} + + +const Color4& Color4::nan() { + static Color4 c((float)G3D::fnan(), (float)G3D::fnan(), (float)G3D::fnan(), (float)G3D::fnan()); + return c; +} + + +const Color4& Color4::clear() { + return Color4::zero(); +} + + +Color4::Color4(const Vector4& v) { + r = v.x; + g = v.y; + b = v.z; + a = v.w; +} + + +Color4::Color4(const Color4uint8& c) : r(c.r), g(c.g), b(c.b), a(c.a) { + *this /= 255.0f; +} + +size_t Color4::hashCode() const { + unsigned int rhash = (*(int*)(void*)(&r)); + unsigned int ghash = (*(int*)(void*)(&g)); + unsigned int bhash = (*(int*)(void*)(&b)); + unsigned int ahash = (*(int*)(void*)(&a)); + + return rhash + (ghash * 37) + (bhash * 101) + (ahash * 241); +} + +Color4 Color4::fromARGB(uint32 x) { + return Color4( + (float)((x >> 16) & 0xFF), + (float)((x >> 8) & 0xFF), + (float)(x & 0xFF), + (float)((x >> 24) & 0xFF)) / 255.0; +} + + +Color4::Color4(BinaryInput& bi) { + deserialize(bi); +} + + +void Color4::deserialize(BinaryInput& bi) { + r = bi.readFloat32(); + g = bi.readFloat32(); + b = bi.readFloat32(); + a = bi.readFloat32(); +} + + +void Color4::serialize(BinaryOutput& bo) const { + bo.writeFloat32(r); + bo.writeFloat32(g); + bo.writeFloat32(b); + bo.writeFloat32(a); +} + + +//---------------------------------------------------------------------------- + +Color4 Color4::operator/ (float fScalar) const { + Color4 kQuot; + + if (fScalar != 0.0f) { + float fInvScalar = 1.0f / fScalar; + kQuot.r = fInvScalar * r; + kQuot.g = fInvScalar * g; + kQuot.b = fInvScalar * b; + kQuot.a = fInvScalar * a; + return kQuot; + + } else { + + return Color4::inf(); + } +} + +//---------------------------------------------------------------------------- + +Color4& Color4::operator/= (float fScalar) { + if (fScalar != 0.0f) { + float fInvScalar = 1.0f / fScalar; + r *= fInvScalar; + g *= fInvScalar; + b *= fInvScalar; + a *= fInvScalar; + } else { + r = (float)G3D::finf(); + g = (float)G3D::finf(); + b = (float)G3D::finf(); + a = (float)G3D::finf(); + } + + return *this; +} + +//---------------------------------------------------------------------------- + +std::string Color4::toString() const { + return G3D::format("(%g, %g, %g, %g)", r, g, b, a); +} + +//---------------------------------------------------------------------------- + +}; // namespace + diff --git a/dep/src/g3dlite/Color4uint8.cpp b/dep/src/g3dlite/Color4uint8.cpp new file mode 100644 index 00000000000..5cc3a578aca --- /dev/null +++ b/dep/src/g3dlite/Color4uint8.cpp @@ -0,0 +1,47 @@ +/** + @file Color4uint8.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-04-07 + @edited 2006-01-07 + */ +#include "G3D/platform.h" +#include "G3D/g3dmath.h" +#include "G3D/Color4uint8.h" +#include "G3D/Color4.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +Color4uint8::Color4uint8(const class Color4& c) { + r = iMin(255, iFloor(c.r * 256)); + g = iMin(255, iFloor(c.g * 256)); + b = iMin(255, iFloor(c.b * 256)); + a = iMin(255, iFloor(c.a * 256)); +} + + +Color4uint8::Color4uint8(class BinaryInput& bi) { + deserialize(bi); +} + + +void Color4uint8::serialize(class BinaryOutput& bo) const { + bo.writeUInt8(r); + bo.writeUInt8(g); + bo.writeUInt8(b); + bo.writeUInt8(a); +} + + +void Color4uint8::deserialize(class BinaryInput& bi) { + r = bi.readUInt8(); + g = bi.readUInt8(); + b = bi.readUInt8(); + a = bi.readUInt8(); +} + + +} diff --git a/dep/src/g3dlite/Cone.cpp b/dep/src/g3dlite/Cone.cpp new file mode 100644 index 00000000000..3104b8424a7 --- /dev/null +++ b/dep/src/g3dlite/Cone.cpp @@ -0,0 +1,79 @@ +/** + @file Cone.cpp + + Cone class + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2001-07-09 + @edited 2006-01-29 +*/ + +#include "G3D/platform.h" +#include "G3D/Cone.h" +#include "G3D/Line.h" +#include "G3D/Sphere.h" +#include "G3D/Box.h" + +namespace G3D { + +Cone::Cone(const Vector3 &tip, const Vector3 &direction, float angle) { + this->tip = tip; + this->direction = direction.direction(); + this->angle = angle; + + debugAssert(angle >= 0); + debugAssert(angle <= pi()); +} + +/** + Forms the smallest cone that contains the box. Undefined if + the tip is inside or on the box. + */ +Cone::Cone(const Vector3& tip, const Box& box) { + this->tip = tip; + this->direction = (box.center() - tip).direction(); + + // Find the biggest angle + float smallestDotProduct = direction.dot((box.corner(0) - tip).direction()); + + for (int i = 1; i < 8; ++i) { + float dp = direction.dot((box.corner(i) - tip).direction()); + + debugAssert(dp > 0); + + if (dp < smallestDotProduct) { + smallestDotProduct = dp; + } + } + + angle = acosf(smallestDotProduct); +} + + +bool Cone::intersects(const Sphere& b) const { + // If the bounding sphere contains the tip, then + // they definitely touch. + if (b.contains(this->tip)) { + return true; + } + + // Move the tip backwards, effectively making the cone bigger + // to account for the radius of the sphere. + + Vector3 tip = this->tip - direction * b.radius / sinf(angle); + + return Cone(tip, direction, angle).contains(b.center); +} + + +bool Cone::contains(const Vector3& v) const { + + Vector3 d = (v - tip).direction(); + + float x = d.dot(direction); + + return (x > 0) && (x >= cosf(angle)); +} + +}; // namespace diff --git a/dep/src/g3dlite/ConvexPolyhedron.cpp b/dep/src/g3dlite/ConvexPolyhedron.cpp new file mode 100644 index 00000000000..5fa76e3ed41 --- /dev/null +++ b/dep/src/g3dlite/ConvexPolyhedron.cpp @@ -0,0 +1,457 @@ +/** + @file ConvexPolyhedron.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2001-11-11 + @edited 2009-08-10 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/platform.h" +#include "G3D/ConvexPolyhedron.h" +#include "G3D/debug.h" + +namespace G3D { + +ConvexPolygon::ConvexPolygon(const Array<Vector3>& __vertex) : _vertex(__vertex) { + // Intentionally empty +} + + +ConvexPolygon::ConvexPolygon(const Vector3& v0, const Vector3& v1, const Vector3& v2) { + _vertex.append(v0, v1, v2); +} + + +bool ConvexPolygon::isEmpty() const { + return (_vertex.length() == 0) || (getArea() <= fuzzyEpsilon); +} + + +float ConvexPolygon::getArea() const { + + if (_vertex.length() < 3) { + return 0; + } + + float sum = 0; + + int length = _vertex.length(); + // Split into triangle fan, compute individual area + for (int v = 2; v < length; v++) { + int i0 = 0; + int i1 = v - 1; + int i2 = v; + + sum += (_vertex[i1] - _vertex[i0]).cross(_vertex[i2] - _vertex[i0]).magnitude() / 2; + } + + return sum; +} + +void ConvexPolygon::cut(const Plane& plane, ConvexPolygon &above, ConvexPolygon &below) { + DirectedEdge edge; + cut(plane, above, below, edge); +} + +void ConvexPolygon::cut(const Plane& plane, ConvexPolygon &above, ConvexPolygon &below, DirectedEdge &newEdge) { + above._vertex.resize(0); + below._vertex.resize(0); + + if (isEmpty()) { + //debugPrintf("Empty\n"); + return; + } + + int v = 0; + int length = _vertex.length(); + + + Vector3 polyNormal = normal(); + Vector3 planeNormal= plane.normal(); + + // See if the polygon is *in* the plane. + if (planeNormal.fuzzyEq(polyNormal) || planeNormal.fuzzyEq(-polyNormal)) { + // Polygon is parallel to the plane. It must be either above, + // below, or in the plane. + + double a, b, c, d; + Vector3 pt = _vertex[0]; + + plane.getEquation(a,b,c,d); + float r = (float)(a * pt.x + b * pt.y + c * pt.z + d); + + if (fuzzyGe(r, 0)) { + // The polygon is entirely in the plane. + //debugPrintf("Entirely above\n"); + above = *this; + return; + } else { + //debugPrintf("Entirely below (1)\n"); + below = *this; + return; + } + } + + + // Number of edges crossing the plane. Used for + // debug assertions. + int count = 0; + + // True when the last _vertex we looked at was above the plane + bool lastAbove = plane.halfSpaceContains(_vertex[v]); + + if (lastAbove) { + above._vertex.append(_vertex[v]); + } else { + below._vertex.append(_vertex[v]); + } + + for (v = 1; v < length; v++) { + bool isAbove = plane.halfSpaceContains(_vertex[v]); + + if (lastAbove ^ isAbove) { + // Switched sides. + // Create an interpolated point that lies + // in the plane, between the two points. + Line line = Line::fromTwoPoints(_vertex[v - 1], _vertex[v]); + Vector3 interp = line.intersection(plane); + + if (! interp.isFinite()) { + + // Since the polygon is not in the plane (we checked above), + // it must be the case that this edge (and only this edge) + // is in the plane. This only happens when the polygon is + // entirely below the plane except for one edge. This edge + // forms a degenerate polygon, so just treat the whole polygon + // as below the plane. + below = *this; + above._vertex.resize(0); + //debugPrintf("Entirely below\n"); + return; + } + + above._vertex.append(interp); + below._vertex.append(interp); + if (lastAbove) { + newEdge.stop = interp; + } else { + newEdge.start = interp; + } + count++; + } + + lastAbove = isAbove; + if (lastAbove) { + above._vertex.append(_vertex[v]); + } else { + below._vertex.append(_vertex[v]); + } + } + + // Loop back to the first point, seeing if an interpolated point is + // needed. + bool isAbove = plane.halfSpaceContains(_vertex[0]); + if (lastAbove ^ isAbove) { + Line line = Line::fromTwoPoints(_vertex[length - 1], _vertex[0]); + Vector3 interp = line.intersection(plane); + if (! interp.isFinite()) { + // Since the polygon is not in the plane (we checked above), + // it must be the case that this edge (and only this edge) + // is in the plane. This only happens when the polygon is + // entirely below the plane except for one edge. This edge + // forms a degenerate polygon, so just treat the whole polygon + // as below the plane. + below = *this; + above._vertex.resize(0); + //debugPrintf("Entirely below\n"); + return; + } + + above._vertex.append(interp); + below._vertex.append(interp); + debugAssertM(count < 2, "Convex polygons may only intersect planes at two edges."); + if (lastAbove) { + newEdge.stop = interp; + } else { + newEdge.start = interp; + } + ++count; + } + + debugAssertM((count == 2) || (count == 0), "Convex polygons may only intersect planes at two edges."); +} + + +ConvexPolygon ConvexPolygon::inverse() const { + ConvexPolygon result; + int length = _vertex.length(); + result._vertex.resize(length); + + for (int v = 0; v < length; v++) { + result._vertex[v] = _vertex[length - v - 1]; + } + + return result; +} + + +void ConvexPolygon::removeDuplicateVertices(){ + // Any valid polygon should have 3 or more vertices, but why take chances? + if (_vertex.size() >= 2){ + + // Remove duplicate vertices. + for (int i=0;i<_vertex.size()-1;++i){ + if (_vertex[i].fuzzyEq(_vertex[i+1])){ + _vertex.remove(i+1); + --i; // Don't move forward. + } + } + + // Check the last vertex against the first. + if (_vertex[_vertex.size()-1].fuzzyEq(_vertex[0])){ + _vertex.pop(); + } + } +} + +////////////////////////////////////////////////////////////////////////////// + +ConvexPolyhedron::ConvexPolyhedron(const Array<ConvexPolygon>& _face) : face(_face) { + // Intentionally empty +} + + +float ConvexPolyhedron::getVolume() const { + + if (face.length() < 4) { + return 0; + } + + // The volume of any pyramid is 1/3 * h * base area. + // Discussion at: http://nrich.maths.org/mathsf/journalf/oct01/art1/ + + float sum = 0; + + // Choose the first _vertex of the first face as the origin. + // This lets us skip one face, too, and avoids negative heights. + Vector3 v0 = face[0]._vertex[0]; + for (int f = 1; f < face.length(); f++) { + const ConvexPolygon& poly = face[f]; + + float height = (poly._vertex[0] - v0).dot(poly.normal()); + float base = poly.getArea(); + + sum += height * base; + } + + return sum / 3; +} + +bool ConvexPolyhedron::isEmpty() const { + return (face.length() == 0) || (getVolume() <= fuzzyEpsilon); +} + +void ConvexPolyhedron::cut(const Plane& plane, ConvexPolyhedron &above, ConvexPolyhedron &below) { + above.face.resize(0); + below.face.resize(0); + + Array<DirectedEdge> edge; + + int f; + + // See if the plane cuts this polyhedron at all. Detect when + // the polyhedron is entirely to one side or the other. + //{ + int numAbove = 0, numIn = 0, numBelow = 0; + bool ruledOut = false; + double d; + Vector3 abc; + plane.getEquation(abc, d); + + // This number has to be fairly large to prevent precision problems down + // the road. + const float eps = 0.005f; + for (f = face.length() - 1; (f >= 0) && (!ruledOut); f--) { + const ConvexPolygon& poly = face[f]; + for (int v = poly._vertex.length() - 1; (v >= 0) && (!ruledOut); v--) { + double r = abc.dot(poly._vertex[v]) + d; + if (r > eps) { + numAbove++; + } else if (r < -eps) { + numBelow++; + } else { + numIn++; + } + + ruledOut = (numAbove != 0) && (numBelow !=0); + } + } + + if (numBelow == 0) { + above = *this; + return; + } else if (numAbove == 0) { + below = *this; + return; + } + //} + + // Clip each polygon, collecting split edges. + for (f = face.length() - 1; f >= 0; f--) { + ConvexPolygon a, b; + DirectedEdge e; + face[f].cut(plane, a, b, e); + + bool aEmpty = a.isEmpty(); + bool bEmpty = b.isEmpty(); + + //debugPrintf("\n"); + if (! aEmpty) { + //debugPrintf(" Above %f\n", a.getArea()); + above.face.append(a); + } + + if (! bEmpty) { + //debugPrintf(" Below %f\n", b.getArea()); + below.face.append(b); + } + + if (! aEmpty && ! bEmpty) { + //debugPrintf(" == Split\n"); + edge.append(e); + } else { + // Might be the case that the polygon is entirely on + // one side of the plane yet there is an edge we need + // because it touches the plane. + // + // Extract the non-empty _vertex list and examine it. + // If we find exactly one edge in the plane, add that edge. + const Array<Vector3>& _vertex = (aEmpty ? b._vertex : a._vertex); + int L = _vertex.length(); + int count = 0; + for (int v = 0; v < L; v++) { + if (plane.fuzzyContains(_vertex[v]) && plane.fuzzyContains(_vertex[(v + 1) % L])) { + e.start = _vertex[v]; + e.stop = _vertex[(v + 1) % L]; + count++; + } + } + + if (count == 1) { + edge.append(e); + } + } + } + + if (above.face.length() == 1) { + // Only one face above means that this entire + // polyhedron is below the plane. Move that face over. + below.face.append(above.face[0]); + above.face.resize(0); + } else if (below.face.length() == 1) { + // This shouldn't happen, but it arises in practice + // from numerical imprecision. + above.face.append(below.face[0]); + below.face.resize(0); + } + + if ((above.face.length() > 0) && (below.face.length() > 0)) { + // The polyhedron was actually cut; create a cap polygon + ConvexPolygon cap; + + // Collect the final polgyon by sorting the edges + int numVertices = edge.length(); +/*debugPrintf("\n"); +for (int xx=0; xx < numVertices; xx++) { + std::string s1 = edge[xx].start.toString(); + std::string s2 = edge[xx].stop.toString(); + debugPrintf("%s -> %s\n", s1.c_str(), s2.c_str()); +} +*/ + + // Need at least three points to make a polygon + debugAssert(numVertices >= 3); + + Vector3 last_vertex = edge.last().stop; + cap._vertex.append(last_vertex); + + // Search for the next _vertex. Because of accumulating + // numerical error, we have to find the closest match, not + // just the one we expect. + for (int v = numVertices - 1; v >= 0; v--) { + // matching edge index + int index = 0; + int num = edge.length(); + double distance = (edge[index].start - last_vertex).squaredMagnitude(); + for (int e = 1; e < num; e++) { + double d = (edge[e].start - last_vertex).squaredMagnitude(); + + if (d < distance) { + // This is the new closest one + index = e; + distance = d; + } + } + + // Don't tolerate ridiculous error. + debugAssertM(distance < 0.02, "Edge missing while closing polygon."); + + last_vertex = edge[index].stop; + cap._vertex.append(last_vertex); + } + + //debugPrintf("\n"); + //debugPrintf("Cap (both) %f\n", cap.getArea()); + above.face.append(cap); + below.face.append(cap.inverse()); + } + + // Make sure we put enough faces on each polyhedra + debugAssert((above.face.length() == 0) || (above.face.length() >= 4)); + debugAssert((below.face.length() == 0) || (below.face.length() >= 4)); +} + +/////////////////////////////////////////////// + +ConvexPolygon2D::ConvexPolygon2D(const Array<Vector2>& pts, bool reverse) : m_vertex(pts) { + if (reverse) { + m_vertex.reverse(); + } +} + + +bool ConvexPolygon2D::contains(const Vector2& p, bool reverse) const { + // Compute the signed area of each polygon from p to an edge. + // If the area is non-negative for all polygons then p is inside + // the polygon. (To adapt this algorithm for a concave polygon, + // the *sum* of the areas must be non-negative). + + float r = reverse ? -1 : 1; + + for (int i0 = 0; i0 < m_vertex.size(); ++i0) { + int i1 = (i0 + 1) % m_vertex.size(); + const Vector2& v0 = m_vertex[i0]; + const Vector2& v1 = m_vertex[i1]; + + Vector2 e0 = v0 - p; + Vector2 e1 = v1 - p; + + // Area = (1/2) cross product, negated to be ccw in + // a 2D space; we neglect the 1/2 + float area = -(e0.x * e1.y - e0.y * e1.x); + + if (area * r < 0) { + return false; + } + } + + return true; +} + + +} + diff --git a/dep/src/g3dlite/CoordinateFrame.cpp b/dep/src/g3dlite/CoordinateFrame.cpp new file mode 100644 index 00000000000..9b639b62082 --- /dev/null +++ b/dep/src/g3dlite/CoordinateFrame.cpp @@ -0,0 +1,436 @@ +/** + @file CoordinateFrame.cpp + + Coordinate frame class + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2001-06-02 + @edited 2009-11-13 + + Copyright 2000-2010, Morgan McGuire. + All rights reserved. +*/ + +#include "G3D/platform.h" +#include "G3D/CoordinateFrame.h" +#include "G3D/Quat.h" +#include "G3D/Matrix4.h" +#include "G3D/Box.h" +#include "G3D/AABox.h" +#include "G3D/Sphere.h" +#include "G3D/Triangle.h" +#include "G3D/Ray.h" +#include "G3D/Capsule.h" +#include "G3D/Cylinder.h" +#include "G3D/UprightFrame.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +CoordinateFrame::CoordinateFrame(const Any& any) { + any.verifyName("CFrame"); + if (toUpper(any.name()) == "CFRAME") { + any.verifyType(Any::TABLE, Any::ARRAY); + if (any.type() == Any::TABLE) { + rotation = any["rotation"]; + translation = any["translation"]; + } else { + any.verifySize(2); + rotation = any[0]; + translation = any[1]; + } + } else { + any.verifyName("CFrame::fromXYZYPRDegrees"); + any.verifyType(Any::ARRAY); + any.verifySize(3, 6); + + int s = any.size(); + + *this = fromXYZYPRDegrees(any[0], any[1], any[2], + (s > 3) ? any[3].number() : 0.0f, + (s > 4) ? any[4].number() : 0.0f, + (s > 5) ? any[5].number() : 0.0f); + } +} + + +CoordinateFrame::operator Any() const { + float x, y, z, yaw, pitch, roll; + getXYZYPRDegrees(x, y, z, yaw, pitch, roll); + Any a(Any::ARRAY, "CFrame::fromXYZYPRDegrees"); + a.append(x, y, z, yaw); + if ( ! G3D::fuzzyEq(yaw, 0.0f) || ! G3D::fuzzyEq(pitch, 0.0f) || ! G3D::fuzzyEq(roll, 0.0f)) { + a.append(yaw); + if (! G3D::fuzzyEq(pitch, 0.0f) || ! G3D::fuzzyEq(roll, 0.0f)) { + a.append(pitch); + if (! G3D::fuzzyEq(roll, 0.0f)) { + a.append(roll); + } + } + } + return a; +} + + +CoordinateFrame::CoordinateFrame(const class UprightFrame& f) { + *this = f.toCoordinateFrame(); +} + + +CoordinateFrame::CoordinateFrame() : + rotation(Matrix3::identity()), translation(Vector3::zero()) { +} + +CoordinateFrame CoordinateFrame::fromXYZYPRRadians(float x, float y, float z, float yaw, + float pitch, float roll) { + Matrix3 rotation = Matrix3::fromAxisAngle(Vector3::unitY(), yaw); + + rotation = Matrix3::fromAxisAngle(rotation.column(0), pitch) * rotation; + rotation = Matrix3::fromAxisAngle(rotation.column(2), roll) * rotation; + + const Vector3 translation(x, y, z); + + return CoordinateFrame(rotation, translation); +} + + +void CoordinateFrame::getXYZYPRRadians(float& x, float& y, float& z, + float& yaw, float& pitch, float& roll) const { + x = translation.x; + y = translation.y; + z = translation.z; + + const Vector3& look = lookVector(); + + if (abs(look.y) > 0.99f) { + // Looking nearly straight up or down + + yaw = G3D::pi() + atan2(look.x, look.z); + pitch = asin(look.y); + roll = 0.0f; + + } else { + + // Yaw cannot be affected by others, so pull it first + yaw = G3D::pi() + atan2(look.x, look.z); + + // Pitch is the elevation of the yaw vector + pitch = asin(look.y); + + Vector3 actualRight = rightVector(); + Vector3 expectedRight = look.cross(Vector3::unitY()); + + roll = 0;//acos(actualRight.dot(expectedRight)); TODO + } +} + + +void CoordinateFrame::getXYZYPRDegrees(float& x, float& y, float& z, + float& yaw, float& pitch, float& roll) const { + getXYZYPRRadians(x, y, z, yaw, pitch, roll); + yaw = toDegrees(yaw); + pitch = toDegrees(pitch); + roll = toDegrees(roll); +} + + +CoordinateFrame CoordinateFrame::fromXYZYPRDegrees(float x, float y, float z, + float yaw, float pitch, float roll) { + return fromXYZYPRRadians(x, y, z, toRadians(yaw), toRadians(pitch), toRadians(roll)); +} + + +Ray CoordinateFrame::lookRay() const { + return Ray::fromOriginAndDirection(translation, lookVector()); +} + + +bool CoordinateFrame::fuzzyEq(const CoordinateFrame& other) const { + + for (int c = 0; c < 3; ++c) { + for (int r = 0; r < 3; ++r) { + if (! G3D::fuzzyEq(other.rotation[r][c], rotation[r][c])) { + return false; + } + } + if (! G3D::fuzzyEq(translation[c], other.translation[c])) { + return false; + } + } + + return true; +} + + +bool CoordinateFrame::fuzzyIsIdentity() const { + const Matrix3& I = Matrix3::identity(); + + for (int c = 0; c < 3; ++c) { + for (int r = 0; r < 3; ++r) { + if (fuzzyNe(I[r][c], rotation[r][c])) { + return false; + } + } + if (fuzzyNe(translation[c], 0)) { + return false; + } + } + + return true; +} + + +bool CoordinateFrame::isIdentity() const { + return + (translation == Vector3::zero()) && + (rotation == Matrix3::identity()); +} + + +Matrix4 CoordinateFrame::toMatrix4() const { + return Matrix4(*this); +} + + +std::string CoordinateFrame::toXML() const { + return G3D::format( + "<COORDINATEFRAME>\n %lf,%lf,%lf,%lf,\n %lf,%lf,%lf,%lf,\n %lf,%lf,%lf,%lf,\n %lf,%lf,%lf,%lf\n</COORDINATEFRAME>\n", + rotation[0][0], rotation[0][1], rotation[0][2], translation.x, + rotation[1][0], rotation[1][1], rotation[1][2], translation.y, + rotation[2][0], rotation[2][1], rotation[2][2], translation.z, + 0.0, 0.0, 0.0, 1.0); +} + + +Plane CoordinateFrame::toObjectSpace(const Plane& p) const { + Vector3 N, P; + double d; + p.getEquation(N, d); + P = N * (float)d; + P = pointToObjectSpace(P); + N = normalToObjectSpace(N); + return Plane(N, P); +} + + +Plane CoordinateFrame::toWorldSpace(const Plane& p) const { + Vector3 N, P; + double d; + p.getEquation(N, d); + P = N * (float)d; + P = pointToWorldSpace(P); + N = normalToWorldSpace(N); + return Plane(N, P); +} + + +Triangle CoordinateFrame::toObjectSpace(const Triangle& t) const { + return Triangle(pointToObjectSpace(t.vertex(0)), + pointToObjectSpace(t.vertex(1)), + pointToObjectSpace(t.vertex(2))); +} + + +Triangle CoordinateFrame::toWorldSpace(const Triangle& t) const { + return Triangle(pointToWorldSpace(t.vertex(0)), + pointToWorldSpace(t.vertex(1)), + pointToWorldSpace(t.vertex(2))); +} + + +Cylinder CoordinateFrame::toWorldSpace(const Cylinder& c) const { + return Cylinder( + pointToWorldSpace(c.point(0)), + pointToWorldSpace(c.point(1)), + c.radius()); +} + + +Capsule CoordinateFrame::toWorldSpace(const Capsule& c) const { + return Capsule( + pointToWorldSpace(c.point(0)), + pointToWorldSpace(c.point(1)), + c.radius()); +} + + +Box CoordinateFrame::toWorldSpace(const AABox& b) const { + Box b2(b); + return toWorldSpace(b2); +} + + +Box CoordinateFrame::toWorldSpace(const Box& b) const { + Box out(b); + + for (int i = 0; i < 8; ++i) { + out._corner[i] = pointToWorldSpace(b._corner[i]); + debugAssert(! isNaN(out._corner[i].x)); + } + + for (int i = 0; i < 3; ++i) { + out._axis[i] = vectorToWorldSpace(b._axis[i]); + } + + out._center = pointToWorldSpace(b._center); + + return out; +} + + +Box CoordinateFrame::toObjectSpace(const Box &b) const { + return inverse().toWorldSpace(b); +} + + +Box CoordinateFrame::toObjectSpace(const AABox& b) const { + return toObjectSpace(Box(b)); +} + + +CoordinateFrame::CoordinateFrame(class BinaryInput& b) : rotation(Matrix3::zero()) { + deserialize(b); +} + + +void CoordinateFrame::deserialize(class BinaryInput& b) { + rotation.deserialize(b); + translation.deserialize(b); +} + + +void CoordinateFrame::serialize(class BinaryOutput& b) const { + rotation.serialize(b); + translation.serialize(b); +} + + +Sphere CoordinateFrame::toWorldSpace(const Sphere &b) const { + return Sphere(pointToWorldSpace(b.center), b.radius); +} + + +Sphere CoordinateFrame::toObjectSpace(const Sphere &b) const { + return Sphere(pointToObjectSpace(b.center), b.radius); +} + + +Ray CoordinateFrame::toWorldSpace(const Ray& r) const { + return Ray::fromOriginAndDirection(pointToWorldSpace(r.origin()), vectorToWorldSpace(r.direction())); +} + + +Ray CoordinateFrame::toObjectSpace(const Ray& r) const { + return Ray::fromOriginAndDirection(pointToObjectSpace(r.origin()), vectorToObjectSpace(r.direction())); +} + + +void CoordinateFrame::lookAt(const Vector3 &target) { + lookAt(target, Vector3::unitY()); +} + + +void CoordinateFrame::lookAt( + const Vector3& target, + Vector3 up) { + + up = up.direction(); + + Vector3 look = (target - translation).direction(); + if (fabs(look.dot(up)) > .99f) { + up = Vector3::unitX(); + if (fabs(look.dot(up)) > .99f) { + up = Vector3::unitY(); + } + } + + up -= look * look.dot(up); + up.unitize(); + + Vector3 z = -look; + Vector3 x = -z.cross(up); + x.unitize(); + + Vector3 y = z.cross(x); + + rotation.setColumn(0, x); + rotation.setColumn(1, y); + rotation.setColumn(2, z); +} + + +CoordinateFrame CoordinateFrame::lerp( + const CoordinateFrame& other, + float alpha) const { + + if (alpha == 1.0f) { + return other; + } else if (alpha == 0.0f) { + return *this; + } else { + Quat q1 = Quat(this->rotation); + Quat q2 = Quat(other.rotation); + + return CoordinateFrame( + q1.slerp(q2, alpha).toRotationMatrix(), + this->translation * (1 - alpha) + other.translation * alpha); + } +} + + +void CoordinateFrame::pointToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const { + vout.resize(v.size()); + + for (int i = v.size() - 1; i >= 0; --i) { + vout[i] = pointToWorldSpace(v[i]); + } +} + + +void CoordinateFrame::normalToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const { + vout.resize(v.size()); + + for (int i = v.size() - 1; i >= 0; --i) { + vout[i] = normalToWorldSpace(v[i]); + } +} + + +void CoordinateFrame::vectorToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const { + vout.resize(v.size()); + + for (int i = v.size() - 1; i >= 0; --i) { + vout[i] = vectorToWorldSpace(v[i]); + } +} + + +void CoordinateFrame::pointToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const { + vout.resize(v.size()); + + for (int i = v.size() - 1; i >= 0; --i) { + vout[i] = pointToObjectSpace(v[i]); + } +} + + +void CoordinateFrame::normalToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const { + vout.resize(v.size()); + + for (int i = v.size() - 1; i >= 0; --i) { + vout[i] = normalToObjectSpace(v[i]); + } +} + + +void CoordinateFrame::vectorToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const { + vout.resize(v.size()); + + for (int i = v.size() - 1; i >= 0; --i) { + vout[i] = vectorToObjectSpace(v[i]); + } +} + +} // namespace diff --git a/dep/src/g3dlite/Crypto.cpp b/dep/src/g3dlite/Crypto.cpp index 03851193e57..c69b23375ce 100644 --- a/dep/src/g3dlite/Crypto.cpp +++ b/dep/src/g3dlite/Crypto.cpp @@ -1,7 +1,8 @@ /** @file Crypto.cpp - @author Morgan McGuire, matrix@graphics3d.com + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2006-03-28 @edited 2006-04-06 @@ -10,8 +11,10 @@ #include "G3D/platform.h" #include "G3D/Crypto.h" #include "G3D/g3dmath.h" +#include <zlib.h> namespace G3D { + int Crypto::smallPrime(int n) { debugAssert(n < numSmallPrimes() && n >= 0); @@ -20,125 +23,48 @@ int Crypto::smallPrime(int n) { // http://primes.utm.edu/lists/small/1000.txt static const int table[] = { - 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, - 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, - 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, - 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, - 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, - 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, - 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, - 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, - 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, - 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, - 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, - 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, - 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, - 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, - 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, - 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, - 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, - 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, - 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, - 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, - 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, - 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, - 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, - 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, - 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, - 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, - 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, + 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, + 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, + 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, + 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, + 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, + 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, + 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, + 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, + 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, + 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, + 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, + 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, + 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, + 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, + 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, + 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, + 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, + 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, + 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, + 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, + 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, + 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, + 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, + 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, + 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, + 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, + 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, - 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, - 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, + 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, + 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999}; return table[n]; } + int Crypto::numSmallPrimes() { return 303; } uint32 Crypto::crc32(const void* byte, size_t numBytes) { - static const uint32 crc32Table[256] = { - 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, - 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, - 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, - 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, - 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, - 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, - 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, - 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, - 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, - 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, - 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, - 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, - 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, - 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, - 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, - 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, - - 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, - 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, - 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, - 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, - 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, - 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, - 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, - 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, - 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, - 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, - 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, - 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, - 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, - 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, - 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, - 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, - - 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, - 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, - 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, - 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, - 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, - 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, - 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, - 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, - 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, - 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, - 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, - 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, - 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, - 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, - 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, - 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, - - 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, - 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, - 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, - 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, - 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, - 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, - 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, - 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, - 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, - 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, - 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, - 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, - 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, - 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, - 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, - 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D, - }; - - // By definition, initialize to all binary 1's - uint32 value = 0xFFFFFFFF; - - for (size_t i = 0; i < numBytes; ++i) { - value = (value >> 8 ) ^ crc32Table[static_cast<const uint8*>(byte)[i] ^ (value & 0xFF)]; - } - - return value; + return ::crc32(::crc32(0, Z_NULL, 0), static_cast<const Bytef *>(byte), numBytes); } } // G3D - diff --git a/dep/src/g3dlite/Crypto_md5.cpp b/dep/src/g3dlite/Crypto_md5.cpp new file mode 100644 index 00000000000..c7ee535d61e --- /dev/null +++ b/dep/src/g3dlite/Crypto_md5.cpp @@ -0,0 +1,471 @@ +/** + @file Crypto_md5.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + Copyright 2006-2007, Morgan McGuire. All rights reserved. + + @created 2006-03-28 + @edited 2006-04-06 + */ + +#include "G3D/platform.h" +#include "G3D/Crypto.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +#include <cstring> + +namespace G3D { + + +MD5Hash::MD5Hash(class BinaryInput& b) { + deserialize(b); +} + + +void MD5Hash::deserialize(class BinaryInput& b) { + b.readBytes(value, 16); +} + + +void MD5Hash::serialize(class BinaryOutput& b) const { + b.writeBytes(value, 16); +} + + +typedef unsigned char md5_byte_t; /* 8-bit byte */ +typedef unsigned int md5_word_t; /* 32-bit word */ + +/* Define the state of the MD5 Algorithm. */ +typedef struct md5_state_s { + md5_word_t count[2]; /* message length in bits, lsw first */ + md5_word_t abcd[4]; /* digest buffer */ + md5_byte_t buf[64]; /* accumulate block */ +} md5_state_t; + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* Initialize the algorithm. */ +static void md5_init(md5_state_t *pms); + +/* Append a string to the message. */ +static void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes); + +/* Finish the message and return the digest. */ +void md5_finish(md5_state_t *pms, md5_byte_t digest[16]); +#ifdef __cplusplus +} +#endif + + + +MD5Hash Crypto::md5(const void* data, size_t n) { + md5_state_t state; + md5_init(&state); + md5_append(&state, (const uint8*)data, (int)n); + + MD5Hash h; + md5_finish(&state, &(h[0])); + return h; +} + +/* + Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved. + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + L. Peter Deutsch + ghost@aladdin.com + + */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.c is L. Peter Deutsch + <ghost@aladdin.com>. Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order + either statically or dynamically; added missing #include <string.h> + in library. + 2002-03-11 lpd Corrected argument list for main(), and added int return + type, in test program and T value program. + 2002-02-21 lpd Added missing #include <stdio.h> in test program. + 2000-07-03 lpd Patched to eliminate warnings about "constant is + unsigned in ANSI C, signed in traditional"; made test program + self-checking. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5). + 1999-05-03 lpd Original version. + */ + +/* + * This package supports both compile-time and run-time determination of CPU + * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be + * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is + * defined as non-zero, the code will be compiled to run only on big-endian + * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to + * run on either big- or little-endian CPUs, but will run slightly less + * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined. + */ + + +#if defined(G3D_LINUX) || defined(G3D_OSX) +# if defined(G3D_OSX_PPC) +# include <ppc/endian.h> +# elif defined(G3D_OSX_INTEL) +# include <i386/endian.h> +# elif defined(__linux__) +# include <endian.h> +# elif defined(__FreeBSD__) +# include <sys/endian.h> +# endif +#else +# define BYTE_ORDER 0 +#endif + +#define T_MASK ((md5_word_t)~0) +#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) +#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) +#define T3 0x242070db +#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) +#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) +#define T6 0x4787c62a +#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) +#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) +#define T9 0x698098d8 +#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) +#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) +#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) +#define T13 0x6b901122 +#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) +#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) +#define T16 0x49b40821 +#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) +#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) +#define T19 0x265e5a51 +#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) +#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) +#define T22 0x02441453 +#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) +#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) +#define T25 0x21e1cde6 +#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) +#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) +#define T28 0x455a14ed +#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) +#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) +#define T31 0x676f02d9 +#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) +#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) +#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) +#define T35 0x6d9d6122 +#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) +#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) +#define T38 0x4bdecfa9 +#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) +#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) +#define T41 0x289b7ec6 +#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) +#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) +#define T44 0x04881d05 +#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) +#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) +#define T47 0x1fa27cf8 +#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) +#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) +#define T50 0x432aff97 +#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) +#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) +#define T53 0x655b59c3 +#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) +#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) +#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) +#define T57 0x6fa87e4f +#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) +#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) +#define T60 0x4e0811a1 +#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) +#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) +#define T63 0x2ad7d2bb +#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) + + +static void +md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/) +{ + md5_word_t + a = pms->abcd[0], b = pms->abcd[1], + c = pms->abcd[2], d = pms->abcd[3]; + md5_word_t t; +#if BYTE_ORDER > 0 + /* Define storage only for big-endian CPUs. */ + md5_word_t X[16]; +#else + /* Define storage for little-endian or both types of CPUs. */ + md5_word_t xbuf[16]; + const md5_word_t *X; +#endif + + { +#if BYTE_ORDER == 0 + /* + * Determine dynamically whether this is a big-endian or + * little-endian machine, since we can use a more efficient + * algorithm on the latter. + */ + static const int w = 1; + + if (*((const md5_byte_t *)&w)) /* dynamic little-endian */ +#endif +#if BYTE_ORDER <= 0 /* little-endian */ + { + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if (!((data - (const md5_byte_t *)0) & 3)) { + /* data are properly aligned */ + X = (const md5_word_t *)data; + } else { + /* not aligned */ + memcpy(xbuf, data, 64); + X = xbuf; + } + } +#endif +#if BYTE_ORDER == 0 + else /* dynamic big-endian */ +#endif +#if BYTE_ORDER >= 0 /* big-endian */ + { + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const md5_byte_t *xp = data; + int i; + +# if BYTE_ORDER == 0 + X = xbuf; /* (dynamic only) */ +# else +# define xbuf X /* (static only) */ +# endif + for (i = 0; i < 16; ++i, xp += 4) + xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); + } +#endif + } + +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + + /* Round 1. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ +#define F(x, y, z) (((x) & (y)) | (~(x) & (z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + F(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 7, T1); + SET(d, a, b, c, 1, 12, T2); + SET(c, d, a, b, 2, 17, T3); + SET(b, c, d, a, 3, 22, T4); + SET(a, b, c, d, 4, 7, T5); + SET(d, a, b, c, 5, 12, T6); + SET(c, d, a, b, 6, 17, T7); + SET(b, c, d, a, 7, 22, T8); + SET(a, b, c, d, 8, 7, T9); + SET(d, a, b, c, 9, 12, T10); + SET(c, d, a, b, 10, 17, T11); + SET(b, c, d, a, 11, 22, T12); + SET(a, b, c, d, 12, 7, T13); + SET(d, a, b, c, 13, 12, T14); + SET(c, d, a, b, 14, 17, T15); + SET(b, c, d, a, 15, 22, T16); +#undef SET + + /* Round 2. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ +#define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + G(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 1, 5, T17); + SET(d, a, b, c, 6, 9, T18); + SET(c, d, a, b, 11, 14, T19); + SET(b, c, d, a, 0, 20, T20); + SET(a, b, c, d, 5, 5, T21); + SET(d, a, b, c, 10, 9, T22); + SET(c, d, a, b, 15, 14, T23); + SET(b, c, d, a, 4, 20, T24); + SET(a, b, c, d, 9, 5, T25); + SET(d, a, b, c, 14, 9, T26); + SET(c, d, a, b, 3, 14, T27); + SET(b, c, d, a, 8, 20, T28); + SET(a, b, c, d, 13, 5, T29); + SET(d, a, b, c, 2, 9, T30); + SET(c, d, a, b, 7, 14, T31); + SET(b, c, d, a, 12, 20, T32); +#undef SET + + /* Round 3. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + H(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 5, 4, T33); + SET(d, a, b, c, 8, 11, T34); + SET(c, d, a, b, 11, 16, T35); + SET(b, c, d, a, 14, 23, T36); + SET(a, b, c, d, 1, 4, T37); + SET(d, a, b, c, 4, 11, T38); + SET(c, d, a, b, 7, 16, T39); + SET(b, c, d, a, 10, 23, T40); + SET(a, b, c, d, 13, 4, T41); + SET(d, a, b, c, 0, 11, T42); + SET(c, d, a, b, 3, 16, T43); + SET(b, c, d, a, 6, 23, T44); + SET(a, b, c, d, 9, 4, T45); + SET(d, a, b, c, 12, 11, T46); + SET(c, d, a, b, 15, 16, T47); + SET(b, c, d, a, 2, 23, T48); +#undef SET + + /* Round 4. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ +#define I(x, y, z) ((y) ^ ((x) | ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + I(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 6, T49); + SET(d, a, b, c, 7, 10, T50); + SET(c, d, a, b, 14, 15, T51); + SET(b, c, d, a, 5, 21, T52); + SET(a, b, c, d, 12, 6, T53); + SET(d, a, b, c, 3, 10, T54); + SET(c, d, a, b, 10, 15, T55); + SET(b, c, d, a, 1, 21, T56); + SET(a, b, c, d, 8, 6, T57); + SET(d, a, b, c, 15, 10, T58); + SET(c, d, a, b, 6, 15, T59); + SET(b, c, d, a, 13, 21, T60); + SET(a, b, c, d, 4, 6, T61); + SET(d, a, b, c, 11, 10, T62); + SET(c, d, a, b, 2, 15, T63); + SET(b, c, d, a, 9, 21, T64); +#undef SET + + /* Then perform the following additions. (That is increment each + of the four registers by the value it had before this block + was started.) */ + pms->abcd[0] += a; + pms->abcd[1] += b; + pms->abcd[2] += c; + pms->abcd[3] += d; +} + +void +md5_init(md5_state_t *pms) +{ + pms->count[0] = pms->count[1] = 0; + pms->abcd[0] = 0x67452301; + pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + pms->abcd[3] = 0x10325476; +} + +void +md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes) +{ + const md5_byte_t *p = data; + int left = nbytes; + int offset = (pms->count[0] >> 3) & 63; + md5_word_t nbits = (md5_word_t)(nbytes << 3); + + if (nbytes <= 0) + return; + + /* Update the message length. */ + pms->count[1] += nbytes >> 29; + pms->count[0] += nbits; + if (pms->count[0] < nbits) + pms->count[1]++; + + /* Process an initial partial block. */ + if (offset) { + int copy = (offset + nbytes > 64 ? 64 - offset : nbytes); + + memcpy(pms->buf + offset, p, copy); + if (offset + copy < 64) + return; + p += copy; + left -= copy; + md5_process(pms, pms->buf); + } + + /* Process full blocks. */ + for (; left >= 64; p += 64, left -= 64) + md5_process(pms, p); + + /* Process a final partial block. */ + if (left) + memcpy(pms->buf, p, left); +} + +void +md5_finish(md5_state_t *pms, md5_byte_t digest[16]) +{ + static const md5_byte_t pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + md5_byte_t data[8]; + int i; + + /* Save the length before padding. */ + for (i = 0; i < 8; ++i) + data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3)); + /* Pad to 56 bytes mod 64. */ + md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); + /* Append the length. */ + md5_append(pms, data, 8); + for (i = 0; i < 16; ++i) + digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3)); +} + +} diff --git a/dep/src/g3dlite/Cylinder.cpp b/dep/src/g3dlite/Cylinder.cpp new file mode 100644 index 00000000000..7a7b9f9440d --- /dev/null +++ b/dep/src/g3dlite/Cylinder.cpp @@ -0,0 +1,176 @@ +/** + @file Cylinder.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-02-07 + @edited 2006-02-18 + + Copyright 2000-2006, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/platform.h" +#include "G3D/Cylinder.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/LineSegment.h" +#include "G3D/CoordinateFrame.h" +#include "G3D/Line.h" +#include "G3D/AABox.h" + +namespace G3D { + +Cylinder::Cylinder(class BinaryInput& b) { + deserialize(b); +} + + +Cylinder::Cylinder() { +} + + +Cylinder::Cylinder(const Vector3& _p1, const Vector3& _p2, float _r) + : p1(_p1), p2(_p2), mRadius(_r) { +} + + +void Cylinder::serialize(class BinaryOutput& b) const { + p1.serialize(b); + p2.serialize(b); + b.writeFloat64(mRadius); +} + + +void Cylinder::deserialize(class BinaryInput& b) { + p1.deserialize(b); + p2.deserialize(b); + mRadius = b.readFloat64(); +} + + +Line Cylinder::axis() const { + return Line::fromTwoPoints(p1, p2); +} + + + +float Cylinder::radius() const { + return mRadius; +} + + +float Cylinder::volume() const { + return + (float)pi() * square(mRadius) * (p1 - p2).magnitude(); +} + + +float Cylinder::area() const { + return + // Sides + (twoPi() * mRadius) * height() + + + // Caps + twoPi() * square(mRadius); +} + +void Cylinder::getBounds(AABox& out) const { + Vector3 min = p1.min(p2) - (Vector3(1, 1, 1) * mRadius); + Vector3 max = p1.max(p2) + (Vector3(1, 1, 1) * mRadius); + out = AABox(min, max); +} + +bool Cylinder::contains(const Vector3& p) const { + return LineSegment::fromTwoPoints(p1, p2).distanceSquared(p) <= square(mRadius); +} + + +void Cylinder::getReferenceFrame(CoordinateFrame& cframe) const { + cframe.translation = center(); + + Vector3 Y = (p1 - p2).direction(); + Vector3 X = (abs(Y.dot(Vector3::unitX())) > 0.9) ? Vector3::unitY() : Vector3::unitX(); + Vector3 Z = X.cross(Y).direction(); + X = Y.cross(Z); + cframe.rotation.setColumn(0, X); + cframe.rotation.setColumn(1, Y); + cframe.rotation.setColumn(2, Z); +} + + +void Cylinder::getRandomSurfacePoint(Vector3& p, Vector3& N) const { + float h = height(); + float r = radius(); + + // Create a random point on a standard cylinder and then rotate to the global frame. + + // Relative areas (factor of 2PI already taken out) + float capRelArea = square(r) / 2.0f; + float sideRelArea = r * h; + + float r1 = uniformRandom(0, capRelArea * 2 + sideRelArea); + + if (r1 < capRelArea * 2) { + + // Select a point uniformly at random on a disk + // @cite http://mathworld.wolfram.com/DiskPointPicking.html + float a = uniformRandom(0, (float)twoPi()); + float r2 = sqrt(uniformRandom(0, 1)) * r; + p.x = cos(a) * r2; + p.z = sin(a) * r2; + + N.x = 0; + N.z = 0; + if (r1 < capRelArea) { + // Top + p.y = h / 2.0f; + N.y = 1; + } else { + // Bottom + p.y = -h / 2.0f; + N.y = -1; + } + } else { + // Side + float a = uniformRandom(0, (float)twoPi()); + N.x = cos(a); + N.y = 0; + N.z = sin(a); + p.x = N.x * r; + p.z = N.y * r; + p.y = uniformRandom(-h / 2.0f, h / 2.0f); + } + + // Transform to world space + CoordinateFrame cframe; + getReferenceFrame(cframe); + + p = cframe.pointToWorldSpace(p); + N = cframe.normalToWorldSpace(N); +} + + +Vector3 Cylinder::randomInteriorPoint() const { + float h = height(); + float r = radius(); + + // Create a random point in a standard cylinder and then rotate to the global frame. + + // Select a point uniformly at random on a disk + // @cite http://mathworld.wolfram.com/DiskPointPicking.html + float a = uniformRandom(0, (float)twoPi()); + float r2 = sqrt(uniformRandom(0, 1)) * r; + + Vector3 p( cos(a) * r2, + uniformRandom(-h / 2.0f, h / 2.0f), + sin(a) * r2); + + // Transform to world space + CoordinateFrame cframe; + getReferenceFrame(cframe); + + return cframe.pointToWorldSpace(p); +} + +} // namespace diff --git a/dep/src/g3dlite/GCamera.cpp b/dep/src/g3dlite/GCamera.cpp new file mode 100644 index 00000000000..64b0c94543e --- /dev/null +++ b/dep/src/g3dlite/GCamera.cpp @@ -0,0 +1,502 @@ +/** + @file GCamera.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + @author Jeff Marsceill, 08jcm@williams.edu + + @created 2005-07-20 + @edited 2009-11-24 +*/ +#include "G3D/GCamera.h" +#include "G3D/platform.h" +#include "G3D/Rect2D.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Ray.h" +#include "G3D/Matrix4.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +GCamera::GCamera(const Any& any) { + any.verifyName("GCamera"); + any.verifyType(Any::TABLE); + *this = GCamera(); + + const Any::AnyTable& table = any.table(); + Any::AnyTable::Iterator it = table.begin(); + while (it.hasMore()) { + const std::string& k = toUpper(it->key); + if (k == "FOVDIRECTION") { + const std::string& v = toUpper(it->value); + if (v == "HORIZONTAL") { + m_direction = HORIZONTAL; + } else if (v == "VERTICAL") { + m_direction = VERTICAL; + } else { + any.verify(false, "fovDirection must be \"HORIZONTAL\" or \"VERTICAL\""); + } + } else if (k == "COORDINATEFRAME") { + m_cframe = it->value; + } else if (k == "FOVDEGREES") { + m_fieldOfView = toRadians(it->value.number()); + } else if (k == "NEARPLANEZ") { + m_nearPlaneZ = it->value; + } else if (k == "FARPLANEZ") { + m_farPlaneZ = it->value; + } else { + any.verify(false, std::string("Illegal key in table: ") + it->key); + } + ++it; + } +} + + +GCamera::operator Any() const { + Any any(Any::TABLE, "GCamera"); + + any.set("fovDirection", std::string((m_direction == HORIZONTAL) ? "HORIZONTAL" : "VERTICAL")); + any.set("fovDegrees", toDegrees(m_fieldOfView)); + any.set("nearPlaneZ", nearPlaneZ()); + any.set("farPlaneZ", farPlaneZ()); + any.set("coordinateFrame", coordinateFrame()); + + return any; +} + + +GCamera::GCamera() { + setNearPlaneZ(-0.2f); + setFarPlaneZ(-100.0f); + setFieldOfView((float)toRadians(90.0f), HORIZONTAL); +} + + +GCamera::GCamera(const Matrix4& proj, const CFrame& frame) { + float left, right, bottom, top, nearval, farval; + proj.getPerspectiveProjectionParameters(left, right, bottom, top, nearval, farval); + setNearPlaneZ(-nearval); + setFarPlaneZ(-farval); + float x = right; + + // Assume horizontal field of view + setFieldOfView(atan2(x, -m_nearPlaneZ) * 2.0f, HORIZONTAL); + setCoordinateFrame(frame); +} + + +GCamera::~GCamera() { +} + + +void GCamera::getCoordinateFrame(CoordinateFrame& c) const { + c = m_cframe; +} + + +void GCamera::setCoordinateFrame(const CoordinateFrame& c) { + m_cframe = c; +} + + +void GCamera::setFieldOfView(float angle, FOVDirection dir) { + debugAssert((angle < pi()) && (angle > 0)); + + m_fieldOfView = angle; + m_direction = dir; +} + + +float GCamera::imagePlaneDepth() const{ + return -m_nearPlaneZ; +} + +float GCamera::viewportWidth(const Rect2D& viewport) const { + // Compute the side of a square at the near plane based on our field of view + float s = 2.0f * -m_nearPlaneZ * tan(m_fieldOfView * 0.5f); + + if (m_direction == VERTICAL) { + s *= viewport.width() / viewport.height(); + } + + return s; +} + + +float GCamera::viewportHeight(const Rect2D& viewport) const { + // Compute the side of a square at the near plane based on our field of view + float s = 2.0f * -m_nearPlaneZ * tan(m_fieldOfView * 0.5f); + + debugAssert(m_fieldOfView < toRadians(180)); + if (m_direction == HORIZONTAL) { + s *= viewport.height() / viewport.width(); + } + + return s; +} + + +Ray GCamera::worldRay(float x, float y, const Rect2D& viewport) const { + + int screenWidth = iFloor(viewport.width()); + int screenHeight = iFloor(viewport.height()); + + Vector3 origin = m_cframe.translation; + + float cx = screenWidth / 2.0f; + float cy = screenHeight / 2.0f; + + float vw = viewportWidth(viewport); + float vh = viewportHeight(viewport); + + Vector3 direction = Vector3( (x - cx) * vw / screenWidth, + -(y - cy) * vh / screenHeight, + m_nearPlaneZ); + + direction = m_cframe.vectorToWorldSpace(direction); + + // Normalize the direction (we didn't do it before) + direction = direction.direction(); + + return Ray::fromOriginAndDirection(origin, direction); +} + + +void GCamera::getProjectPixelMatrix(const Rect2D& viewport, Matrix4& P) const { + getProjectUnitMatrix(viewport, P); + float screenWidth = viewport.width(); + float screenHeight = viewport.height(); + + float sx = screenWidth / 2.0; + float sy = screenHeight / 2.0; + + P = Matrix4(sx, 0, 0, sx + viewport.x0(), + 0, -sy, 0, sy + viewport.y0(), + 0, 0, 1, 0, + 0, 0, 0, 1) * P; +} + + +void GCamera::getProjectUnitMatrix(const Rect2D& viewport, Matrix4& P) const { + + float screenWidth = viewport.width(); + float screenHeight = viewport.height(); + + float r, l, t, b, n, f, x, y; + + if (m_direction == VERTICAL) { + y = -m_nearPlaneZ * tan(m_fieldOfView / 2); + x = y * (screenWidth / screenHeight); + } else { //m_direction == HORIZONTAL + x = -m_nearPlaneZ * tan(m_fieldOfView / 2); + y = x * (screenHeight / screenWidth); + } + + n = -m_nearPlaneZ; + f = -m_farPlaneZ; + r = x; + l = -x; + t = y; + b = -y; + + P = Matrix4::perspectiveProjection(l, r, b, t, n, f); +} + +Vector3 GCamera::projectUnit(const Vector3& point, const Rect2D& viewport) const { + Matrix4 M; + getProjectUnitMatrix(viewport, M); + + Vector4 cameraSpacePoint(coordinateFrame().pointToObjectSpace(point), 1.0f); + const Vector4& screenSpacePoint = M * cameraSpacePoint; + + return Vector3(screenSpacePoint.xyz() / screenSpacePoint.w); +} + +Vector3 GCamera::project(const Vector3& point, + const Rect2D& viewport) const { + + // Find the point in the homogeneous cube + const Vector3& cube = projectUnit(point, viewport); + + return convertFromUnitToNormal(cube, viewport); +} + +Vector3 GCamera::unprojectUnit(const Vector3& v, const Rect2D& viewport) const { + + const Vector3& projectedPoint = convertFromUnitToNormal(v, viewport); + + return unproject(projectedPoint, viewport); +} + + +Vector3 GCamera::unproject(const Vector3& v, const Rect2D& viewport) const { + + const float n = m_nearPlaneZ; + const float f = m_farPlaneZ; + + float z; + + if (-f >= finf()) { + // Infinite far plane + z = 1.0f / (((-1.0f / n) * v.z) + 1.0f / n); + } else { + z = 1.0f / ((((1.0f / f) - (1.0f / n)) * v.z) + 1.0f / n); + } + + const Ray& ray = worldRay(v.x, v.y, viewport); + + // Find out where the ray reaches the specified depth. + const Vector3& out = ray.origin() + ray.direction() * -z / (ray.direction().dot(m_cframe.lookVector())); + + return out; +} + + +float GCamera::worldToScreenSpaceArea(float area, float z, const Rect2D& viewport) const { + (void)viewport; + if (z >= 0) { + return finf(); + } + return area * (float)square(imagePlaneDepth() / z); +} + + +void GCamera::getClipPlanes( + const Rect2D& viewport, + Array<Plane>& clip) const { + + Frustum fr; + frustum(viewport, fr); + clip.resize(fr.faceArray.size(), DONT_SHRINK_UNDERLYING_ARRAY); + for (int f = 0; f < clip.size(); ++f) { + clip[f] = fr.faceArray[f].plane; + } +} + + +GCamera::Frustum GCamera::frustum(const Rect2D& viewport) const { + Frustum f; + frustum(viewport, f); + return f; +} + + +void GCamera::frustum(const Rect2D& viewport, Frustum& fr) const { + + // The volume is the convex hull of the vertices definining the view + // frustum and the light source point at infinity. + + const float x = viewportWidth(viewport) / 2; + const float y = viewportHeight(viewport) / 2; + const float zn = m_nearPlaneZ; + const float zf = m_farPlaneZ; + float xx, zz, yy; + + float halfFOV = m_fieldOfView * 0.5f; + + // This computes the normal, which is based on the complement of the + // halfFOV angle, so the equations are "backwards" + if (m_direction == VERTICAL) { + yy = -cosf(halfFOV); + xx = yy * viewport.height() / viewport.width(); + zz = -sinf(halfFOV); + } else { + xx = -cosf(halfFOV); + yy = xx * viewport.width() / viewport.height(); + zz = -sinf(halfFOV); + } + + // Near face (ccw from UR) + fr.vertexPos.append( + Vector4( x, y, zn, 1), + Vector4(-x, y, zn, 1), + Vector4(-x, -y, zn, 1), + Vector4( x, -y, zn, 1)); + + // Far face (ccw from UR, from origin) + if (m_farPlaneZ == -finf()) { + fr.vertexPos.append(Vector4( x, y, zn, 0), + Vector4(-x, y, zn, 0), + Vector4(-x, -y, zn, 0), + Vector4( x, -y, zn, 0)); + } else { + // Finite + const float s = zf / zn; + fr.vertexPos.append(Vector4( x * s, y * s, zf, 1), + Vector4(-x * s, y * s, zf, 1), + Vector4(-x * s, -y * s, zf, 1), + Vector4( x * s, -y * s, zf, 1)); + } + + Frustum::Face face; + + // Near plane (wind backwards so normal faces into frustum) + // Recall that nearPlane, farPlane are positive numbers, so + // we need to negate them to produce actual z values. + face.plane = Plane(Vector3(0,0,-1), Vector3(0,0,m_nearPlaneZ)); + face.vertexIndex[0] = 3; + face.vertexIndex[1] = 2; + face.vertexIndex[2] = 1; + face.vertexIndex[3] = 0; + fr.faceArray.append(face); + + // Right plane + face.plane = Plane(Vector3(xx, 0, zz), Vector3::zero()); + face.vertexIndex[0] = 0; + face.vertexIndex[1] = 4; + face.vertexIndex[2] = 7; + face.vertexIndex[3] = 3; + fr.faceArray.append(face); + + // Left plane + face.plane = Plane(Vector3(-fr.faceArray.last().plane.normal().x, 0, fr.faceArray.last().plane.normal().z), Vector3::zero()); + face.vertexIndex[0] = 5; + face.vertexIndex[1] = 1; + face.vertexIndex[2] = 2; + face.vertexIndex[3] = 6; + fr.faceArray.append(face); + + // Top plane + face.plane = Plane(Vector3(0, yy, zz), Vector3::zero()); + face.vertexIndex[0] = 1; + face.vertexIndex[1] = 5; + face.vertexIndex[2] = 4; + face.vertexIndex[3] = 0; + fr.faceArray.append(face); + + // Bottom plane + face.plane = Plane(Vector3(0, -fr.faceArray.last().plane.normal().y, fr.faceArray.last().plane.normal().z), Vector3::zero()); + face.vertexIndex[0] = 2; + face.vertexIndex[1] = 3; + face.vertexIndex[2] = 7; + face.vertexIndex[3] = 6; + fr.faceArray.append(face); + + // Far plane + if (-m_farPlaneZ < finf()) { + face.plane = Plane(Vector3(0, 0, 1), Vector3(0, 0, m_farPlaneZ)); + face.vertexIndex[0] = 4; + face.vertexIndex[1] = 5; + face.vertexIndex[2] = 6; + face.vertexIndex[3] = 7; + fr.faceArray.append(face); + } + + // Transform vertices to world space + for (int v = 0; v < fr.vertexPos.size(); ++v) { + fr.vertexPos[v] = m_cframe.toWorldSpace(fr.vertexPos[v]); + } + + // Transform planes to world space + for (int p = 0; p < fr.faceArray.size(); ++p) { + // Since there is no scale factor, we don't have to + // worry about the inverse transpose of the normal. + Vector3 normal; + float d; + + fr.faceArray[p].plane.getEquation(normal, d); + + Vector3 newNormal = m_cframe.rotation * normal; + + if (isFinite(d)) { + d = (newNormal * -d + m_cframe.translation).dot(newNormal); + fr.faceArray[p].plane = Plane(newNormal, newNormal * d); + } else { + // When d is infinite, we can't multiply 0's by it without + // generating NaNs. + fr.faceArray[p].plane = Plane::fromEquation(newNormal.x, newNormal.y, newNormal.z, d); + } + } +} + +void GCamera::getNearViewportCorners +(const Rect2D& viewport, + Vector3& outUR, + Vector3& outUL, + Vector3& outLL, + Vector3& outLR) const { + + // Must be kept in sync with getFrustum() + const float w = viewportWidth(viewport) / 2.0f; + const float h = viewportHeight(viewport) / 2.0f; + const float z = nearPlaneZ(); + + // Compute the points + outUR = Vector3( w, h, z); + outUL = Vector3(-w, h, z); + outLL = Vector3(-w, -h, z); + outLR = Vector3( w, -h, z); + + // Take to world space + outUR = m_cframe.pointToWorldSpace(outUR); + outUL = m_cframe.pointToWorldSpace(outUL); + outLR = m_cframe.pointToWorldSpace(outLR); + outLL = m_cframe.pointToWorldSpace(outLL); +} + +void GCamera::getFarViewportCorners( + const Rect2D& viewport, + Vector3& outUR, + Vector3& outUL, + Vector3& outLL, + Vector3& outLR) const { + + // Must be kept in sync with getFrustum() + const float w = viewportWidth(viewport) * m_farPlaneZ / m_nearPlaneZ; + const float h = viewportHeight(viewport) * m_farPlaneZ / m_nearPlaneZ; + const float z = m_farPlaneZ; + + // Compute the points + outUR = Vector3( w/2, h/2, z); + outUL = Vector3(-w/2, h/2, z); + outLL = Vector3(-w/2, -h/2, z); + outLR = Vector3( w/2, -h/2, z); + + // Take to world space + outUR = m_cframe.pointToWorldSpace(outUR); + outUL = m_cframe.pointToWorldSpace(outUL); + outLR = m_cframe.pointToWorldSpace(outLR); + outLL = m_cframe.pointToWorldSpace(outLL); +} + + + +void GCamera::setPosition(const Vector3& t) { + m_cframe.translation = t; +} + + +void GCamera::lookAt(const Vector3& position, const Vector3& up) { + m_cframe.lookAt(position, up); +} + + +void GCamera::serialize(BinaryOutput& bo) const { + bo.writeFloat32(m_fieldOfView); + bo.writeFloat32(imagePlaneDepth()); + debugAssert(nearPlaneZ() < 0.0f); + bo.writeFloat32(nearPlaneZ()); + debugAssert(farPlaneZ() < 0.0f); + bo.writeFloat32(farPlaneZ()); + m_cframe.serialize(bo); + bo.writeInt8(m_direction); +} + + +void GCamera::deserialize(BinaryInput& bi) { + m_fieldOfView = bi.readFloat32(); + m_nearPlaneZ = bi.readFloat32(); + debugAssert(m_nearPlaneZ < 0.0f); + m_farPlaneZ = bi.readFloat32(); + debugAssert(m_farPlaneZ < 0.0f); + m_cframe.deserialize(bi); + m_direction = (FOVDirection)bi.readInt8(); +} + + +Vector3 GCamera::convertFromUnitToNormal(const Vector3& in, const Rect2D& viewport) const{ + return (in + Vector3(1,1,1)) * 0.5 * Vector3(viewport.width(), -viewport.height(), 1) + + Vector3(viewport.x0(), viewport.y1(), 0); +} +} // namespace diff --git a/dep/src/g3dlite/GImage.cpp b/dep/src/g3dlite/GImage.cpp new file mode 100644 index 00000000000..9527e96cf67 --- /dev/null +++ b/dep/src/g3dlite/GImage.cpp @@ -0,0 +1,1166 @@ +/** + \file GImage.cpp + \author Morgan McGuire, http://graphics.cs.williams.edu + Copyright 2002-2010, Morgan McGuire + + \created 2002-05-27 + \edited 2010-01-04 + */ +#include "G3D/platform.h" +#include "G3D/GImage.h" +#include "G3D/debug.h" +#include "G3D/stringutils.h" +#include "G3D/TextInput.h" +#include "G3D/TextOutput.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Log.h" +#include "G3D/fileutils.h" + +#ifdef G3D_LINUX +# include <png.h> +#else +# include "png.h" +#endif + +#include <sys/stat.h> +#include <assert.h> +#include <sys/types.h> + +////////////////////////////////////////////////////////////////////////////////////////////// + +namespace G3D { + +void GImage::LtoRGBA( + const uint8* in, + uint8* out, + int numPixels) { + + for (int i = 0; i < numPixels; ++i) { + int v = in[i]; + int i4 = i * 4; + + out[i4 + 0] = v; + out[i4 + 1] = v; + out[i4 + 2] = v; + out[i4 + 3] = 255; + } +} + + +void GImage::LtoRGB( + const uint8* in, + uint8* out, + int numPixels) { + + for (int i = 0; i < numPixels; ++i) { + int v = in[i]; + int i3 = i * 3; + + out[i3 + 0] = v; + out[i3 + 1] = v; + out[i3 + 2] = v; + } +} + + +void GImage::RGBtoRGBA( + const uint8* in, + uint8* out, + int numPixels) { + + for (int i = 0; i < numPixels; ++i) { + int i3 = i * 3; + int i4 = i3 + i; + + out[i4 + 0] = in[i3 + 0]; + out[i4 + 1] = in[i3 + 1]; + out[i4 + 2] = in[i3 + 2]; + out[i4 + 3] = 255; + } +} + + +void GImage::RGBAtoRGB( + const uint8* in, + uint8* out, + int numPixels) { + + for (int i = 0; i < numPixels; ++i) { + int i3 = i * 3; + int i4 = i3 + i; + + out[i3 + 0] = in[i4 + 0]; + out[i3 + 1] = in[i4 + 1]; + out[i3 + 2] = in[i4 + 2]; + } +} + + +void GImage::RGBtoBGRA( + const uint8* in, + uint8* out, + int numPixels) { + + for (int i = 0; i < numPixels; ++i) { + int i3 = i * 3; + int i4 = i3 + i; + + out[i4 + 2] = in[i3 + 0]; + out[i4 + 1] = in[i3 + 1]; + out[i4 + 0] = in[i3 + 2]; + out[i4 + 3] = 255; + } +} + + + +void GImage::RGBtoBGR( + const uint8* in, + uint8* out, + int numPixels) { + + for (int i = 0; i < numPixels; ++i) { + int i3 = i * 3; + + int r = in[i3 + 0]; + int g = in[i3 + 1]; + int b = in[i3 + 2]; + + out[i3 + 2] = r; + out[i3 + 1] = g; + out[i3 + 0] = b; + } +} + + +void GImage::RGBxRGBtoRGBA( + const uint8* colorRGB, + const uint8* alphaRGB, + uint8* out, + int numPixels) { + + for (int i = numPixels - 1; i >= 0; --i) { + int i3 = i * 3; + int i4 = i3 + i; + + out[i4 + 0] = colorRGB[i3 + 0]; + out[i4 + 1] = colorRGB[i3 + 1]; + out[i4 + 2] = colorRGB[i3 + 2]; + out[i4 + 3] = alphaRGB[i3 + 0]; + } +} + + +void GImage::RGBtoARGB( + const uint8* in, + uint8* out, + int numPixels) { + + for (int i = 0; i < numPixels; ++i) { + int i3 = i * 3; + int i4 = i3 + i; + + out[i4 + 0] = 255; + out[i4 + 1] = in[i3 + 0]; + out[i4 + 2] = in[i3 + 1]; + out[i4 + 3] = in[i3 + 2]; + } +} + + +void GImage::flipRGBVertical( + const uint8* in, + uint8* out, + int width, + int height) { + + + // Allocate a temp row so the operation + // is still safe if in == out + uint8* temp = (uint8*)System::malloc(width * 3); + alwaysAssertM(temp != NULL, "Out of memory"); + + int oneRow = width * 3; + int N = height / 2; + + // if height is an odd value, don't swap odd middle row + for (int i = 0; i < N; ++i) { + int topOff = i * oneRow; + int botOff = (height - i - 1) * oneRow; + System::memcpy(temp, in + topOff, oneRow); + System::memcpy(out + topOff, in + botOff, oneRow); + System::memcpy(out + botOff, temp, oneRow); + } + + System::free(temp); +} + + +void GImage::flipRGBAVertical( + const uint8* in, + uint8* out, + int width, + int height) { + + + // Allocate a temp row so the operation + // is still safe if in == out + uint8* temp = (uint8*)System::malloc(width * 4); + alwaysAssertM(temp != NULL, "Out of memory"); + + int oneRow = width * 4; + + // if height is an odd value, don't swap odd middle row + for (int i = 0; i < height / 2; ++i) { + int topOff = i * oneRow; + int botOff = (height - i - 1) * oneRow; + System::memcpy(temp, in + topOff, oneRow); + System::memcpy(out + topOff, in + botOff, oneRow); + System::memcpy(out + botOff, temp, oneRow); + } + + System::free(temp); +} + +//////////////////////////////////////////////////////////////////////////////////////// + +void GImage::decode( + BinaryInput& input, + Format format) { + + switch (format) { + case PPM_ASCII: + decodePPMASCII(input); + break; + + case PPM_BINARY: + decodePPM(input); + break; + + case PNG: + decodePNG(input); + break; + + case JPEG: + decodeJPEG(input); + break; + + case TGA: + decodeTGA(input); + break; + + case BMP: + decodeBMP(input); + break; + + case ICO: + decodeICO(input); + break; + + case PCX: + decodePCX(input); + break; + + default: + debugAssert(false); + } + + debugAssert(m_width >= 0); + debugAssert(m_height >= 0); + debugAssert(m_channels == 1 || m_channels == 3 || m_channels == 4); + debugAssert(m_byte != NULL); +} + + +void GImage::decodePCX( + BinaryInput& input) { + + uint8 manufacturer = input.readUInt8(); + uint8 version = input.readUInt8(); + uint8 encoding = input.readUInt8(); + uint8 bitsPerPixel = input.readUInt8(); + + uint16 xmin = input.readUInt16(); + uint16 ymin = input.readUInt16(); + uint16 xmax = input.readUInt16(); + uint16 ymax = input.readUInt16(); + + uint16 horizDPI = input.readUInt16(); + uint16 vertDPI = input.readUInt16(); + + Color3uint8 colorMap[16]; + input.readBytes(colorMap, 48); + + input.skip(1); + + uint8 planes = input.readUInt8(); + uint16 bytesPerLine = input.readUInt16(); + uint16 paletteType = input.readUInt16(); + input.skip(4 + 54); + + (void)bytesPerLine; + + m_width = xmax - xmin + 1; + m_height = ymax - ymin + 1; + m_channels = 3; + + if ((manufacturer != 0x0A) || (encoding != 0x01)) { + throw GImage::Error("PCX file is corrupted", input.getFilename()); + } + + (void)version; + (void)vertDPI; + (void)horizDPI; + + if ((bitsPerPixel != 8) || ((planes != 1) && (planes != 3))) { + throw GImage::Error("Only 8-bit paletted and 24-bit PCX files supported.", input.getFilename()); + } + + // Prepare the pointer object for the pixel data + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * 3); + + if ((paletteType == 1) && (planes == 3)) { + + Color3uint8* pixel = pixel3(); + + // Iterate over each scan line + for (int row = 0; row < m_height; ++row) { + // Read each scan line once per plane + for (int plane = 0; plane < planes; ++plane) { + int p = row * m_width; + int p1 = p + m_width; + while (p < p1) { + uint8 value = input.readUInt8(); + int length = 1; + + if (value >= 192) { + // This is the length, not the value. Mask off + // the two high bits and read the true index. + length = value & 0x3F; + value = input.readUInt8(); + } + + // Set the whole run + for (int i = length - 1; i >= 0; --i, ++p) { + debugAssert(p < m_width * m_height); + pixel[p][plane] = value; + } + } + } + } + + } else if (planes == 1) { + + Color3uint8 palette[256]; + + int imageBeginning = input.getPosition(); + int paletteBeginning = input.getLength() - 769; + + input.setPosition(paletteBeginning); + + uint8 dummy = input.readUInt8(); + + if (dummy != 12) { + Log::common()->println("\n*********************"); + Log::common()->printf("Warning: Corrupted PCX file (palette marker byte was missing) \"%s\"\nLoading anyway\n\n", input.getFilename().c_str()); + } + + input.readBytes(palette, sizeof(palette)); + input.setPosition(imageBeginning); + + Color3uint8* pixel = pixel3(); + + // The palette indices are run length encoded. + int p = 0; + while (p < m_width * m_height) { + uint8 index = input.readUInt8(); + uint8 length = 1; + + if (index >= 192) { + // This is the length, not the index. Mask off + // the two high bits and read the true index. + length = index & 0x3F; + index = input.readUInt8(); + } + + Color3uint8 color = palette[index]; + + // Set the whole run + for (int i = length - 1; i >= 0; --i, ++p) { + if (p > m_width * m_height) { + break; + } + pixel[p] = color; + } + + } + + } else { + throw GImage::Error("Unsupported PCX file type.", input.getFilename()); + } +} + + +GImage::Format GImage::resolveFormat(const std::string& filename) { + BinaryInput b(filename, G3D_LITTLE_ENDIAN); + if (b.size() <= 0) { + throw Error("File not found.", filename); + } + + return resolveFormat(filename, b.getCArray(), b.size(), AUTODETECT); +} + + +GImage::Format GImage::resolveFormat( + const std::string& filename, + const uint8* data, + int dataLen, + Format maybeFormat) { + + // Return the provided format if it is specified. + if (maybeFormat != AUTODETECT) { + return maybeFormat; + } + + std::string extension = toUpper(filenameExt(filename)); + + if ((extension == "PPM") || (extension == "PGM") || (extension == "PBM")) { + // There are two PPM formats (binary and ASCII); we handle them differently + if (dataLen > 3) { + if (!memcmp(data, "P6", 2) || !memcmp(data, "P5", 2)) { + return PPM_BINARY; + } else { + return PPM_ASCII; + } + } + } + + Format tmp = stringToFormat(extension); + if ((tmp != AUTODETECT) && (tmp != UNKNOWN)) { + return tmp; + } + + // Try and autodetect from the file itself by looking at the first + // character. + + // We can't look at the character if it is null. + debugAssert(data != NULL); + + if ((dataLen > 3) && (! memcmp(data, "P3", 2) || (! memcmp(data, "P2", 2)) || (! memcmp(data, "P1", 2)))) { + return PPM_ASCII; + } + + if ((dataLen > 3) && (!memcmp(data, "P6", 2) ||!memcmp(data, "P5", 2))) { + return PPM_BINARY; + } + + if (dataLen > 8) { + if (!png_sig_cmp((png_bytep)data, 0, 8)) { + return PNG; + } + } + + if ((dataLen > 0) && (data[0] == 'B')) { + return BMP; + } + + if (dataLen > 10) { + if ((dataLen > 11) && (data[0] == 0xFF) && + (memcmp(&data[6], "JFIF", 4) == 0)) { + return JPEG; + } + } + + if (dataLen > 40) { + if (memcmp(&data[dataLen - 18], "TRUEVISION-XFILE", 16) == 0) { + return TGA; + } + } + + if ((dataLen > 4) && (data[0] == 0) && (data[1] == 0) && (data[2] == 0) && (data[3] == 1)) { + return ICO; + } + + if ((dataLen > 0) && (data[0] == 10)) { + return PCX; + } + + return UNKNOWN; +} + + +GImage::GImage( + const std::string& filename, + Format format, + const MemoryManager::Ref& m) : + m_memMan(m), + m_byte(NULL), + m_channels(0), + m_width(0), + m_height(0) { + + load(filename, format); +} + + +void GImage::load( + const std::string& filename, + Format format) { + + clear(); + + try { + BinaryInput b(filename, G3D_LITTLE_ENDIAN); + if (b.size() <= 0) { + throw Error("File not found.", filename); + } + + alwaysAssertM(this != NULL, "Corrupt GImage"); + decode(b, resolveFormat(filename, b.getCArray(), b.size(), format)); + } catch (const std::string& error) { + throw Error(error, filename); + } +} + + +GImage::GImage( + const uint8* data, + int length, + Format format, + const MemoryManager::Ref& m) : + m_memMan(m), + m_byte(NULL), + m_channels(0), + m_width(0), + m_height(0) { + + BinaryInput b(data, length, G3D_LITTLE_ENDIAN); + // It is safe to cast away the const because we + // know we don't corrupt the data. + + decode(b, resolveFormat("", data, length, format)); +} + + +GImage::GImage( + int width, + int height, + int channels, + const MemoryManager::Ref& mem) : + m_memMan(mem), + m_byte(0), + m_channels(0), + m_width(0), + m_height(0) { + + resize(width, height, channels); +} + + +void GImage::resize( + int width, + int height, + int channels, + bool zero) { + + debugAssert(width >= 0); + debugAssert(height >= 0); + debugAssert(channels >= 1); + + clear(); + + m_width = width; + m_height = height; + m_channels = channels; + size_t sz = width * height * channels; + + if (sz > 0) { + m_byte = (uint8*)m_memMan->alloc(sz); + if (zero) { + System::memset(m_byte, 0, sz); + } + debugAssert(isValidHeapPointer(m_byte)); + } +} + + +void GImage::_copy( + const GImage& other) { + + clear(); + + m_width = other.m_width; + m_height = other.m_height; + m_channels = other.m_channels; + int s = m_width * m_height * m_channels * sizeof(uint8); + m_byte = (uint8*)m_memMan->alloc(s); + debugAssert(isValidHeapPointer(m_byte)); + memcpy(m_byte, other.m_byte, s); +} + + +void GImage::flipHorizontal() { + uint8 temp[4]; + int rowBytes = m_width * m_channels; + for (int y = 0; y < m_height; ++y) { + uint8* row = m_byte + y * rowBytes; + for (int x = 0; x < m_width / 2; ++x) { + System::memcpy(temp, row + x * m_channels, m_channels); + System::memcpy(row + x * m_channels, row + (m_width - x - 1) * m_channels, m_channels); + System::memcpy(row + (m_width - x - 1) * m_channels, temp, m_channels); + } + } +} + + +void GImage::flipVertical() { + uint8* old = m_byte; + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * m_channels); + + // We could do this with only a single-row temp buffer, but then + // we'd have to copy twice as much data. + int rowBytes = m_width * m_channels; + for (int y = 0; y < m_height; ++y) { + System::memcpy(m_byte + y * rowBytes, old + (m_height - y - 1) * rowBytes, rowBytes); + } + + m_memMan->free(old); +} + + +void GImage::rotate90CW(int numTimes) { + + uint8* old = NULL; + numTimes = iWrap(numTimes, 4); + if (numTimes > 0) { + (uint8*)m_memMan->alloc(m_width * m_height * m_channels); + } + for (int j = 0; j < numTimes; ++j) { + { + uint8* temp = old; + uint8* old = m_byte; + m_byte = temp; + } + + { + int temp = m_width; + m_width = m_height; + m_height = temp; + } + + int rowBytes = m_width * m_channels; + for (int y = 0; y < m_height; ++y) { + for (int x = 0; x < m_width; ++x) { + uint8* dst = m_byte + x + y * rowBytes; + uint8* src = old + y + (m_height - x - 1) * rowBytes; + System::memcpy(dst, src, m_channels); + } + } + } + m_memMan->free(old); +} + + + +GImage::GImage( + const GImage& other, + const MemoryManager::Ref& m) : m_memMan(m), m_byte(NULL) { + + _copy(other); +} + + +GImage::~GImage() { + clear(); +} + + +void GImage::clear() { + m_width = 0; + m_height = 0; + m_memMan->free(m_byte); + m_byte = NULL; +} + + +GImage& GImage::operator=(const GImage& other) { + _copy(other); + return *this; +} + + +bool GImage::copySubImage( + GImage & dest, const GImage & src, + int srcX, int srcY, int srcWidth, int srcHeight) { + if ((src.m_width < srcX + srcWidth) || + (src.m_height < srcY + srcHeight) || + (srcY < 0) || + (srcX < 0)) { + + return false; + } + + dest.resize(srcWidth, srcHeight, src.m_channels); + + bool ret; + ret = pasteSubImage(dest, src, 0, 0, srcX, srcY, srcWidth, srcHeight); + debugAssert(ret); + + return true; +} + + +bool GImage::pasteSubImage( + GImage & dest, const GImage & src, + int destX, int destY, + int srcX, int srcY, int srcWidth, int srcHeight) { + + if ((src.m_width < srcX + srcWidth) || + (src.m_height < srcY + srcHeight) || + (dest.m_width < destX + srcWidth) || + (dest.m_height < destY + srcHeight) || + (srcY < 0) || + (srcX < 0) || + (destY < 0) || + (destX < 0) || + (src.channels() != dest.channels())) { + + return false; + } + + for (int i = 0; i < srcHeight; i++) { + const uint8* srcRow = src.byte() + + ((i + srcY) * src.m_width + srcX) * src.channels(); + uint8* destRow = dest.byte() + + ((i + destY) * dest.width() + destX) * dest.channels(); + memcpy(destRow, srcRow, srcWidth * src.m_channels); + } + + return true; +} + + +bool GImage::supportedFormat( + const std::string& format) { + + return (stringToFormat(format) != UNKNOWN); +} + + +GImage::Format GImage::stringToFormat( + const std::string& format) { + + std::string extension = toUpper(format); + + if ((extension == "JPG") || (extension == "JPEG")) { + return JPEG; + } else if (extension == "TGA") { + return TGA; + } else if (extension == "BMP") { + return BMP; + } else if (extension == "PCX") { + return PCX; + } else if (extension == "ICO") { + return ICO; + } else if (extension == "PNG") { + return PNG; + } else { + return UNKNOWN; + } + // Don't put PPM here, since it has two versions +} + + +void GImage::save( + const std::string& filename, + Format format) const { + + BinaryOutput b(filename, G3D_LITTLE_ENDIAN); + encode(resolveFormat(filename, NULL, 0, format), b); + b.commit(false); +} + + +void GImage::encode( + Format format, + uint8*& outData, + int& outLength) const { + + BinaryOutput out; + + encode(format, out); + + outData = (uint8*)System::malloc(out.size()); + debugAssert(outData); + outLength = out.size(); + + out.commit(outData); +} + + +void GImage::encode( + Format format, + BinaryOutput& out) const { + + switch (format) { + case PPM_ASCII: + encodePPMASCII(out); + break; + + case PPM_BINARY: + encodePPM(out); + break; + + case PNG: + encodePNG(out); + break; + + case JPEG: + encodeJPEG(out); + break; + + case BMP: + encodeBMP(out); + break; + + case TGA: + encodeTGA(out); + break; + + default: + debugAssert(false); + } +} + + +void GImage::insertRedAsAlpha(const GImage& alpha, GImage& output) const { + debugAssert(alpha.width() == width()); + debugAssert(alpha.height() == height()); + + // make sure output GImage is valid + if (output.width() != width() || output.height() != height() || output.channels() != 4) { + output.resize(width(), height(), 4); + } + + int N = m_width * m_height; + for (int i = 0; i < N; ++i) { + output.byte()[i * 4 + 0] = byte()[i * m_channels + 0]; + output.byte()[i * 4 + 1] = byte()[i * m_channels + 1]; + output.byte()[i * 4 + 2] = byte()[i * m_channels + 2]; + output.byte()[i * 4 + 3] = alpha.byte()[i * alpha.m_channels]; + } +} + + +void GImage::stripAlpha(GImage& output) const { + + if (output.m_width != m_width || output.m_height != m_height || output.m_channels != 3) { + output.resize(m_width, m_height, 3); + } + + int N = m_width * m_height; + for (int i = 0; i < N; ++i) { + output.byte()[i * 3 + 0] = byte()[i * m_channels + 0]; + output.byte()[i * 3 + 1] = byte()[i * m_channels + 1]; + output.byte()[i * 3 + 2] = byte()[i * m_channels + 2]; + } +} + + +int GImage::sizeInMemory() const { + return sizeof(GImage) + m_width * m_height * m_channels; +} + + +void GImage::computeNormalMap( + const GImage& bump, + GImage& normal, + const BumpMapPreprocess& preprocess) { + computeNormalMap(bump.m_width, bump.m_height, bump.m_channels, + bump.byte(), normal, preprocess); +} + +void GImage::computeNormalMap( + int width, + int height, + int channels, + const uint8* src, + GImage& normal, + const BumpMapPreprocess& preprocess) { + + float whiteHeightInPixels = preprocess.zExtentPixels; + bool lowPassBump = preprocess.lowPassFilter; + bool scaleHeightByNz = preprocess.scaleZByNz; + + if (whiteHeightInPixels < 0.0f) { + // Default setting scales so that a gradient ramp + // over the whole image becomes a 45-degree angle + + // Account for potentially non-square aspect ratios + whiteHeightInPixels = max(width, height) * -whiteHeightInPixels; + } + + debugAssert(whiteHeightInPixels >= 0); + + const int w = width; + const int h = height; + const int stride = channels; + + normal.resize(w, h, 4); + + const uint8* const B = src; + Color4uint8* const N = normal.pixel4(); + + // 1/s for the scale factor that each ELEVATION should be multiplied by. + // We avoid actually multiplying by this and instead just divide it out of z. + float elevationInvScale = 255.0f / whiteHeightInPixels; + + for (int y = 0; y < h; ++y) { + for (int x = 0; x < w; ++x) { + // Index into normal map pixel + int i = x + y * w; + + // Index into bump map *byte* + int j = stride * i; + + Vector3 delta; + + // Get a value from B (with wrapping lookup) relative to (x, y) + // and divide by 255 + #define ELEVATION(DX, DY) ((int)B[(((DX + x + w) % w) + \ + ((DY + y + h) % h) * w) * stride]) + + + // Sobel filter to compute the normal. + // + // Y Filter (X filter is the transpose) + // [ -1 -2 -1 ] + // [ 0 0 0 ] + // [ 1 2 1 ] + + // Write the Y value directly into the x-component so we don't have + // to explicitly compute a cross product at the end. Does not + // go out of bounds because the above is computed mod (width, height) + delta.y = -( ELEVATION(-1, -1) * 1 + ELEVATION( 0, -1) * 2 + ELEVATION( 1, -1) * 1 + + -ELEVATION(-1, 1) * 1 + -ELEVATION( 0, 1) * 2 + -ELEVATION( 1, 1) * 1); + + delta.x = -(-ELEVATION(-1, -1) * 1 + ELEVATION( 1, -1) * 1 + + -ELEVATION(-1, 0) * 2 + ELEVATION( 1, 0) * 2 + + -ELEVATION(-1, 1) * 1 + ELEVATION( 1, 1) * 1); + + // The scale of each filter row is 4, the filter width is two pixels, + // and the "normal" range is 0-255. + delta.z = 4 * 2 * elevationInvScale; + + // Delta is now scaled in pixels; normalize + delta = delta.direction(); + + // Copy over the bump value into the alpha channel. + float H = B[j] / 255.0f; + + if (lowPassBump) { + H = (ELEVATION(-1, -1) + ELEVATION( 0, -1) + ELEVATION(1, -1) + + ELEVATION(-1, 0) + ELEVATION( 0, 0) + ELEVATION(1, 0) + + ELEVATION(-1, 1) + ELEVATION( 0, 1) + ELEVATION(1, 1)) / (255.0f * 9.0f); + } +# undef ELEVATION + + if (scaleHeightByNz) { + // delta.z can't possibly be negative, so we avoid actually + // computing the absolute value. + H *= delta.z; + } + + N[i].a = iRound(H * 255.0f); + + // Pack into byte range + delta = delta * 127.5f + Vector3(127.5f, 127.5f, 127.5f); + N[i].r = iClamp(iRound(delta.x), 0, 255); + N[i].g = iClamp(iRound(delta.y), 0, 255); + N[i].b = iClamp(iRound(delta.z), 0, 255); + } + } +} + + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +void GImage::convertToL8() { + switch (m_channels) { + case 1: + return; + + case 3: + { + // Average + Color3uint8* src = (Color3uint8*)m_byte; + m_byte = NULL; + resize(m_width, m_height, 1); + for (int i = m_width * m_height - 1; i >= 0; --i) { + const Color3uint8 s = src[i]; + uint8& d = m_byte[i]; + d = ((int)s.r + (int)s.g + (int)s.b) / 3; + } + m_memMan->free(src); + } + break; + + case 4: + { + // Average + Color4uint8* src = (Color4uint8*)m_byte; + m_byte = NULL; + resize(m_width, m_height, 1); + for (int i = m_width * m_height - 1; i >= 0; --i) { + const Color4uint8 s = src[i]; + uint8& d = m_byte[i]; + d = ((int)s.r + (int)s.g + (int)s.b) / 3; + } + m_memMan->free(src); + } + return; + + default: + alwaysAssertM(false, "Bad number of channels in input image"); + } +} + + +void GImage::convertToRGBA() { + switch (m_channels) { + case 1: + { + // Spread + uint8* old = m_byte; + m_byte = NULL; + resize(m_width, m_height, 4); + for (int i = m_width * m_height - 1; i >= 0; --i) { + const uint8 s = old[i]; + Color4uint8& d = ((Color4uint8*)m_byte)[i]; + d.r = d.g = d.b = s; + d.a = 255; + } + m_memMan->free(m_byte); + } + break; + + case 3: + { + // Add alpha + Color3uint8* old = (Color3uint8*)m_byte; + m_byte = NULL; + resize(m_width, m_height, 4); + for (int i = m_width * m_height - 1; i >= 0; --i) { + const Color3uint8 s = old[i]; + Color4uint8& d = ((Color4uint8*)m_byte)[i]; + d.r = s.r; + d.g = s.g; + d.b = s.b; + d.a = 255; + } + m_memMan->free(old); + } + break; + + case 4: + // Already RGBA + return; + + default: + alwaysAssertM(false, "Bad number of channels in input image"); + } +} + + +void GImage::convertToRGB() { + switch (m_channels) { + case 1: + { + // Spread + uint8* old = m_byte; + m_byte = NULL; + resize(m_width, m_height, 3); + for (int i = m_width * m_height - 1; i >= 0; --i) { + const uint8 s = old[i]; + Color3uint8& d = ((Color3uint8*)m_byte)[i]; + d.r = d.g = d.b = s; + } + m_memMan->free(old); + } + break; + + case 3: + return; + + case 4: + // Strip alpha + { + Color4uint8* old = (Color4uint8*)m_byte; + m_byte = NULL; + resize(m_width, m_height, 3); + for (int i = m_width * m_height - 1; i >= 0; --i) { + const Color4uint8 s = old[i]; + Color3uint8& d = ((Color3uint8*)m_byte)[i]; + d.r = s.r; + d.g = s.g; + d.b = s.b; + } + m_memMan->free(old); + } + break; + + default: + alwaysAssertM(false, "Bad number of channels in input image"); + } +} + + +void GImage::R8G8B8_to_Y8U8V8(int width, int height, const uint8* _in, uint8* _out) { + const Color3uint8* in = reinterpret_cast<const Color3uint8*>(_in); + Color3uint8* out = reinterpret_cast<Color3uint8*>(_out); + + Color3uint8 p; + for (int i = width * height - 1; i >= 0; --i) { + p.r = iClamp(iRound(in->r * 0.229 + in->g * 0.587 + in->b * 0.114), 0, 255); + p.g = iClamp(iRound(in->r * -0.147 + in->g * -0.289 + in->b * 0.436) + 127, 0, 255); + p.b = iClamp(iRound(in->r * 0.615 + in->g * -0.515 + in->b * -0.100) + 127, 0, 255); + *out = p; + ++in; + ++out; + } +} + + + +void GImage::Y8U8V8_to_R8G8B8(int width, int height, const uint8* _in, uint8* _out) { + const Color3uint8* in = reinterpret_cast<const Color3uint8*>(_in); + Color3uint8* out = reinterpret_cast<Color3uint8*>(_out); + + Color3uint8 p; + for (int i = width * height - 1; i >= 0; --i) { + p.r = iClamp(iRound(in->r * 1.0753 + (in->b - 127) * 1.2256), 0, 255); + p.g = iClamp(iRound(in->r * 1.0753 + (in->g - 127) * -0.3946 + (in->b - 127) * -0.4947), 0, 255); + p.b = iClamp(iRound(in->r * 1.0753 + (in->g - 127) * 2.0320 + (in->b - 127) * 0.0853), 0, 255); + *out = p; + ++in; + ++out; + } +} + + +void GImage::makeCheckerboard(GImage& im, int checkerSize, const Color4uint8& A, const Color4uint8& B) { + for (int y = 0; y < im.m_height; ++y) { + for (int x = 0; x < im.m_width; ++x) { + bool checker = isOdd((x / checkerSize) + (y / checkerSize)); + const Color4uint8& color = checker ? A : B; + for (int c = 0; c < im.m_channels; ++c) { + uint8* v = im.byte() + (x + y * im.m_width) * im.m_channels + c; + *v = color[c]; + } + } + } +} + +} + diff --git a/dep/src/g3dlite/GImage_bayer.cpp b/dep/src/g3dlite/GImage_bayer.cpp new file mode 100644 index 00000000000..3d08e8ade5f --- /dev/null +++ b/dep/src/g3dlite/GImage_bayer.cpp @@ -0,0 +1,298 @@ +/** + @file GImage_bayer.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2002-05-27 + @edited 2006-05-10 + */ +#include "G3D/platform.h" +#include "G3D/GImage.h" + +namespace G3D { + +void GImage::BAYER_G8B8_R8G8_to_Quarter_R8G8B8(int width, int height, const uint8* in, uint8* out) { + debugAssert(in != out); + + int halfHeight = height / 2; + int halfWidth = width / 2; + + int dst_off = 0; + for (int y = 0; y < halfHeight; ++y) { + for (int x = 0; x < halfWidth; ++x) { + // GBRG + int src_off = x*2 + y*2*width; + out[dst_off] = in[src_off+width]; // red + out[dst_off+1] = ((int)in[src_off] + (int)in[src_off+width+1])/2; // green + out[dst_off+2] = in[src_off+1]; // blue + + dst_off = dst_off + 3; + } + } +} + + +void GImage::Quarter_R8G8B8_to_BAYER_G8B8_R8G8(int inWidth, int inHeight, const uint8* in, uint8* out) { + // Undo quarter-size Bayer as best we can. This code isn't very efficient, but it + // also isn't used very frequently. + + debugAssert(out != in); + + int outWidth = 2 * inWidth; + int outHeight = 2 * inHeight; + + for (int y = 0; y < outHeight; ++y) { + for (int x = 0; x < outWidth; ++x) { + const Color3uint8* inp = ((const Color3uint8*)in) + ((x/2) + (y/2)* inWidth); + uint8* outp = out + x + y * outWidth; + + if (isEven(y)) { + // GB row + if (isEven(x)) { + // Green + *outp = inp->g; + } else { + // Blue + *outp = inp->b; + } + } else { + // RG row + if (isEven(x)) { + // Red + *outp = inp->r; + } else { + // Green + *outp = inp->g; + } + } + } + } +} + + +/** Applies a 5x5 filter to monochrome image I (wrapping at the boundaries) */ +static uint8 applyFilter( + const uint8* I, + int x, + int y, + int w, + int h, + const float filter[5][5]) { + + debugAssert(isEven(w)); + debugAssert(isEven(h)); + + float sum = 0.0f; + float denom = 0.0f; + + for (int dy = 0; dy < 5; ++dy) { + int offset = ((y + dy + h - 2) % h) * w; + + for (int dx = 0; dx < 5; ++dx) { + float f = filter[dy][dx]; + sum += f * I[((x + dx + w - 2) % w) + offset]; + denom += f; + } + } + + return (uint8)iClamp(iRound(sum / denom), 0, 255); +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +// +// Bayer conversions +// + +// There are two kinds of rows (GR and BG). +// In each row, there are two kinds of pixels (G/R, B/G). +// We express the four kinds of INPUT pixels as: +// GRG, GRG, BGB, BGG +// +// There are three kinds of OUTPUT pixels: R, G, B. +// Thus there are nominally 12 different I/O combinations, +// but several are impulses because needed output at that +// location *is* the input (e.g., G_GRG and G_BGG). +// +// The following 5x5 row-major filters are named as output_input. + +// Green +static const float G_GRR[5][5] = +{{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}, +{ 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, +{ -1.0f, 2.0f, 4.0f, 2.0f, -1.0f}, +{ 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, +{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}; + +static const float G_BGB[5][5] = +{{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}, +{ 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, +{ -1.0f, 2.0f, 4.0f, 2.0f, -1.0f}, +{ 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, +{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}; + +// Red +//(the caption in the paper is wrong for this case: +// "R row B column really means R row G column" +static const float R_GRG[5][5] = +{{ 0.0f, 0.0f, 0.5f, 0.0f, 0.0f}, +{ 0.0f, -1.0f, 0.0f, -1.0f, 0.0f}, +{ -1.0f, 4.0f, 5.0f, 4.0f, -1.0f}, +{ 0.0f, -1.0f, 0.0f, -1.0f, 0.0f}, +{ 0.0f, 0.0f, 0.5f, 0.0f, 0.0f}}; + +static const float R_BGG[5][5] = +{{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}, +{ 0.0f, -1.0f, 4.0f, -1.0f, 0.0f}, +{ 0.5f, 0.0f, 5.0f, 0.0f, 0.5f}, +{ 0.0f, -1.0f, 4.0f, -1.0f, 0.0f}, +{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}; + +static const float R_BGB[5][5] = +{{ 0.0f, 0.0f, -3.0f/2.0f, 0.0f, 0.0f}, +{ 0.0f, 2.0f, 0.0f, 2.0f, 0.0f}, +{-3.0f/2.0f, 0.0f, 6.0f, 0.0f, -3.0f/2.0f}, +{ 0.0f, 2.0f, 0.0f, 2.0f, 0.0f}, +{ 0.0f, 0.0f, -3.0f/2.0f, 0.0f, 0.0f}}; + + +// Blue +//(the caption in the paper is wrong for this case: +// "B row R column really means B row G column") +#define B_BGG R_GRG +#define B_GRG R_BGG +#define B_GRR R_BGB + + +void GImage::BAYER_R8G8_G8B8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out) { + debugAssert(in != _out); + + Color3uint8* out = (Color3uint8*)_out; + + for (int y = 0; y < h; ++y) { + + // Row beginning in the input array. + int offset = y * w; + + // RG row + for (int x = 0; x < w; ++x, ++out) { + // R pixel + { + out->r = in[x + offset]; + out->g = applyFilter(in, x, y, w, h, G_GRR); + out->b = applyFilter(in, x, y, w, h, B_GRR); + } + ++x; ++out; + + // G pixel + { + out->r = applyFilter(in, x, y, w, h, R_GRG); + out->g = in[x + offset]; + out->b = applyFilter(in, x, y, w, h, B_GRG); + } + } + + ++y; + offset += w; + + // GB row + for (int x = 0; x < w; ++x, ++out) { + // G pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGG); + out->g = in[x + offset]; + out->b = applyFilter(in, x, y, w, h, B_BGG); + } + ++x; ++out; + + // B pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGB); + out->g = applyFilter(in, x, y, w, h, G_BGB); + out->b = in[x + offset]; + } + } + } +} + +static void swapRedAndBlue(int N, Color3uint8* out) { + for (int i = N - 1; i >= 0; --i) { + uint8 tmp = out[i].r; + out[i].r = out[i].b; + out[i].b = tmp; + } +} + +void GImage::BAYER_G8R8_B8G8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out) { + // Run the equivalent function for red + BAYER_G8B8_R8G8_to_R8G8B8_MHC(w, h, in, _out); + + // Now swap red and blue + swapRedAndBlue(w * h, (Color3uint8*)_out); +} + + +void GImage::BAYER_B8G8_G8R8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out) { + // Run the equivalent function for red + BAYER_R8G8_G8B8_to_R8G8B8_MHC(w, h, in, _out); + + // Now swap red and blue + swapRedAndBlue(w * h, (Color3uint8*)_out); +} + + +void GImage::BAYER_G8B8_R8G8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out) { + + debugAssert(in != _out); + + Color3uint8* out = (Color3uint8*)_out; + + for (int y = 0; y < h; ++y) { + + // Row beginning in the input array. + int offset = y * w; + + // GB row + for (int x = 0; x < w; ++x, ++out) { + // G pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGG); + out->g = in[x + offset]; + out->b = applyFilter(in, x, y, w, h, B_BGG); + } + ++x; ++out; + + // B pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGB); + out->g = applyFilter(in, x, y, w, h, G_BGB); + out->b = in[x + offset]; + } + } + + ++y; + offset += w; + + // RG row + for (int x = 0; x < w; ++x, ++out) { + // R pixel + { + out->r = in[x + offset]; + out->g = applyFilter(in, x, y, w, h, G_GRR); + out->b = applyFilter(in, x, y, w, h, B_GRR); + } + ++x; ++out; + + // G pixel + { + out->r = applyFilter(in, x, y, w, h, R_GRG); + out->g = in[x + offset]; + out->b = applyFilter(in, x, y, w, h, B_GRG); + } + } + } + +} + +#undef B_BGG +#undef B_GRG +#undef B_GRR + +} diff --git a/dep/src/g3dlite/GImage_bmp.cpp b/dep/src/g3dlite/GImage_bmp.cpp new file mode 100644 index 00000000000..425a7e1a1d2 --- /dev/null +++ b/dep/src/g3dlite/GImage_bmp.cpp @@ -0,0 +1,717 @@ +/** + @file GImage_bmp.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2002-05-27 + @edited 2006-05-10 + */ +#include "G3D/platform.h" +#include "G3D/GImage.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Log.h" + +namespace G3D { + +#ifndef G3D_WIN32 +/** + This is used by the Windows bitmap I/O. + */ +static const int BI_RGB = 0; +#endif + +void GImage::encodeBMP( + BinaryOutput& out) const { + + debugAssert(m_channels == 1 || m_channels == 3); + out.setEndian(G3D_LITTLE_ENDIAN); + + uint8 red; + uint8 green; + uint8 blue; + int pixelBufferSize = m_width * m_height * 3; + int fileHeaderSize = 14; + int infoHeaderSize = 40; + int BMScanWidth; + int BMPadding; + + // First write the BITMAPFILEHEADER + // + // WORD bfType; + // DWORD bfSize; + // WORD bfReserved1; + // WORD bfReserved2; + // DWORD bfOffBits; + + // Type + out.writeUInt8('B'); + out.writeUInt8('M'); + + // File size + out.writeUInt32(fileHeaderSize + infoHeaderSize + pixelBufferSize); + + // Two reserved fields set to zero + out.writeUInt16(0); + out.writeUInt16(0); + + // The offset, in bytes, from the BITMAPFILEHEADER structure + // to the bitmap bits. + out.writeUInt32(infoHeaderSize + fileHeaderSize); + + // Now the BITMAPINFOHEADER + // + // DWORD biSize; + // LONG biWidth; + // LONG biHeight; + // WORD biPlanes; + // WORD biBitCount + // DWORD biCompression; + // DWORD biSizeImage; + // LONG biXPelsPerMeter; + // LONG biYPelsPerMeter; + // DWORD biClrUsed; + // DWORD biClrImportant; + + // Size of the info header + out.writeUInt32(infoHeaderSize); + + // Width and height of the image + out.writeUInt32(m_width); + out.writeUInt32(m_height); + + // Planes ("must be set to 1") + out.writeUInt16(1); + + // BitCount and CompressionType + out.writeUInt16(24); + out.writeUInt32(BI_RGB); + + // Image size ("may be zero for BI_RGB bitmaps") + out.writeUInt32(0); + + // biXPelsPerMeter + out.writeUInt32(0); + // biYPelsPerMeter + out.writeUInt32(0); + + // biClrUsed + out.writeUInt32(0); + + // biClrImportant + out.writeUInt32(0); + + BMScanWidth = m_width * 3; + + if (BMScanWidth & 3) { + BMPadding = 4 - (BMScanWidth & 3); + } else { + BMPadding = 0; + } + + int hStart = m_height - 1; + int hEnd = -1; + int hDir = -1; + int dest; + + // Write the pixel data + for (int h = hStart; h != hEnd; h += hDir) { + dest = m_channels * h * m_width; + for (int w = 0; w < m_width; ++w) { + + if (m_channels == 3) { + red = m_byte[dest]; + green = m_byte[dest + 1]; + blue = m_byte[dest + 2]; + } else { + red = m_byte[dest]; + green = m_byte[dest]; + blue = m_byte[dest]; + } + + out.writeUInt8(blue); + out.writeUInt8(green); + out.writeUInt8(red); + + dest += m_channels; + } + + if (BMPadding > 0) { + out.skip(BMPadding); + } + } +} + + +void GImage::decodeBMP( + BinaryInput& input) { + + // The BMP decoding uses these flags. + static const uint16 PICTURE_NONE = 0x0000; + static const uint16 PICTURE_BITMAP = 0x1000; + + // Compression Flags + static const uint16 PICTURE_UNCOMPRESSED = 0x0100; + static const uint16 PICTURE_MONOCHROME = 0x0001; + static const uint16 PICTURE_4BIT = 0x0002; + static const uint16 PICTURE_8BIT = 0x0004; + static const uint16 PICTURE_16BIT = 0x0008; + static const uint16 PICTURE_24BIT = 0x0010; + static const uint16 PICTURE_32BIT = 0x0020; + + (void)PICTURE_16BIT; + (void)PICTURE_32BIT; + + // This is a simple BMP loader that can handle uncompressed BMP files. + // Verify this is a BMP file by looking for the BM tag. + input.reset(); + std::string tag = input.readString(2); + if (tag != "BM") { + throw Error("Not a BMP file", input.getFilename()); + } + + m_channels = 3; + // Skip to the BITMAPINFOHEADER's width and height + input.skip(16); + + m_width = input.readUInt32(); + m_height = input.readUInt32(); + + // Skip to the bit count and compression type + input.skip(2); + + uint16 bitCount = input.readUInt16(); + uint32 compressionType = input.readUInt32(); + + uint8 red; + uint8 green; + uint8 blue; + uint8 blank; + + // Only uncompressed bitmaps are supported by this code + if ((int32)compressionType != BI_RGB) { + throw Error("BMP images must be uncompressed", input.getFilename()); + } + + uint8* palette = NULL; + + // Create the palette if needed + if (bitCount <= 8) { + + // Skip to the palette color count in the header + input.skip(12); + + int numColors = input.readUInt32(); + + palette = (uint8*)System::malloc(numColors * 3); + debugAssert(palette); + + // Skip past the end of the header to the palette info + input.skip(4); + + int c; + for(c = 0; c < numColors * 3; c += 3) { + // Palette information in bitmaps is stored in BGR_ format. + // That means it's blue-green-red-blank, for each entry. + blue = input.readUInt8(); + green = input.readUInt8(); + red = input.readUInt8(); + blank = input.readUInt8(); + + palette[c] = red; + palette[c + 1] = green; + palette[c + 2] = blue; + } + } + + int hStart = 0; + int hEnd = 0; + int hDir = 0; + + if (m_height < 0) { + m_height = -m_height; + hStart = 0; + hEnd = m_height; + hDir = 1; + } else { + //height = height; + hStart = m_height - 1; + hEnd = -1; + hDir = -1; + } + + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * 3); + debugAssert(m_byte); + + int BMScanWidth; + int BMPadding; + uint8 BMGroup; + uint8 BMPixel8; + int currPixel; + int dest; + int flags = PICTURE_NONE; + + if (bitCount == 1) { + // Note that this file is not necessarily grayscale, since it's possible + // the palette is blue-and-white, or whatever. But of course most image + // programs only write 1-bit images if they're black-and-white. + flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_MONOCHROME; + + // For bitmaps, each scanline is dword-aligned. + BMScanWidth = (m_width + 7) >> 3; + if (BMScanWidth & 3) { + BMScanWidth += 4 - (BMScanWidth & 3); + } + + // Powers of 2 + int pow2[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; + + for (int h = hStart; h != hEnd; h += hDir) { + + currPixel = 0; + dest = 3 * h * m_width; + + for (int w = 0; w < BMScanWidth; ++w) { + + BMGroup = input.readUInt8(); + + // Now we read the pixels. Usually there are eight pixels per byte, + // since each pixel is represented by one bit, but if the width + // is not a multiple of eight, the last byte will have some bits + // set, with the others just being extra. Plus there's the + // dword-alignment padding. So we keep checking to see if we've + // already read "width" number of pixels. + for (int i = 7; i >= 0; --i) { + if (currPixel < m_width) { + int src = 3 * ((BMGroup & pow2[i]) >> i); + + m_byte[dest] = palette[src]; + m_byte[dest + 1] = palette[src + 1]; + m_byte[dest + 2] = palette[src + 2]; + + ++currPixel; + dest += 3; + } + } + } + } + + } else if (bitCount == 4) { + + flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_4BIT; + + // For bitmaps, each scanline is dword-aligned. + int BMScanWidth = (m_width + 1) >> 1; + if (BMScanWidth & 3) { + BMScanWidth += 4 - (BMScanWidth & 3); + } + + for (int h = hStart; h != hEnd; h += hDir) { + + currPixel = 0; + dest = 3 * h * m_width; + + for (int w = 0; w < BMScanWidth; w++) { + + BMGroup = input.readUInt8(); + int src[2]; + src[0] = 3 * ((BMGroup & 0xF0) >> 4); + src[1] = 3 * (BMGroup & 0x0F); + + // Now we read the pixels. Usually there are two pixels per byte, + // since each pixel is represented by four bits, but if the width + // is not a multiple of two, the last byte will have only four bits + // set, with the others just being extra. Plus there's the + // dword-alignment padding. So we keep checking to see if we've + // already read "Width" number of pixels. + + for (int i = 0; i < 2; ++i) { + if (currPixel < m_width) { + int tsrc = src[i]; + + m_byte[dest] = palette[tsrc]; + m_byte[dest + 1] = palette[tsrc + 1]; + m_byte[dest + 2] = palette[tsrc + 2]; + + ++currPixel; + dest += 3; + } + } + } + } + + } else if (bitCount == 8) { + + flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_8BIT; + + // For bitmaps, each scanline is dword-aligned. + BMScanWidth = m_width; + if (BMScanWidth & 3) { + BMScanWidth += 4 - (BMScanWidth & 3); + } + + for (int h = hStart; h != hEnd; h += hDir) { + + currPixel = 0; + + for (int w = 0; w < BMScanWidth; ++w) { + + BMPixel8 = input.readUInt8(); + + if (currPixel < m_width) { + dest = 3 * ((h * m_width) + currPixel); + int src = 3 * BMPixel8; + + m_byte[dest] = palette[src]; + m_byte[dest + 1] = palette[src + 1]; + m_byte[dest + 2] = palette[src + 2]; + + ++currPixel; + } + } + } + + } else if (bitCount == 16) { + + m_memMan->free(m_byte); + m_byte = NULL; + System::free(palette); + palette = NULL; + throw Error("16-bit bitmaps not supported", input.getFilename()); + + } else if (bitCount == 24) { + input.skip(20); + + flags = PICTURE_BITMAP | PICTURE_UNCOMPRESSED | PICTURE_24BIT; + + // For bitmaps, each scanline is dword-aligned. + BMScanWidth = m_width * 3; + + if (BMScanWidth & 3) { + BMPadding = 4 - (BMScanWidth & 3); + } else { + BMPadding = 0; + } + + for (int h = hStart; h != hEnd; h += hDir) { + dest = 3 * h * m_width; + for (int w = 0; w < m_width; ++w) { + + blue = input.readUInt8(); + green = input.readUInt8(); + red = input.readUInt8(); + + m_byte[dest] = red; + m_byte[dest + 1] = green; + m_byte[dest + 2] = blue; + + dest += 3; + } + + if (BMPadding) { + input.skip(2); + } + } + + } else if (bitCount == 32) { + + m_memMan->free(m_byte); + m_byte = NULL; + System::free(palette); + palette = NULL; + throw Error("32 bit bitmaps not supported", input.getFilename()); + + } else { + // We support all possible bit depths, so if the + // code gets here, it's not even a real bitmap. + m_memMan->free(m_byte); + m_byte = NULL; + throw Error("Not a bitmap!", input.getFilename()); + } + + System::free(palette); + palette = NULL; +} + + +void GImage::decodeICO( + BinaryInput& input) { + + // Header + uint16 r = input.readUInt16(); + debugAssert(r == 0); + r = input.readUInt16(); + debugAssert(r == 1); + + // Read the number of icons, although we'll only load the + // first one. + int count = input.readUInt16(); + + m_channels = 4; + + debugAssert(count > 0); + + const uint8* headerBuffer = input.getCArray() + input.getPosition(); + int maxWidth = 0, maxHeight = 0; + int maxHeaderNum = 0; + for (int currentHeader = 0; currentHeader < count; ++currentHeader) { + + const uint8* curHeaderBuffer = headerBuffer + (currentHeader * 16); + int tmpWidth = curHeaderBuffer[0]; + int tmpHeight = curHeaderBuffer[1]; + // Just in case there is a non-square icon, checking area + if ((tmpWidth * tmpHeight) > (maxWidth * maxHeight)) { + maxWidth = tmpWidth; + maxHeight = tmpHeight; + maxHeaderNum = currentHeader; + } + } + + input.skip(maxHeaderNum * 16); + + m_width = input.readUInt8(); + m_height = input.readUInt8(); + int numColors = input.readUInt8(); + + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * m_channels); + debugAssert(m_byte); + + // Bit mask for packed bits + int mask = 0; + + int bitsPerPixel = 8; + + switch (numColors) { + case 2: + mask = 0x01; + bitsPerPixel = 1; + break; + + case 16: + mask = 0x0F; + bitsPerPixel = 4; + break; + + case 0: + numColors = 256; + mask = 0xFF; + bitsPerPixel = 8; + break; + + default: + throw Error("Unsupported ICO color count.", input.getFilename()); + } + + input.skip(5); + // Skip 'size' unused + input.skip(4); + + int offset = input.readUInt32(); + + // Skip over any other icon descriptions + input.setPosition(offset); + + // Skip over bitmap header; it is redundant + input.skip(40); + + Array<Color4uint8> palette; + palette.resize(numColors, true); + for (int c = 0; c < numColors; ++c) { + palette[c].b = input.readUInt8(); + palette[c].g = input.readUInt8(); + palette[c].r = input.readUInt8(); + palette[c].a = input.readUInt8(); + } + + // The actual image and mask follow + + // The XOR Bitmap is stored as 1-bit, 4-bit or 8-bit uncompressed Bitmap + // using the same encoding as BMP files. The AND Bitmap is stored in as + // 1-bit uncompressed Bitmap. + // + // Pixels are stored bottom-up, left-to-right. Pixel lines are padded + // with zeros to end on a 32bit (4byte) boundary. Every line will have the + // same number of bytes. Color indices are zero based, meaning a pixel color + // of 0 represents the first color table entry, a pixel color of 255 (if there + // are that many) represents the 256th entry. +/* + int bitsPerRow = width * bitsPerPixel; + int bytesPerRow = iCeil((double)bitsPerRow / 8); + // Rows are padded to 32-bit boundaries + bytesPerRow += bytesPerRow % 4; + + // Read the XOR values into the color channel + for (int y = height - 1; y >= 0; --y) { + int x = 0; + // Read the row + for (int i = 0; i < bytesPerRow; ++i) { + uint8 byte = input.readUInt8(); + for (int j = 0; (j < 8) && (x < width); ++x, j += bitsPerPixel) { + int bit = ((byte << j) >> (8 - bitsPerPixel)) & mask; + pixel4(x, y) = colorTable[bit]; + } + } + } +*/ + int hStart = 0; + int hEnd = 0; + int hDir = 0; + + if (m_height < 0) { + m_height = -m_height; + hStart = 0; + hEnd = m_height; + hDir = 1; + } else { + //height = height; + hStart = m_height - 1; + hEnd = -1; + hDir = -1; + } + + int BMScanWidth; + uint8 BMGroup; + uint8 BMPixel8; + int currPixel; + int dest; + + if (bitsPerPixel == 1) { + // Note that this file is not necessarily grayscale, since it's possible + // the palette is blue-and-white, or whatever. But of course most image + // programs only write 1-bit images if they're black-and-white. + + // For bitmaps, each scanline is dword-aligned. + BMScanWidth = (m_width + 7) >> 3; + if (BMScanWidth & 3) { + BMScanWidth += 4 - (BMScanWidth & 3); + } + + // Powers of 2 + int pow2[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; + + for (int h = hStart; h != hEnd; h += hDir) { + + currPixel = 0; + dest = 3 * h * m_width; + + for (int w = 0; w < BMScanWidth; ++w) { + + BMGroup = input.readUInt8(); + + // Now we read the pixels. Usually there are eight pixels per byte, + // since each pixel is represented by one bit, but if the width + // is not a multiple of eight, the last byte will have some bits + // set, with the others just being extra. Plus there's the + // dword-alignment padding. So we keep checking to see if we've + // already read "width" number of pixels. + for (int i = 7; i >= 0; --i) { + if (currPixel < m_width) { + int src = ((BMGroup & pow2[i]) >> i); + + m_byte[dest] = palette[src].r; + m_byte[dest + 1] = palette[src].g; + m_byte[dest + 2] = palette[src].b; + + ++currPixel; + dest += 4; + } + } + } + } + + } else if (bitsPerPixel == 4) { + + // For bitmaps, each scanline is dword-aligned. + int BMScanWidth = (m_width + 1) >> 1; + if (BMScanWidth & 3) { + BMScanWidth += 4 - (BMScanWidth & 3); + } + + for (int h = hStart; h != hEnd; h += hDir) { + + currPixel = 0; + dest = 4 * h * m_width; + + for (int w = 0; w < BMScanWidth; w++) { + + BMGroup = input.readUInt8(); + int src[2]; + src[0] = ((BMGroup & 0xF0) >> 4); + src[1] = (BMGroup & 0x0F); + + // Now we read the pixels. Usually there are two pixels per byte, + // since each pixel is represented by four bits, but if the width + // is not a multiple of two, the last byte will have only four bits + // set, with the others just being extra. Plus there's the + // dword-alignment padding. So we keep checking to see if we've + // already read "Width" number of pixels. + + for (int i = 0; i < 2; ++i) { + if (currPixel < m_width) { + int tsrc = src[i]; + + m_byte[dest] = palette[tsrc].r; + m_byte[dest + 1] = palette[tsrc].g; + m_byte[dest + 2] = palette[tsrc].b; + + ++currPixel; + dest += 4; + } + } + } + } + + } else if (bitsPerPixel == 8) { + + // For bitmaps, each scanline is dword-aligned. + BMScanWidth = m_width; + if (BMScanWidth & 3) { + BMScanWidth += 4 - (BMScanWidth & 3); + } + + for (int h = hStart; h != hEnd; h += hDir) { + + currPixel = 0; + + for (int w = 0; w < BMScanWidth; ++w) { + + BMPixel8 = input.readUInt8(); + + if (currPixel < m_width) { + dest = 4 * ((h * m_width) + currPixel); + int src = BMPixel8; + + m_byte[dest] = palette[src].r; + m_byte[dest + 1] = palette[src].g; + m_byte[dest + 2] = palette[src].b; + + ++currPixel; + } + } + } + } + + // Read the mask into the alpha channel + int bitsPerRow = m_width; + int bytesPerRow = iCeil((double)bitsPerRow / 8); + + // For bitmaps, each scanline is dword-aligned. + //BMScanWidth = (width + 1) >> 1; + if (bytesPerRow & 3) { + bytesPerRow += 4 - (bytesPerRow & 3); + } + + for (int y = m_height - 1; y >= 0; --y) { + int x = 0; + // Read the row + for (int i = 0; i < bytesPerRow; ++i) { + uint8 byte = input.readUInt8(); + for (int j = 0; (j < 8) && (x < m_width); ++x, ++j) { + int bit = (byte >> (7 - j)) & 0x01; + pixel4(x, y).a = (1 - bit) * 0xFF; + } + } + } + +} + + +} diff --git a/dep/src/g3dlite/GImage_jpeg.cpp b/dep/src/g3dlite/GImage_jpeg.cpp new file mode 100644 index 00000000000..0b0521f31e7 --- /dev/null +++ b/dep/src/g3dlite/GImage_jpeg.cpp @@ -0,0 +1,446 @@ +/** + @file GImage_jpeg.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2002-05-27 + @edited 2009-04-20 + */ +#include "G3D/platform.h" +#include "G3D/GImage.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +#include <cstring> + +extern "C" { +#ifdef G3D_LINUX +# include <jconfig.h> +# include <jpeglib.h> +#else +# include "jconfig.h" +# include "jpeglib.h" +#endif +} + +namespace G3D { + + +const int jpegQuality = 96; + +/** + The IJG library needs special setup for compress/decompressing + from memory. These classes provide them. + + The format of this class is defined by the IJG library; do not + change it. + */ +class memory_destination_mgr { +public: + struct jpeg_destination_mgr pub; + JOCTET* buffer; + int size; + int count; +}; + +typedef memory_destination_mgr* mem_dest_ptr; + +/** + Signature dictated by IJG. + */ +static void init_destination ( + j_compress_ptr cinfo) { + + mem_dest_ptr dest = (mem_dest_ptr) cinfo->dest; + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = dest->size; + dest->count=0; +} + +/** + Signature dictated by IJG. + */ +static boolean empty_output_buffer ( + j_compress_ptr cinfo) { + + mem_dest_ptr dest = (mem_dest_ptr) cinfo->dest; + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = dest->size; + + return TRUE; +} + +/** + Signature dictated by IJG. + */ +static void term_destination ( + j_compress_ptr cinfo) { + + mem_dest_ptr dest = (mem_dest_ptr) cinfo->dest; + dest->count = dest->size - dest->pub.free_in_buffer; +} + +/** + Signature dictated by IJG. + */ +static void jpeg_memory_dest ( + j_compress_ptr cinfo, + JOCTET* buffer, + int size) { + + mem_dest_ptr dest; + + if (cinfo->dest == NULL) { + // First time for this JPEG object; call the + // IJG allocator to get space. + cinfo->dest = (struct jpeg_destination_mgr*) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, + JPOOL_PERMANENT, + sizeof(memory_destination_mgr)); + } + + dest = (mem_dest_ptr) cinfo->dest; + dest->size = size; + dest->buffer = buffer; + dest->pub.init_destination = init_destination; + dest->pub.empty_output_buffer = empty_output_buffer; + dest->pub.term_destination = term_destination; +} + +//////////////////////////////////////////////////////////////////////////////////////// + +#define INPUT_BUF_SIZE 4096 + +/** + Structure dictated by IJG. + */ +class memory_source_mgr { +public: + struct jpeg_source_mgr pub; + int source_size; + unsigned char* source_data; + boolean start_of_data; + JOCTET* buffer; +}; + + +typedef memory_source_mgr* mem_src_ptr; + + +/** + Signature dictated by IJG. + */ +static void init_source( + j_decompress_ptr cinfo) { + + mem_src_ptr src = (mem_src_ptr) cinfo->src; + + src->start_of_data = TRUE; +} + + +/** + Signature dictated by IJG. + */ +static boolean fill_input_buffer( + j_decompress_ptr cinfo) { + + mem_src_ptr src = (mem_src_ptr) cinfo->src; + + size_t bytes_read = 0; + + if (src->source_size > INPUT_BUF_SIZE) + bytes_read = INPUT_BUF_SIZE; + else + bytes_read = src->source_size; + + memcpy (src->buffer, src->source_data, bytes_read); + + src->source_data += bytes_read; + src->source_size -= bytes_read; + + src->pub.next_input_byte = src->buffer; + src->pub.bytes_in_buffer = bytes_read; + src->start_of_data = FALSE; + + + return TRUE; +} + + +/** + Signature dictated by IJG. + */ +static void skip_input_data( + j_decompress_ptr cinfo, + long num_bytes) { + + mem_src_ptr src = (mem_src_ptr)cinfo->src; + + if (num_bytes > 0) { + while (num_bytes > (long) src->pub.bytes_in_buffer) { + num_bytes -= (long) src->pub.bytes_in_buffer; + boolean s = fill_input_buffer(cinfo); + debugAssert(s); (void)s; + } + + src->pub.next_input_byte += (size_t) num_bytes; + src->pub.bytes_in_buffer -= (size_t) num_bytes; + } +} + + +/** + Signature dictated by IJG. + */ +static void term_source ( + j_decompress_ptr cinfo) { + (void)cinfo; + // Intentionally empty +} + + +/** + Signature dictated by IJG. + */ +static void jpeg_memory_src ( + j_decompress_ptr cinfo, + JOCTET* buffer, + int size) { + + mem_src_ptr src; + + if (cinfo->src == NULL) { + // First time for this JPEG object + cinfo->src = (struct jpeg_source_mgr*) + (*cinfo->mem->alloc_small)( + (j_common_ptr) cinfo, + JPOOL_PERMANENT, + sizeof(memory_source_mgr)); + + src = (mem_src_ptr)cinfo->src; + + src->buffer = (JOCTET*) + (*cinfo->mem->alloc_small)( + (j_common_ptr) cinfo, + JPOOL_PERMANENT, + INPUT_BUF_SIZE * sizeof(JOCTET)); + } + + src = (mem_src_ptr)cinfo->src; + src->pub.init_source = init_source; + src->pub.fill_input_buffer = fill_input_buffer; + src->pub.skip_input_data = skip_input_data; + + // use default method + src->pub.resync_to_restart = jpeg_resync_to_restart; + src->pub.term_source = term_source; + src->source_data = buffer; + src->source_size = size; + + // forces fill_input_buffer on first read + src->pub.bytes_in_buffer = 0; + + // until buffer loaded + src->pub.next_input_byte = NULL; +} + + +void GImage::encodeJPEG( + BinaryOutput& out) const { + + if (m_channels != 3) { + // Convert to three channel + GImage tmp = *this; + tmp.convertToRGB(); + tmp.encodeJPEG(out); + return; + } + + debugAssert(m_channels == 3); + out.setEndian(G3D_LITTLE_ENDIAN); + + // Allocate and initialize a compression object + jpeg_compress_struct cinfo; + jpeg_error_mgr jerr; + + cinfo.err = jpeg_std_error(&jerr); + jpeg_create_compress(&cinfo); + + // Specify the destination for the compressed data. + // (Overestimate the size) + int buffer_size = m_width * m_height * 3 + 200; + JOCTET* compressed_data = (JOCTET*)System::malloc(buffer_size); + jpeg_memory_dest(&cinfo, compressed_data, buffer_size); + + + cinfo.image_width = m_width; + cinfo.image_height = m_height; + + // # of color components per pixel + cinfo.input_components = 3; + + // colorspace of input image + cinfo.in_color_space = JCS_RGB; + cinfo.input_gamma = 1.0; + + // Set parameters for compression, including image size & colorspace + jpeg_set_defaults(&cinfo); + jpeg_set_quality(&cinfo, jpegQuality, false); + cinfo.smoothing_factor = 0; + cinfo.optimize_coding = TRUE; +// cinfo.dct_method = JDCT_FLOAT; + cinfo.dct_method = JDCT_ISLOW; + cinfo.jpeg_color_space = JCS_YCbCr; + + // Initialize the compressor + jpeg_start_compress(&cinfo, TRUE); + + // Iterate over all scanlines from top to bottom + // pointer to a single row + JSAMPROW row_pointer[1]; + + // JSAMPLEs per row in image_buffer + int row_stride = cinfo.image_width * 3; + while (cinfo.next_scanline < cinfo.image_height) { + row_pointer[0] = &(m_byte[cinfo.next_scanline * row_stride]); + jpeg_write_scanlines(&cinfo, row_pointer, 1); + } + + // Shut down the compressor + jpeg_finish_compress(&cinfo); + + // Figure out how big the result was. + int outLength = ((mem_dest_ptr)cinfo.dest)->count; + + // Release the JPEG compression object + jpeg_destroy_compress(&cinfo); + + // Copy into an appropriately sized output buffer. + out.writeBytes(compressed_data, outLength); + + // Free the conservative buffer. + System::free(compressed_data); + compressed_data = NULL; +} + + +void GImage::decodeJPEG( + BinaryInput& input) { + + struct jpeg_decompress_struct cinfo; + struct jpeg_error_mgr jerr; + int loc = 0; + + m_channels = 3; + // We have to set up the error handler, in case initialization fails. + cinfo.err = jpeg_std_error(&jerr); + + // Initialize the JPEG decompression object. + jpeg_create_decompress(&cinfo); + + // Specify data source (eg, a file, for us, memory) + jpeg_memory_src(&cinfo, const_cast<uint8*>(input.getCArray()), input.size()); + + // Read the parameters with jpeg_read_header() + jpeg_read_header(&cinfo, TRUE); + + // Set parameters for decompression + // (We do nothing here since the defaults are fine) + + // Start decompressor + jpeg_start_decompress(&cinfo); + + // Get and set the values of interest to this object + m_width = cinfo.output_width; + m_height = cinfo.output_height; + + // Prepare the pointer object for the pixel data + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * 3); + + // JSAMPLEs per row in output buffer + int bpp = cinfo.output_components; + int row_stride = cinfo.output_width * bpp; + + // Make a one-row-high sample array that will go away when done with image + JSAMPARRAY temp = (*cinfo.mem->alloc_sarray) + ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); + + // Read data on a scanline by scanline basis + while (cinfo.output_scanline < cinfo.output_height) { + + // We may need to adjust the output based on the + // number of channels it has. + switch (bpp) { + case 1: + // Grayscale; decompress to temp. + jpeg_read_scanlines(&cinfo, temp, 1); + + // Expand to three channels + { + uint8* scan = &(m_byte[loc * 3]); + uint8* endScan = scan + (m_width * 3); + uint8* t = *temp; + + while (scan < endScan) { + uint8 value = t[0]; + + // Spread the value 3x. + scan[0] = value; + scan[1] = value; + scan[2] = value; + + scan += 3; + t += 1; + } + } + break; + + case 3: + // Read directly into the array + { + // Need one extra level of indirection. + uint8* scan = m_byte + loc; + JSAMPARRAY ptr = &scan; + jpeg_read_scanlines(&cinfo, ptr, 1); + } + break; + + case 4: + // RGBA; decompress to temp. + jpeg_read_scanlines(&cinfo, temp, 1); + + // Drop the 3rd channel + { + uint8* scan = &(m_byte[loc * 3]); + uint8* endScan = scan + m_width * 3; + uint8* t = *temp; + + while (scan < endScan) { + scan[0] = t[0]; + scan[1] = t[1]; + scan[2] = t[2]; + + scan += 3; + t += 4; + } + } + break; + + default: + throw Error("Unexpected number of channels.", input.getFilename()); + } + + loc += row_stride; + } + + // Finish decompression + jpeg_finish_decompress(&cinfo); + + alwaysAssertM(this, "Corrupt GImage"); + // Release JPEG decompression object + jpeg_destroy_decompress(&cinfo); +} + + +} diff --git a/dep/src/g3dlite/GImage_png.cpp b/dep/src/g3dlite/GImage_png.cpp new file mode 100644 index 00000000000..0a515bf7ed2 --- /dev/null +++ b/dep/src/g3dlite/GImage_png.cpp @@ -0,0 +1,266 @@ +/** + @file GImage_png.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2002-05-27 + @edited 2009-04-20 + */ +#include "G3D/platform.h" +#include "G3D/GImage.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Log.h" +#include <png.h> + +namespace G3D { + + +//libpng required function signature +static void png_read_data( + png_structp png_ptr, + png_bytep data, + png_size_t length) { + + + debugAssert( png_ptr->io_ptr != NULL ); + debugAssert( length >= 0 ); + debugAssert( data != NULL ); + + ((BinaryInput*)png_ptr->io_ptr)->readBytes(data, length); +} + +//libpng required function signature +static void png_write_data(png_structp png_ptr, + png_bytep data, + png_size_t length) { + + debugAssert( png_ptr->io_ptr != NULL ); + debugAssert( data != NULL ); + + ((BinaryOutput*)png_ptr->io_ptr)->writeBytes(data, length); +} + +//libpng required function signature +static void png_flush_data( + png_structp png_ptr) { + (void)png_ptr; + //Do nothing. +} + +//libpng required function signature +static void png_error( + png_structp png_ptr, + png_const_charp error_msg) { + + (void)png_ptr; + debugAssert( error_msg != NULL ); + throw GImage::Error(error_msg, "PNG"); +} + + +//libpng required function signature +void png_warning( + png_structp png_ptr, + png_const_charp warning_msg) { + + (void)png_ptr; + debugAssert( warning_msg != NULL ); + Log::common()->println(warning_msg); +} + + +void GImage::encodePNG( + BinaryOutput& out) const { + + debugAssert( m_channels == 1 || m_channels == 3 || m_channels == 4 ); + + if (m_height > (int)(PNG_UINT_32_MAX / png_sizeof(png_bytep))) + throw GImage::Error("Unsupported PNG height.", out.getFilename()); + + out.setEndian(G3D_LITTLE_ENDIAN); + + png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, png_error, png_warning); + if (! png_ptr) { + throw GImage::Error("Unable to initialize PNG encoder.", out.getFilename()); + } + + png_infop info_ptr = png_create_info_struct(png_ptr); + if (! info_ptr) { + png_destroy_write_struct(&png_ptr, &info_ptr); + throw GImage::Error("Unable to initialize PNG encoder.", out.getFilename()); + } + + //setup libpng write handler so can use BinaryOutput + png_set_write_fn(png_ptr, (void*)&out, png_write_data, png_flush_data); + png_color_8_struct sig_bit; + + switch (m_channels) { + case 1: + png_set_IHDR(png_ptr, info_ptr, m_width, m_height, 8, PNG_COLOR_TYPE_GRAY, + PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); + sig_bit.red = 0; + sig_bit.green = 0; + sig_bit.blue = 0; + sig_bit.alpha = 0; + sig_bit.gray = 8; + break; + + case 3: + png_set_IHDR(png_ptr, info_ptr, m_width, m_height, 8, PNG_COLOR_TYPE_RGB, + PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); + + sig_bit.red = 8; + sig_bit.green = 8; + sig_bit.blue = 8; + sig_bit.alpha = 0; + sig_bit.gray = 0; + break; + + case 4: + png_set_IHDR(png_ptr, info_ptr, m_width, m_height, 8, PNG_COLOR_TYPE_RGBA, + PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); + sig_bit.red = 8; + sig_bit.green = 8; + sig_bit.blue = 8; + sig_bit.alpha = 8; + sig_bit.gray = 0; + break; + + default: + png_destroy_write_struct(&png_ptr, &info_ptr); + throw GImage::Error("Unsupported number of channels for PNG.", out.getFilename()); + } + + + png_set_sBIT(png_ptr, info_ptr, &sig_bit); + + //write the png header + png_write_info(png_ptr, info_ptr); + + png_bytepp row_pointers = new png_bytep[m_height]; + + for (int i=0; i < m_height; ++i) { + row_pointers[i] = (png_bytep)&m_byte[m_width * m_channels * i]; + } + + png_write_image(png_ptr, row_pointers); + + png_write_end(png_ptr, info_ptr); + + delete[] row_pointers; + + png_destroy_write_struct(&png_ptr, &info_ptr); +} + + +void GImage::decodePNG( + BinaryInput& input) { + + png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, png_error, png_warning); + if (png_ptr == NULL) { + throw GImage::Error("Unable to initialize PNG decoder.", input.getFilename()); + } + + png_infop info_ptr = png_create_info_struct(png_ptr); + if (info_ptr == NULL) { + png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); + throw GImage::Error("Unable to initialize PNG decoder.", input.getFilename()); + } + + png_infop end_info = png_create_info_struct(png_ptr); + if (end_info == NULL) { + png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); + throw GImage::Error("Unable to initialize PNG decoder.", input.getFilename()); + } + + // now that the libpng structures are setup, change the error handlers and read routines + // to use G3D functions so that BinaryInput can be used. + + png_set_read_fn(png_ptr, (png_voidp)&input, png_read_data); + + // read in sequentially so that three copies of the file are not in memory at once + png_read_info(png_ptr, info_ptr); + + png_uint_32 png_width, png_height; + int bit_depth, color_type, interlace_type; + // this will validate the data it extracts from info_ptr + png_get_IHDR(png_ptr, info_ptr, &png_width, &png_height, &bit_depth, &color_type, + &interlace_type, int_p_NULL, int_p_NULL); + + if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { + png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); + throw GImage::Error("Unsupported PNG color type - PNG_COLOR_TYPE_GRAY_ALPHA.", input.getFilename()); + } + + m_width = static_cast<uint32>(png_width); + m_height = static_cast<uint32>(png_height); + + //swap bytes of 16 bit files to least significant byte first + png_set_swap(png_ptr); + + png_set_strip_16(png_ptr); + + //Expand paletted colors into true RGB triplets + if (color_type == PNG_COLOR_TYPE_PALETTE) { + png_set_palette_to_rgb(png_ptr); + } + + //Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel + if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) { + png_set_gray_1_2_4_to_8(png_ptr); + } + + //Expand paletted or RGB images with transparency to full alpha channels + //so the data will be available as RGBA quartets. + if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) { + png_set_tRNS_to_alpha(png_ptr); + } + + // Fix sub-8 bit_depth to 8bit + if (bit_depth < 8) { + png_set_packing(png_ptr); + } + + if ((color_type == PNG_COLOR_TYPE_RGBA) || + ((color_type == PNG_COLOR_TYPE_PALETTE) && (png_ptr->num_trans > 0)) ) { + + m_channels = 4; + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * 4); + + } else if ((color_type == PNG_COLOR_TYPE_RGB) || + (color_type == PNG_COLOR_TYPE_PALETTE)) { + + m_channels = 3; + m_byte = (uint8*)System::malloc(m_width * m_height * 3); + + } else if (color_type == PNG_COLOR_TYPE_GRAY) { + + m_channels = 1; + + // Round up to the nearest 8 rows to avoid a bug in the PNG decoder + int h = iCeil(m_height / 8) * 8; + int sz = m_width * h; + m_byte = (uint8*)m_memMan->alloc(sz); + + } else { + throw GImage::Error("Unsupported PNG bit-depth or type.", input.getFilename()); + } + + //since we are reading row by row, required to handle interlacing + uint32 number_passes = png_set_interlace_handling(png_ptr); + + png_read_update_info(png_ptr, info_ptr); + + for (uint32 pass = 0; pass < number_passes; ++pass) { + for (uint32 y = 0; y < (uint32)m_height; ++y) { + png_bytep rowPointer = &m_byte[m_width * m_channels * y]; + png_read_rows(png_ptr, &rowPointer, png_bytepp_NULL, 1); + } + } + +// png_read_image(png_ptr, &_byte); + png_read_end(png_ptr, info_ptr); + + png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); +} + +} diff --git a/dep/src/g3dlite/GImage_ppm.cpp b/dep/src/g3dlite/GImage_ppm.cpp new file mode 100644 index 00000000000..28f8cdf9ab0 --- /dev/null +++ b/dep/src/g3dlite/GImage_ppm.cpp @@ -0,0 +1,217 @@ +/** + @file GImage_ppm.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2002-05-27 + @edited 2006-05-10 + */ +#include "G3D/platform.h" +#include "G3D/GImage.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/TextInput.h" +#include "G3D/TextOutput.h" +#include "G3D/Log.h" + +namespace G3D { + +void GImage::encodePPMASCII( + BinaryOutput& out) const { + + TextOutput::Settings ppmOptions; + ppmOptions.convertNewlines = false; + ppmOptions.numColumns = 70; + ppmOptions.wordWrap = TextOutput::Settings::WRAP_WITHOUT_BREAKING; + TextOutput ppm(ppmOptions); + + switch (m_channels) { + case 1: + { + ppm.printf("P2\n%d %d\n255\n", m_width, m_height); + + const Color1uint8* c = this->pixel1(); + // Insert newlines every 70 characters max + for (uint32 i = 0; i < (uint32)(m_width * m_height); ++i) { + ppm.printf("%d%c", c[i].value, (i % (70/4) == 0) ? '\n' : ' '); + } + } + break; + + case 3: + { + ppm.printf("P3\n%d %d\n255\n", m_width, m_height); + + const Color3uint8* c = this->pixel3(); + // Insert newlines every 70 characters max + for (uint32 i = 0; i < (uint32)(m_width * m_height); ++i) { + ppm.printf("%d %d %d%c", c[i].r, c[i].g, c[i].b, + (i % (70/12) == 0) ? + '\n' : ' '); + } + } + break; + default: + alwaysAssertM(false, "PPM requires either 1 or 3 channels exactly."); + } + + const std::string& s = ppm.commitString(); + out.writeBytes(s.c_str(), s.length()); +} + + +void GImage::encodePPM( + BinaryOutput& out) const { + + // http://netpbm.sourceforge.net/doc/ppm.html + if (m_channels == 3) { + std::string header = format("P6 %d %d 255 ", m_width, m_height); + out.writeBytes(header.c_str(), header.size()); + out.writeBytes(this->pixel3(), m_width * m_height * 3); + } else if (m_channels == 1) { + std::string header = format("P5 %d %d 255 ", m_width, m_height); + out.writeBytes(header.c_str(), header.size()); + out.writeBytes(this->pixel1(), m_width * m_height); + } else { + alwaysAssertM(false, "PPM requires either 1 or 3 channels exactly."); + } +} + + +void GImage::decodePPMASCII( + BinaryInput& input) { + + int ppmWidth; + int ppmHeight; + + double maxColor; + + // Create a TextInput object to parse ascii format + // Mixed binary/ascii formats will require more + + const std::string inputStr = input.readString(); + + TextInput::Settings ppmOptions; + ppmOptions.cppLineComments = false; + ppmOptions.otherCommentCharacter = '#'; + ppmOptions.signedNumbers = true; + ppmOptions.singleQuotedStrings = false; + + TextInput ppmInput(TextInput::FROM_STRING, inputStr, ppmOptions); + + //Skip first line in header P# + std::string ppmType = ppmInput.readSymbol(); + + ppmWidth = (int)ppmInput.readNumber(); + ppmHeight = (int)ppmInput.readNumber(); + + // Everything but a PBM will have a max color value + if (ppmType != "P2") { + maxColor = ppmInput.readNumber(); + } else { + maxColor = 255; + } + + if ((ppmWidth < 0) || + (ppmHeight < 0) || + (maxColor <= 0)) { + throw GImage::Error("Invalid PPM Header.", input.getFilename()); + } + + // I don't think it's proper to scale values less than 255 + if (maxColor <= 255.0) { + maxColor = 255.0; + } + + m_width = ppmWidth; + m_height = ppmHeight; + m_channels = 3; + // always scale down to 1 byte per channel + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * 3); + + // Read in the image data. I am not validating if the values match the maxColor + // requirements. I only scale if needed to fit within the byte available. + for (uint32 i = 0; i < (uint32)(m_width * m_height); ++i) { + // read in color and scale to max pixel defined in header + // A max color less than 255 might need to be left alone and not scaled. + Color3uint8& curPixel = *(pixel3() + i); + + if (ppmType == "P3") { + curPixel.r = (uint8)(ppmInput.readNumber() * (255.0 / maxColor)); + curPixel.g = (uint8)(ppmInput.readNumber() * (255.0 / maxColor)); + curPixel.b = (uint8)(ppmInput.readNumber() * (255.0 / maxColor)); + } else if (ppmType == "P2") { + uint8 pixel = (uint8)(ppmInput.readNumber() * (255.0 / maxColor)); + curPixel.r = pixel; + curPixel.g = pixel; + curPixel.b = pixel; + } else if (ppmType == "P1") { + int pixel = (uint8)(ppmInput.readNumber() * maxColor); + curPixel.r = pixel; + curPixel.g = pixel; + curPixel.b = pixel; + } + } +} + +/** Consumes whitespace up to and including a number, but not the following character */ +static int scanUInt(BinaryInput& input) { + char c = input.readUInt8(); + while (isWhiteSpace(c)) { + c = input.readUInt8(); + } + + std::string s; + s += c; + c = input.readUInt8(); + while (!isWhiteSpace(c)) { + s += c; + c = input.readUInt8(); + } + + // Back up one to avoid consuming the last character + input.setPosition(input.getPosition() - 1); + + int x; + sscanf(s.c_str(), "%d", &x); + return x; +} + + +void GImage::decodePPM( + BinaryInput& input) { + + char head[2]; + int w, h; + + input.readBytes(head, 2); + if (head[0] != 'P' || (head[1] != '6') && (head[1] != '5')) { + throw GImage::Error("Invalid PPM Header.", input.getFilename()); + } + + w = scanUInt(input); + h = scanUInt(input); + + // Skip the max color specifier + scanUInt(input); + + if ((w < 0) || + (h < 0) || + (w > 100000) || + (h > 100000)) { + throw GImage::Error("Invalid PPM size in header.", input.getFilename()); + } + + // Trailing whitespace + input.readUInt8(); + + if (head[1] == '6') { + // 3 channel + resize(w, h, 3); + input.readBytes(m_byte, m_width * m_height * 3); + } else if (head[1] == '5') { + // 1 channel + resize(w, h, 1); + input.readBytes(m_byte, m_width * m_height); + } +} + +} diff --git a/dep/src/g3dlite/GImage_tga.cpp b/dep/src/g3dlite/GImage_tga.cpp new file mode 100644 index 00000000000..9785f879a1f --- /dev/null +++ b/dep/src/g3dlite/GImage_tga.cpp @@ -0,0 +1,193 @@ +/** + @file GImage_tga.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2002-05-27 + @edited 2009-05-10 + */ +#include "G3D/platform.h" +#include "G3D/GImage.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Log.h" + +namespace G3D { + +void GImage::encodeTGA( + BinaryOutput& out) const { + + out.setEndian(G3D_LITTLE_ENDIAN); + + // ID length + out.writeUInt8(0); + + // Color map Type + out.writeUInt8(0); + + // Type + out.writeUInt8(2); + + // Color map + out.skip(5); + + // x, y offsets + out.writeUInt16(0); + out.writeUInt16(0); + + // Width & height + out.writeUInt16(m_width); + out.writeUInt16(m_height); + + // Color depth + if (m_channels == 1) { + // Force RGB mode + out.writeUInt8(8 * 3); + } else { + out.writeUInt8(8 * m_channels); + } + + // Image descriptor + if (m_channels < 4) { + // 0 alpha bits + out.writeUInt8(0); + } else { + // 8 alpha bits + out.writeUInt8(8); + } + + // Image ID (zero length) + + if (m_channels == 1) { + // Pixels are upside down in BGR format. + for (int y = m_height - 1; y >= 0; --y) { + for (int x = 0; x < m_width; ++x) { + uint8 p = (m_byte[(y * m_width + x)]); + out.writeUInt8(p); + out.writeUInt8(p); + out.writeUInt8(p); + } + } + } else if (m_channels == 3) { + // Pixels are upside down in BGR format. + for (int y = m_height - 1; y >= 0; --y) { + for (int x = 0; x < m_width; ++x) { + uint8* p = &(m_byte[3 * (y * m_width + x)]); + out.writeUInt8(p[2]); + out.writeUInt8(p[1]); + out.writeUInt8(p[0]); + } + } + } else { + // Pixels are upside down in BGRA format. + for (int y = m_height - 1; y >= 0; --y) { + for (int x = 0; x < m_width; ++x) { + uint8* p = &(m_byte[4 * (y * m_width + x)]); + out.writeUInt8(p[2]); + out.writeUInt8(p[1]); + out.writeUInt8(p[0]); + out.writeUInt8(p[3]); + } + } + } + + // Write "TRUEVISION-XFILE " 18 bytes from the end + // (with null termination) + out.writeString("TRUEVISION-XFILE "); +} + + +void GImage::decodeTGA( + BinaryInput& input) { + + // This is a simple TGA loader that can handle uncompressed + // truecolor TGA files (TGA type 2). + // Verify this is a TGA file by looking for the TRUEVISION tag. + int pos = input.getPosition(); + input.setPosition(input.size() - 18); + std::string tag = input.readString(16); + if (tag != "TRUEVISION-XFILE") { + throw Error("Not a TGA file", input.getFilename()); + } + + input.setPosition(pos); + + int IDLength = input.readUInt8(); + int colorMapType = input.readUInt8(); + int imageType = input.readUInt8(); + + (void)colorMapType; + + // 2 is the type supported by this routine. + if (imageType != 2) { + throw Error("TGA images must be type 2 (Uncompressed truecolor)", input.getFilename()); + } + + // Color map specification + input.skip(5); + + // Image specification + + // Skip x and y offsets + input.skip(4); + + m_width = input.readInt16(); + m_height = input.readInt16(); + + int colorDepth = input.readUInt8(); + + if ((colorDepth != 24) && (colorDepth != 32)) { + throw Error("TGA files must be 24 or 32 bit.", input.getFilename()); + } + + if (colorDepth == 32) { + m_channels = 4; + } else { + m_channels = 3; + } + + // Image descriptor contains overlay data as well + // as data indicating where the origin is + int imageDescriptor = input.readUInt8(); + (void)imageDescriptor; + + // Image ID + input.skip(IDLength); + + m_byte = (uint8*)m_memMan->alloc(m_width * m_height * m_channels); + debugAssert(m_byte); + + // Pixel data + int x; + int y; + + if (m_channels == 3) { + for (y = m_height - 1; y >= 0; --y) { + for (x = 0; x < m_width; ++x) { + int b = input.readUInt8(); + int g = input.readUInt8(); + int r = input.readUInt8(); + + int i = (x + y * m_width) * 3; + m_byte[i + 0] = r; + m_byte[i + 1] = g; + m_byte[i + 2] = b; + } + } + } else { + for (y = m_height - 1; y >= 0; --y) { + for (x = 0; x < m_width; ++x) { + int b = input.readUInt8(); + int g = input.readUInt8(); + int r = input.readUInt8(); + int a = input.readUInt8(); + + int i = (x + y * m_width) * 4; + m_byte[i + 0] = r; + m_byte[i + 1] = g; + m_byte[i + 2] = b; + m_byte[i + 3] = a; + } + } + } +} + +} diff --git a/dep/src/g3dlite/GLight.cpp b/dep/src/g3dlite/GLight.cpp new file mode 100644 index 00000000000..37c8054ff3d --- /dev/null +++ b/dep/src/g3dlite/GLight.cpp @@ -0,0 +1,267 @@ +/** + @file GLight.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-11-12 + @edited 2009-11-16 +*/ +#include "G3D/GLight.h" +#include "G3D/Sphere.h" +#include "G3D/CoordinateFrame.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +GLight::GLight(const Any& any) { + any.verifyName("GLight"); + + if (any.type() == Any::TABLE) { + *this = GLight(); + for (Any::AnyTable::Iterator it = any.table().begin(); it.hasMore(); ++it) { + const std::string& key = toLower(it->key); + if (key == "position") { + position = it->value; + } else if (key == "rightdirection") { + rightDirection = it->value; + } else if (key == "spotdirection") { + spotDirection = it->value; + } else if (key == "spotcutoff") { + spotCutoff = it->value.number(); + } else if (key == "spotsquare") { + spotSquare = it->value.boolean(); + } else if (key == "attenuation") { + attenuation[0] = it->value[0].number(); + attenuation[1] = it->value[1].number(); + attenuation[2] = it->value[2].number(); + } else if (key == "color") { + color = it->value; + } else if (key == "enabled") { + enabled = it->value.boolean(); + } else if (key == "specular") { + specular = it->value.boolean(); + } else if (key == "diffuse") { + diffuse = it->value.boolean(); + } else { + any.verify(false, "Illegal key: " + it->key); + } + } + } else if (toLower(any.name()) == "glight::directional") { + + *this = directional(any[0], any[1], + (any.size() > 2) ? any[2] : Any(true), + (any.size() > 3) ? any[3] : Any(true)); + + } else if (toLower(any.name()) == "glight::point") { + + *this = point(any[0], any[1], + (any.size() > 2) ? any[2] : Any(1), + (any.size() > 3) ? any[3] : Any(0), + (any.size() > 4) ? any[4] : Any(0.5f), + (any.size() > 5) ? any[5] : Any(true), + (any.size() > 6) ? any[6] : Any(true)); + + } else if (toLower(any.name()) == "glight::spot") { + + *this = spot(any[0], any[1], any[2], any[3], + (any.size() > 4) ? any[4] : Any(1), + (any.size() > 5) ? any[5] : Any(0), + (any.size() > 6) ? any[6] : Any(0.5f), + (any.size() > 7) ? any[5] : Any(true), + (any.size() > 8) ? any[6] : Any(true)); + } else { + any.verify(false, "Unrecognized name"); + } +} + + +GLight::operator Any() const { + Any a(Any::TABLE, "GLight"); + a.set("position", position.operator Any()); + a.set("rightDirection", rightDirection.operator Any()); + a.set("spotDirection", spotDirection.operator Any()); + a.set("spotCutoff", spotCutoff); + a.set("spotSquare", spotSquare); + + Any att(Any::ARRAY); + att.append(attenuation[0], attenuation[1], attenuation[2]); + a.set("attenuation", att); + a.set("color", color.operator Any()); + a.set("enabled", enabled); + a.set("specular", specular); + a.set("diffuse", diffuse); + return a; +} + + +GLight::GLight() : + position(0, 0, 0, 0), + rightDirection(0,0,0), + spotDirection(0, 0, -1), + spotCutoff(180), + spotSquare(false), + color(Color3::white()), + enabled(false), + specular(true), + diffuse(true) { + + attenuation[0] = 1.0; + attenuation[1] = 0.0; + attenuation[2] = 0.0; +} + + +GLight GLight::directional(const Vector3& toLight, const Color3& color, bool s, bool d) { + GLight L; + L.position = Vector4(toLight.direction(), 0); + L.color = color; + L.specular = s; + L.diffuse = d; + return L; +} + + +GLight GLight::point(const Vector3& pos, const Color3& color, float constAtt, float linAtt, float quadAtt, bool s, bool d) { + GLight L; + L.position = Vector4(pos, 1); + L.color = color; + L.attenuation[0] = constAtt; + L.attenuation[1] = linAtt; + L.attenuation[2] = quadAtt; + L.specular = s; + L.diffuse = d; + return L; +} + + +GLight GLight::spot(const Vector3& pos, const Vector3& pointDirection, float cutOffAngleDegrees, const Color3& color, float constAtt, float linAtt, float quadAtt, bool s, bool d) { + GLight L; + L.position = Vector4(pos, 1.0f); + L.spotDirection = pointDirection.direction(); + debugAssert(cutOffAngleDegrees <= 90); + L.spotCutoff = cutOffAngleDegrees; + L.color = color; + L.attenuation[0] = constAtt; + L.attenuation[1] = linAtt; + L.attenuation[2] = quadAtt; + L.specular = s; + L.diffuse = d; + return L; +} + + +bool GLight::operator==(const GLight& other) const { + return (position == other.position) && + (rightDirection == other.rightDirection) && + (spotDirection == other.spotDirection) && + (spotCutoff == other.spotCutoff) && + (spotSquare == other.spotSquare) && + (attenuation[0] == other.attenuation[0]) && + (attenuation[1] == other.attenuation[1]) && + (attenuation[2] == other.attenuation[2]) && + (color == other.color) && + (enabled == other.enabled) && + (specular == other.specular) && + (diffuse == other.diffuse); +} + + +bool GLight::operator!=(const GLight& other) const { + return !(*this == other); +} + + +Sphere GLight::effectSphere(float cutoff) const { + if (position.w == 0) { + // Directional light + return Sphere(Vector3::zero(), finf()); + } else { + // Avoid divide by zero + cutoff = max(cutoff, 0.00001f); + float maxIntensity = max(color.r, max(color.g, color.b)); + + float radius = finf(); + + if (attenuation[2] != 0) { + + // Solve I / attenuation.dot(1, r, r^2) < cutoff for r + // + // a[0] + a[1] r + a[2] r^2 > I/cutoff + // + + float a = attenuation[2]; + float b = attenuation[1]; + float c = attenuation[0] - maxIntensity / cutoff; + + float discrim = square(b) - 4 * a * c; + + if (discrim >= 0) { + discrim = sqrt(discrim); + + float r1 = (-b + discrim) / (2 * a); + float r2 = (-b - discrim) / (2 * a); + + if (r1 < 0) { + if (r2 > 0) { + radius = r2; + } + } else if (r2 > 0) { + radius = min(r1, r2); + } else { + radius = r1; + } + } + + } else if (attenuation[1] != 0) { + + // Solve I / attenuation.dot(1, r) < cutoff for r + // + // r * a[1] + a[0] = I / cutoff + // r = (I / cutoff - a[0]) / a[1] + + float radius = (maxIntensity / cutoff - attenuation[0]) / attenuation[1]; + radius = max(radius, 0.0f); + } + + return Sphere(position.xyz(), radius); + + } +} + + +CoordinateFrame GLight::frame() const { + CoordinateFrame f; + if (rightDirection == Vector3::zero()) { + // No specified right direction; choose one automatically + if (position.w == 0) { + // Directional light + f.lookAt(-position.xyz()); + } else { + // Spot light + f.lookAt(spotDirection); + } + } else { + const Vector3& Z = -spotDirection.direction(); + Vector3 X = rightDirection.direction(); + + // Ensure the vectors are not too close together + while (abs(X.dot(Z)) > 0.9f) { + X = Vector3::random(); + } + + // Ensure perpendicular + X -= Z * Z.dot(X); + const Vector3& Y = Z.cross(X); + + f.rotation.setColumn(Vector3::X_AXIS, X); + f.rotation.setColumn(Vector3::Y_AXIS, Y); + f.rotation.setColumn(Vector3::Z_AXIS, Z); + } + f.translation = position.xyz(); + + return f; +} + + +} // G3D diff --git a/dep/src/g3dlite/GThread.cpp b/dep/src/g3dlite/GThread.cpp new file mode 100644 index 00000000000..607e4b3572f --- /dev/null +++ b/dep/src/g3dlite/GThread.cpp @@ -0,0 +1,229 @@ +/** + @file GThread.cpp + + GThread class. + + @created 2005-09-24 + @edited 2005-10-22 + */ + +#include "G3D/GThread.h" +#include "G3D/System.h" +#include "G3D/debugAssert.h" +#include "G3D/GMutex.h" + +namespace G3D { + +namespace _internal { + +class BasicThread: public GThread { +public: + BasicThread(const std::string& name, void (*proc)(void*), void* param): + GThread(name), m_wrapperProc(proc), m_param(param) { } +protected: + virtual void threadMain() { + m_wrapperProc(m_param); + } + +private: + void (*m_wrapperProc)(void*); + + void* m_param; +}; + +} // namespace _internal + + +GThread::GThread(const std::string& name): + m_status(STATUS_CREATED), + m_name(name) { + +#ifdef G3D_WIN32 + m_event = NULL; +#endif + + // system-independent clear of handle + System::memset(&m_handle, 0, sizeof(m_handle)); +} + +GThread::~GThread() { +#ifdef _MSC_VER +# pragma warning( push ) +# pragma warning( disable : 4127 ) +#endif + alwaysAssertM(m_status != STATUS_RUNNING, "Deleting thread while running."); +#ifdef _MSC_VER +# pragma warning( pop ) +#endif + +#ifdef G3D_WIN32 + if (m_event) { + ::CloseHandle(m_event); + } +#endif +} + +GThreadRef GThread::create(const std::string& name, void (*proc)(void*), void* param) { + return new _internal::BasicThread(name, proc, param); +} + + +bool GThread::started() const { + return m_status != STATUS_CREATED; +} + +bool GThread::start(SpawnBehavior behavior) { + + debugAssertM(! started(), "Thread has already executed."); + if (started()) { + return false; + } + + m_status = STATUS_STARTED; + + if (behavior == USE_CURRENT_THREAD) { + // Run on this thread + m_status = STATUS_RUNNING; + threadMain(); + m_status = STATUS_COMPLETED; + return true; + } + +# ifdef G3D_WIN32 + DWORD threadId; + + m_event = ::CreateEvent(NULL, TRUE, FALSE, NULL); + debugAssert(m_event); + + m_handle = ::CreateThread(NULL, 0, &internalThreadProc, this, 0, &threadId); + + if (m_handle == NULL) { + ::CloseHandle(m_event); + m_event = NULL; + } + + return (m_handle != NULL); +# else + if (!pthread_create(&m_handle, NULL, &internalThreadProc, this)) { + return true; + } else { + // system-independent clear of handle + System::memset(&m_handle, 0, sizeof(m_handle)); + + return false; + } +# endif +} + +void GThread::terminate() { + if (m_handle) { +# ifdef G3D_WIN32 + ::TerminateThread(m_handle, 0); +# else + pthread_kill(m_handle, SIGSTOP); +# endif + // system-independent clear of handle + System::memset(&m_handle, 0, sizeof(m_handle)); + } +} + + +bool GThread::running() const{ + return (m_status == STATUS_RUNNING); +} + + +bool GThread::completed() const { + return (m_status == STATUS_COMPLETED); +} + + +void GThread::waitForCompletion() { + if (m_status == STATUS_COMPLETED) { + // Must be done + return; + } + +# ifdef G3D_WIN32 + debugAssert(m_event); + ::WaitForSingleObject(m_event, INFINITE); +# else + debugAssert(m_handle); + pthread_join(m_handle, NULL); +# endif +} + + +#ifdef G3D_WIN32 +DWORD WINAPI GThread::internalThreadProc(LPVOID param) { + GThread* current = reinterpret_cast<GThread*>(param); + debugAssert(current->m_event); + current->m_status = STATUS_RUNNING; + current->threadMain(); + current->m_status = STATUS_COMPLETED; + ::SetEvent(current->m_event); + return 0; +} +#else +void* GThread::internalThreadProc(void* param) { + GThread* current = reinterpret_cast<GThread*>(param); + current->m_status = STATUS_RUNNING; + current->threadMain(); + current->m_status = STATUS_COMPLETED; + return (void*)NULL; +} +#endif + + + +//GMutex implementation +GMutex::GMutex() { +#ifdef G3D_WIN32 + ::InitializeCriticalSection(&m_handle); +#else + int ret = pthread_mutexattr_init(&m_attr); + debugAssert(ret == 0); + ret = pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE); + debugAssert(ret == 0); + ret = pthread_mutex_init(&m_handle, &m_attr); + debugAssert(ret == 0); +#endif +} + +GMutex::~GMutex() { + //TODO: Debug check for locked +#ifdef G3D_WIN32 + ::DeleteCriticalSection(&m_handle); +#else + int ret = pthread_mutex_destroy(&m_handle); + debugAssert(ret == 0); + ret = pthread_mutexattr_destroy(&m_attr); + debugAssert(ret == 0); +#endif +} + +bool GMutex::tryLock() { +#ifdef G3D_WIN32 + return (::TryEnterCriticalSection(&m_handle) != 0); +#else + return (pthread_mutex_trylock(&m_handle) == 0); +#endif +} + +void GMutex::lock() { +#ifdef G3D_WIN32 + ::EnterCriticalSection(&m_handle); +#else + pthread_mutex_lock(&m_handle); +#endif +} + +void GMutex::unlock() { +#ifdef G3D_WIN32 + ::LeaveCriticalSection(&m_handle); +#else + pthread_mutex_unlock(&m_handle); +#endif +} + +} // namespace G3D diff --git a/dep/src/g3dlite/GUniqueID.cpp b/dep/src/g3dlite/GUniqueID.cpp new file mode 100644 index 00000000000..84c853e0e31 --- /dev/null +++ b/dep/src/g3dlite/GUniqueID.cpp @@ -0,0 +1,78 @@ +/** + @file GUniqueID.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + */ +#include "G3D/GUniqueID.h" +#include "G3D/BinaryInput.h" +#include "G3D/TextInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/TextOutput.h" +#include "G3D/NetworkDevice.h" + +namespace G3D { + +void GUniqueID::serialize(BinaryOutput& b) const { + b.writeUInt64(id); +} + + +void GUniqueID::deserialize(BinaryInput& b) { + id = b.readUInt64(); +} + +void GUniqueID::serialize(TextOutput& t) const { + t.writeSymbol("("); + t.writeNumber((double)(id >> 32)); + t.writeNumber((double)(id & 0xFFFFFFFF)); + t.writeSymbol(")"); +} + +void GUniqueID::deserialize(TextInput& t) { + t.readSymbol("("); + id = (((uint64)t.readNumber()) << 32) + (uint64)t.readNumber(); + t.readSymbol(")"); +} + + +GUniqueID GUniqueID::create(uint16 tag) { + static uint64 counter = 0; + static uint64 systemID = 0; + + if (systemID == 0) { + // Create a unique ID for this machine/program instance + + // TODO: see ioctl(skfd, SIOCGIFHWADDR, &if_hwaddr) + Array<NetAddress> addr; + NetworkDevice::instance()->localHostAddresses(addr); + if (addr.size() > 0) { + systemID |= addr[0].ip(); + } + + union { + float64 ft; + uint64 ut; + }; + ft = System::time(); + systemID = ut << 22; + systemID ^= ((uint64)iRandom(0, 32768)) << 8; + + systemID &= ~((uint64)1023 << 54); + + // Ensure that the systemID is non-zero (vanishingly small probability) + if (systemID == 0) { + systemID = 1; + } + } + + // No need for modulo; we'll all be dead before this counter + // overflows 54 bits + ++counter; + + GUniqueID i; + + i.id = (((uint64)(tag & 1023)) << 54) | (counter ^ systemID); + + return i; +} + +} // G3D diff --git a/dep/src/g3dlite/Image1.cpp b/dep/src/g3dlite/Image1.cpp new file mode 100644 index 00000000000..a61f7faa633 --- /dev/null +++ b/dep/src/g3dlite/Image1.cpp @@ -0,0 +1,224 @@ +/** + @file Image1.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-31 + @edited 2007-01-31 +*/ + + +#include "G3D/Image1.h" +#include "G3D/Image1uint8.h" +#include "G3D/GImage.h" +#include "G3D/Color4.h" +#include "G3D/Color4uint8.h" +#include "G3D/Color1.h" +#include "G3D/Color1uint8.h" +#include "G3D/ImageFormat.h" + +namespace G3D { + +Image1::Image1(int w, int h, WrapMode wrap) : Map2D<Color1, Color1>(w, h, wrap) { + setAll(Color1(0.0f)); +} + + +Image1::Ref Image1::fromGImage(const GImage& im, WrapMode wrap) { + switch (im.channels()) { + case 1: + return fromArray(im.pixel1(), im.width(), im.height(), wrap); + + case 3: + return fromArray(im.pixel3(), im.width(), im.height(), wrap); + + case 4: + return fromArray(im.pixel4(), im.width(), im.height(), wrap); + + default: + debugAssertM(false, "Input GImage must have 1, 3, or 4 channels."); + return NULL; + } +} + + +Image1::Ref Image1::fromImage1uint8(const ReferenceCountedPointer<Image1uint8>& im) { + Ref out = createEmpty(static_cast<WrapMode>(im->wrapMode())); + out->resize(im->width(), im->height()); + + int N = im->width() * im->height(); + const Color1uint8* src = reinterpret_cast<Color1uint8*>(im->getCArray()); + for (int i = 0; i < N; ++i) { + out->data[i] = Color1(src[i]); + } + + return out; +} + + +Image1::Ref Image1::createEmpty(int width, int height, WrapMode wrap) { + return new Type(width, height, wrap); +} + + +Image1::Ref Image1::createEmpty(WrapMode wrap) { + return createEmpty(0, 0, wrap); +} + + +Image1::Ref Image1::fromFile(const std::string& filename, WrapMode wrap, GImage::Format fmt) { + Ref out = createEmpty(wrap); + out->load(filename, fmt); + return out; +} + + +void Image1::load(const std::string& filename, GImage::Format fmt) { + copyGImage(GImage(filename, fmt)); + setChanged(true); +} + + +Image1::Ref Image1::fromArray(const class Color3uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1::Ref Image1::fromArray(const class Color1* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1::Ref Image1::fromArray(const class Color1uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1::Ref Image1::fromArray(const class Color3* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1::Ref Image1::fromArray(const class Color4uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1::Ref Image1::fromArray(const class Color4* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + +void Image1::copyGImage(const GImage& im) { + switch (im.channels()) { + case 1: + copyArray(im.pixel1(), im.width(), im.height()); + break; + + case 3: + copyArray(im.pixel3(), im.width(), im.height()); + break; + + case 4: + copyArray(im.pixel4(), im.width(), im.height()); + break; + } +} + + +void Image1::copyArray(const Color3uint8* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color1* dst = data.getCArray(); + // Convert int8 -> float + for (int i = 0; i < N; ++i) { + dst[i] = Color1(Color3(src[i]).average()); + } +} + + +void Image1::copyArray(const Color4uint8* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color1* dst = data.getCArray(); + + // Strip alpha and convert + for (int i = 0; i < N; ++i) { + dst[i] = Color1(Color3(src[i].rgb()).average()); + } +} + + +void Image1::copyArray(const Color1* src, int w, int h) { + resize(w, h); + System::memcpy(getCArray(), src, w * h * sizeof(Color1)); +} + + +void Image1::copyArray(const Color4* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color1* dst = data.getCArray(); + + // Strip alpha + for (int i = 0; i < N; ++i) { + dst[i] = Color1(src[i].rgb().average()); + } +} + + +void Image1::copyArray(const Color1uint8* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color1* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i]= Color1(src[i]); + } +} + + +void Image1::copyArray(const Color3* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color1* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color1(src[i].average()); + } +} + + +/** Saves in any of the formats supported by G3D::GImage. */ +void Image1::save(const std::string& filename, GImage::Format fmt) { + GImage im(width(), height(), 1); + + int N = im.width() * im.height(); + Color1uint8* dst = im.pixel1(); + for (int i = 0; i < N; ++i) { + dst[i] = Color1uint8(data[i]); + } + + im.save(filename, fmt); +} + + +const ImageFormat* Image1::format() const { + return ImageFormat::L32F(); +} + +} // G3D diff --git a/dep/src/g3dlite/Image1uint8.cpp b/dep/src/g3dlite/Image1uint8.cpp new file mode 100644 index 00000000000..de2cbbc130b --- /dev/null +++ b/dep/src/g3dlite/Image1uint8.cpp @@ -0,0 +1,212 @@ +/** + @file Image1uint8.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-31 + @edited 2008-01-13 +*/ + +#include "G3D/Image1uint8.h" +#include "G3D/Image3uint8.h" +#include "G3D/Image1.h" +#include "G3D/GImage.h" +#include "G3D/Color1.h" +#include "G3D/Color1uint8.h" +#include "G3D/Color4.h" +#include "G3D/Color4uint8.h" +#include "G3D/ImageFormat.h" + +namespace G3D { + +Image1uint8::Image1uint8(int w, int h, WrapMode wrap) : Map2D<Color1uint8, Color1>(w, h, wrap) { + setAll(Color1uint8(0)); +} + + +Image1uint8::Ref Image1uint8::fromImage3uint8(const ReferenceCountedPointer<class Image3uint8>& im) { + return fromArray(im->getCArray(), im->width(), im->height(), im->wrapMode()); +} + + +Image1uint8::Ref Image1uint8::fromGImage(const GImage& im, WrapMode wrap) { + switch (im.channels()) { + case 1: + return fromArray(im.pixel1(), im.width(), im.height(), wrap); + + case 3: + return fromArray(im.pixel3(), im.width(), im.height(), wrap); + + case 4: + return fromArray(im.pixel4(), im.width(), im.height(), wrap); + + default: + debugAssertM(false, "Input GImage must have 1, 3, or 4 channels."); + return NULL; + } +} + + +Image1uint8::Ref Image1uint8::fromImage1(const ReferenceCountedPointer<Image1>& im) { + Ref out = createEmpty(static_cast<WrapMode>(im->wrapMode())); + out->copyArray(im->getCArray(), im->width(), im->height()); + + return out; +} + + +Image1uint8::Ref Image1uint8::createEmpty(int width, int height, WrapMode wrap) { + return new Type(width, height, wrap); +} + + +Image1uint8::Ref Image1uint8::createEmpty(WrapMode wrap) { + return createEmpty(0, 0, wrap); +} + + +Image1uint8::Ref Image1uint8::fromFile(const std::string& filename, WrapMode wrap, GImage::Format fmt) { + Ref out = createEmpty(wrap); + out->load(filename, fmt); + return out; +} + + +Image1uint8::Ref Image1uint8::fromArray(const class Color3uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1uint8::Ref Image1uint8::fromArray(const class Color1* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1uint8::Ref Image1uint8::fromArray(const class Color1uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1uint8::Ref Image1uint8::fromArray(const class Color3* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1uint8::Ref Image1uint8::fromArray(const class Color4uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image1uint8::Ref Image1uint8::fromArray(const class Color4* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +void Image1uint8::load(const std::string& filename, GImage::Format fmt) { + copyGImage(GImage(filename, fmt)); + setChanged(true); +} + + +void Image1uint8::copyGImage(const GImage& im) { + switch (im.channels()) { + case 1: + copyArray(im.pixel1(), im.width(), im.height()); + break; + + case 3: + copyArray(im.pixel3(), im.width(), im.height()); + break; + + case 4: + copyArray(im.pixel4(), im.width(), im.height()); + break; + } +} + + +void Image1uint8::copyArray(const Color3uint8* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color1uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].value = (src[i].r + src[i].g + src[i].b) / 3; + } +} + +void Image1uint8::copyArray(const Color3* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color1uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color1uint8(Color1(src[i].average())); + } +} + + +void Image1uint8::copyArray(const Color1uint8* ptr, int w, int h) { + resize(w, h); + System::memcpy(getCArray(), ptr, w * h); +} + + +void Image1uint8::copyArray(const Color1* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color1uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color1uint8(src[i]); + } +} + + +void Image1uint8::copyArray(const Color4uint8* ptr, int w, int h) { + resize(w, h); + int N = w * h; + + Color1uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].value = (ptr[i].r + ptr[i].g + ptr[i].b) / 3; + } +} + + +void Image1uint8::copyArray(const Color4* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color1uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color1uint8(Color1(src[i].rgb().average())); + } +} + + +/** Saves in any of the formats supported by G3D::GImage. */ +void Image1uint8::save(const std::string& filename, GImage::Format fmt) { + GImage im(width(), height(), 1); + System::memcpy(im.byte(), getCArray(), width() * height()); + im.save(filename, fmt); +} + + +const ImageFormat* Image1uint8::format() const { + return ImageFormat::L8(); +} + +} // G3D diff --git a/dep/src/g3dlite/Image3.cpp b/dep/src/g3dlite/Image3.cpp new file mode 100644 index 00000000000..0d85bdf45da --- /dev/null +++ b/dep/src/g3dlite/Image3.cpp @@ -0,0 +1,225 @@ +/** + @file Image3.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-31 + @edited 2007-01-31 +*/ + + +#include "G3D/Image3.h" +#include "G3D/Image3uint8.h" +#include "G3D/GImage.h" +#include "G3D/Color4.h" +#include "G3D/Color4uint8.h" +#include "G3D/Color1.h" +#include "G3D/Color1uint8.h" +#include "G3D/ImageFormat.h" + +namespace G3D { + +Image3::Image3(int w, int h, WrapMode wrap) : Map2D<Color3, Color3>(w, h, wrap) { + setAll(Color3::black()); +} + + +Image3::Ref Image3::fromGImage(const GImage& im, WrapMode wrap) { + switch (im.channels()) { + case 1: + return fromArray(im.pixel1(), im.width(), im.height(), wrap); + + case 3: + return fromArray(im.pixel3(), im.width(), im.height(), wrap); + + case 4: + return fromArray(im.pixel4(), im.width(), im.height(), wrap); + + default: + debugAssertM(false, "Input GImage must have 1, 3, or 4 channels."); + return NULL; + } +} + + +Image3::Ref Image3::fromImage3uint8(const ReferenceCountedPointer<Image3uint8>& im) { + Ref out = createEmpty(im->wrapMode()); + out->resize(im->width(), im->height()); + + int N = im->width() * im->height(); + const Color3uint8* src = reinterpret_cast<Color3uint8*>(im->getCArray()); + for (int i = 0; i < N; ++i) { + out->data[i] = Color3(src[i]); + } + + return out; +} + + +Image3::Ref Image3::createEmpty(int width, int height, WrapMode wrap) { + return new Image3(width, height, wrap); +} + + +Image3::Ref Image3::createEmpty(WrapMode wrap) { + return createEmpty(0, 0, wrap); +} + + +Image3::Ref Image3::fromFile(const std::string& filename, WrapMode wrap, GImage::Format fmt) { + Ref out = createEmpty(wrap); + out->load(filename, fmt); + return out; +} + + +void Image3::load(const std::string& filename, GImage::Format fmt) { + copyGImage(GImage(filename, fmt)); + setChanged(true); +} + + +Image3::Ref Image3::fromArray(const class Color3uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3::Ref Image3::fromArray(const class Color1* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3::Ref Image3::fromArray(const class Color1uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3::Ref Image3::fromArray(const class Color3* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3::Ref Image3::fromArray(const class Color4uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3::Ref Image3::fromArray(const class Color4* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +void Image3::copyGImage(const GImage& im) { + switch (im.channels()) { + case 1: + copyArray(im.pixel1(), im.width(), im.height()); + break; + + case 3: + copyArray(im.pixel3(), im.width(), im.height()); + break; + + case 4: + copyArray(im.pixel4(), im.width(), im.height()); + break; + } +} + + +void Image3::copyArray(const Color3uint8* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color3* dst = data.getCArray(); + // Convert int8 -> float + for (int i = 0; i < N; ++i) { + dst[i] = Color3(src[i]); + } +} + + +void Image3::copyArray(const Color4uint8* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color3* dst = data.getCArray(); + + // Strip alpha and convert + for (int i = 0; i < N; ++i) { + dst[i] = Color3(src[i].rgb()); + } +} + + +void Image3::copyArray(const Color3* src, int w, int h) { + resize(w, h); + System::memcpy(getCArray(), src, w * h * sizeof(Color3)); +} + + +void Image3::copyArray(const Color4* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color3* dst = data.getCArray(); + + // Strip alpha + for (int i = 0; i < N; ++i) { + dst[i] = src[i].rgb(); + } +} + + +void Image3::copyArray(const Color1uint8* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color3* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = Color1(src[i]).value; + } +} + + +void Image3::copyArray(const Color1* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color3* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = src[i].value; + } +} + + +/** Saves in any of the formats supported by G3D::GImage. */ +void Image3::save(const std::string& filename, GImage::Format fmt) { + GImage im(width(), height(), 3); + + int N = im.width() * im.height(); + Color3uint8* dst = im.pixel3(); + for (int i = 0; i < N; ++i) { + dst[i] = Color3uint8(data[i]); + } + + im.save(filename, fmt); +} + + +const ImageFormat* Image3::format() const { + return ImageFormat::RGB32F(); +} + +} // G3D diff --git a/dep/src/g3dlite/Image3uint8.cpp b/dep/src/g3dlite/Image3uint8.cpp new file mode 100644 index 00000000000..86595bbd1f6 --- /dev/null +++ b/dep/src/g3dlite/Image3uint8.cpp @@ -0,0 +1,225 @@ +/** + @file Image3uint8.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-31 + @edited 2008-01-08 +*/ + +#include "G3D/Image1uint8.h" +#include "G3D/Image3uint8.h" +#include "G3D/Image3.h" +#include "G3D/GImage.h" +#include "G3D/Color1.h" +#include "G3D/Color1uint8.h" +#include "G3D/Color4.h" +#include "G3D/Color4uint8.h" +#include "G3D/ImageFormat.h" + +namespace G3D { + +Image3uint8::Ref Image3uint8::fromImage1uint8(const ReferenceCountedPointer<class Image1uint8>& im) { + return fromArray(im->getCArray(), im->width(), im->height(), im->wrapMode()); +} + + +Image3uint8::Image3uint8(int w, int h, WrapMode wrap) : Map2D<Color3uint8>(w, h, wrap) { + setAll(Color3::black()); +} + + +Image3uint8::Ref Image3uint8::fromGImage(const GImage& im, WrapMode wrap) { + switch (im.channels()) { + case 1: + return fromArray(im.pixel1(), im.width(), im.height(), wrap); + + case 3: + return fromArray(im.pixel3(), im.width(), im.height(), wrap); + + case 4: + return fromArray(im.pixel4(), im.width(), im.height(), wrap); + + default: + debugAssertM(false, "Input GImage must have 1, 3, or 4 channels."); + return NULL; + } +} + + +Image3uint8::Ref Image3uint8::fromImage3(const ReferenceCountedPointer<Image3>& im) { + Ref out = createEmpty(static_cast<WrapMode>(im->wrapMode())); + out->copyArray(im->getCArray(), im->width(), im->height()); + + return out; +} + + +Image3uint8::Ref Image3uint8::createEmpty(int width, int height, WrapMode wrap) { + return new Type(width, height, wrap); +} + + +Image3uint8::Ref Image3uint8::createEmpty(WrapMode wrap) { + return createEmpty(0, 0, wrap); +} + + +Image3uint8::Ref Image3uint8::fromFile(const std::string& filename, WrapMode wrap, GImage::Format fmt) { + Ref out = createEmpty(wrap); + out->load(filename, fmt); + return out; +} + + +Image3uint8::Ref Image3uint8::fromArray(const class Color3uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3uint8::Ref Image3uint8::fromArray(const class Color1* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3uint8::Ref Image3uint8::fromArray(const class Color1uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3uint8::Ref Image3uint8::fromArray(const class Color3* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3uint8::Ref Image3uint8::fromArray(const class Color4uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image3uint8::Ref Image3uint8::fromArray(const class Color4* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +void Image3uint8::load(const std::string& filename, GImage::Format fmt) { + copyGImage(GImage(filename, fmt)); + setChanged(true); +} + + +void Image3uint8::copyGImage(const GImage& im) { + switch (im.channels()) { + case 1: + copyArray(im.pixel1(), im.width(), im.height()); + break; + + case 3: + copyArray(im.pixel3(), im.width(), im.height()); + break; + + case 4: + copyArray(im.pixel4(), im.width(), im.height()); + break; + } +} + + +void Image3uint8::copyArray(const Color1uint8* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color3uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = src[i].value; + } +} + +void Image3uint8::copyArray(const Color1* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color3uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = Color1uint8(src[i]).value; + } +} + + +void Image3uint8::copyArray(const Color3uint8* ptr, int w, int h) { + resize(w, h); + System::memcpy(getCArray(), ptr, w * h * 3); +} + + +void Image3uint8::copyArray(const Color3* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color3uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color3uint8(src[i]); + } +} + + +void Image3uint8::copyArray(const Color4uint8* ptr, int w, int h) { + resize(w, h); + + // Copy 3/4 bytes + GImage::RGBAtoRGB((const uint8*)ptr, (uint8*)getCArray(), w * h); +} + + +void Image3uint8::copyArray(const Color4* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color3uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color3uint8(src[i].rgb()); + } +} + + +/** Saves in any of the formats supported by G3D::GImage. */ +void Image3uint8::save(const std::string& filename, GImage::Format fmt) { + GImage im(width(), height(), 3); + System::memcpy(im.byte(), getCArray(), width() * height() * 3); + im.save(filename, fmt); +} + + +ReferenceCountedPointer<class Image1uint8> Image3uint8::getChannel(int c) const { + debugAssert(c >= 0 && c <= 2); + + Image1uint8Ref dst = Image1uint8::createEmpty(width(), height(), wrapMode()); + const Color3uint8* srcArray = getCArray(); + Color1uint8* dstArray = dst->getCArray(); + + const int N = width() * height(); + for (int i = 0; i < N; ++i) { + dstArray[i] = Color1uint8(srcArray[i][c]); + } + + return dst; +} + + +const ImageFormat* Image3uint8::format() const { + return ImageFormat::RGB8(); +} + +} // G3D diff --git a/dep/src/g3dlite/Image4.cpp b/dep/src/g3dlite/Image4.cpp new file mode 100644 index 00000000000..c6f2b10640d --- /dev/null +++ b/dep/src/g3dlite/Image4.cpp @@ -0,0 +1,226 @@ +/** + @file Image4.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-31 + @edited 2008-07-27 +*/ + + +#include "G3D/Image4.h" +#include "G3D/Image4uint8.h" +#include "G3D/GImage.h" +#include "G3D/Color3.h" +#include "G3D/Color3uint8.h" +#include "G3D/Color1.h" +#include "G3D/Color1uint8.h" +#include "G3D/ImageFormat.h" + +namespace G3D { + +Image4::Image4(int w, int h, WrapMode wrap) : Map2D<Color4, Color4>(w, h, wrap) { + setAll(Color4::zero()); +} + + +Image4::Ref Image4::fromGImage(const GImage& im, WrapMode wrap) { + switch (im.channels()) { + case 1: + return fromArray(im.pixel1(), im.width(), im.height(), wrap); + + case 3: + return fromArray(im.pixel3(), im.width(), im.height(), wrap); + + case 4: + return fromArray(im.pixel4(), im.width(), im.height(), wrap); + + default: + debugAssertM(false, "Input GImage must have 1, 3, or 4 channels."); + return NULL; + } +} + + +Image4::Ref Image4::fromImage4uint8(const ReferenceCountedPointer<Image4uint8>& im) { + Ref out = createEmpty(static_cast<WrapMode>(im->wrapMode())); + out->resize(im->width(), im->height()); + + int N = im->width() * im->height(); + const Color4uint8* src = reinterpret_cast<Color4uint8*>(im->getCArray()); + for (int i = 0; i < N; ++i) { + out->data[i] = Color4(src[i]); + } + + return out; +} + + +Image4::Ref Image4::createEmpty(int width, int height, WrapMode wrap) { + return new Type(width, height, wrap); +} + + +Image4::Ref Image4::createEmpty(WrapMode wrap) { + return createEmpty(0, 0, wrap); +} + + +Image4::Ref Image4::fromFile(const std::string& filename, WrapMode wrap, GImage::Format fmt) { + Ref out = createEmpty(wrap); + out->load(filename); + return out; +} + + +void Image4::load(const std::string& filename, GImage::Format fmt) { + copyGImage(GImage(filename, fmt)); + setChanged(true); +} + + +Image4::Ref Image4::fromArray(const class Color3uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4::Ref Image4::fromArray(const class Color1* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4::Ref Image4::fromArray(const class Color1uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4::Ref Image4::fromArray(const class Color3* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4::Ref Image4::fromArray(const class Color4uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4::Ref Image4::fromArray(const class Color4* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +void Image4::copyGImage(const GImage& im) { + switch (im.channels()) { + case 1: + copyArray(im.pixel1(), im.width(), im.height()); + break; + + case 3: + copyArray(im.pixel3(), im.width(), im.height()); + break; + + case 4: + copyArray(im.pixel4(), im.width(), im.height()); + break; + } +} + + +void Image4::copyArray(const Color4uint8* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color4* dst = data.getCArray(); + // Convert int8 -> float + for (int i = 0; i < N; ++i) { + dst[i] = Color4(src[i]); + } +} + + +void Image4::copyArray(const Color3uint8* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color4* dst = data.getCArray(); + + // Add alpha and convert + for (int i = 0; i < N; ++i) { + dst[i] = Color4(Color3(src[i]), 1.0f); + } +} + + +void Image4::copyArray(const Color4* src, int w, int h) { + resize(w, h); + System::memcpy(getCArray(), src, w * h * sizeof(Color4)); +} + + +void Image4::copyArray(const Color3* src, int w, int h) { + resize(w, h); + + int N = w * h; + Color4* dst = data.getCArray(); + + // Add alpha + for (int i = 0; i < N; ++i) { + dst[i] = Color4(src[i], 1.0f); + } +} + + +void Image4::copyArray(const Color1uint8* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color4* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = Color1(src[i]).value; + dst[i].a = 1.0f; + } +} + + +void Image4::copyArray(const Color1* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color4* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = src[i].value; + dst[i].a = 1.0f; + } +} + + +/** Saves in any of the formats supported by G3D::GImage. */ +void Image4::save(const std::string& filename, GImage::Format fmt) { + GImage im(width(), height(), 4); + + int N = im.width() * im.height(); + Color4uint8* dst = im.pixel4(); + for (int i = 0; i < N; ++i) { + dst[i] = Color4uint8(data[i]); + } + + im.save(filename, fmt); +} + +const ImageFormat* Image4::format() const { + return ImageFormat::RGBA32F(); +} + +} // G3D diff --git a/dep/src/g3dlite/Image4uint8.cpp b/dep/src/g3dlite/Image4uint8.cpp new file mode 100644 index 00000000000..a94ddb12d03 --- /dev/null +++ b/dep/src/g3dlite/Image4uint8.cpp @@ -0,0 +1,222 @@ +/** + @file Image4uint8.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-01-31 + @edited 2008-07-31 +*/ + +#include "G3D/Image4uint8.h" +#include "G3D/Image4.h" +#include "G3D/Image3uint8.h" +#include "G3D/Image3.h" +#include "G3D/GImage.h" +#include "G3D/Color1.h" +#include "G3D/Color1uint8.h" +#include "G3D/Color4.h" +#include "G3D/Color4uint8.h" +#include "G3D/ImageFormat.h" + +namespace G3D { + +Image4uint8::Image4uint8(int w, int h, WrapMode wrap) : Map2D<Color4uint8, Color4>(w, h, wrap) { + setAll(Color4::zero()); +} + + +Image4uint8::Ref Image4uint8::fromGImage(const GImage& im, WrapMode wrap) { + switch (im.channels()) { + case 1: + return fromArray(im.pixel1(), im.width(), im.height(), wrap); + + case 3: + return fromArray(im.pixel3(), im.width(), im.height(), wrap); + + case 4: + return fromArray(im.pixel4(), im.width(), im.height(), wrap); + + default: + debugAssertM(false, "Input GImage must have 1, 3, or 4 channels."); + return NULL; + } +} + + +Image4uint8::Ref Image4uint8::fromImage4(const ReferenceCountedPointer<Image4>& im) { + Ref out = createEmpty(static_cast<WrapMode>(im->wrapMode())); + out->copyArray(im->getCArray(), im->width(), im->height()); + + return out; +} + + +Image4uint8::Ref Image4uint8::createEmpty(int width, int height, WrapMode wrap) { + return new Type(width, height, wrap); +} + + +Image4uint8::Ref Image4uint8::createEmpty(WrapMode wrap) { + return createEmpty(0, 0, wrap); +} + + +Image4uint8::Ref Image4uint8::fromFile(const std::string& filename, WrapMode wrap, GImage::Format fmt) { + Ref out = createEmpty(wrap); + out->load(filename, fmt); + return out; +} + + +Image4uint8::Ref Image4uint8::fromArray(const class Color3uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4uint8::Ref Image4uint8::fromArray(const class Color1* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4uint8::Ref Image4uint8::fromArray(const class Color1uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4uint8::Ref Image4uint8::fromArray(const class Color3* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4uint8::Ref Image4uint8::fromArray(const class Color4uint8* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +Image4uint8::Ref Image4uint8::fromArray(const class Color4* ptr, int w, int h, WrapMode wrap) { + Ref out = createEmpty(wrap); + out->copyArray(ptr, w, h); + return out; +} + + +void Image4uint8::load(const std::string& filename, GImage::Format fmt) { + copyGImage(GImage(filename, fmt)); + setChanged(true); +} + + +void Image4uint8::copyGImage(const GImage& im) { + switch (im.channels()) { + case 1: + copyArray(im.pixel1(), im.width(), im.height()); + break; + + case 3: + copyArray(im.pixel3(), im.width(), im.height()); + break; + + case 4: + copyArray(im.pixel4(), im.width(), im.height()); + break; + } +} + + +void Image4uint8::copyArray(const Color1uint8* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color4uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = src[i].value; + dst[i].a = 255; + } +} + +void Image4uint8::copyArray(const Color1* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color4uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i].r = dst[i].g = dst[i].b = Color1uint8(src[i]).value; + dst[i].a = 255; + } +} + + +void Image4uint8::copyArray(const Color4uint8* ptr, int w, int h) { + resize(w, h); + System::memcpy(getCArray(), ptr, w * h * 4); +} + + +void Image4uint8::copyArray(const Color4* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color4uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color4uint8(src[i]); + } +} + + +void Image4uint8::copyArray(const Color3uint8* ptr, int w, int h) { + resize(w, h); + + GImage::RGBtoRGBA((const uint8*)ptr, (uint8*)getCArray(), w * h); +} + + +void Image4uint8::copyArray(const Color3* src, int w, int h) { + resize(w, h); + int N = w * h; + + Color4uint8* dst = getCArray(); + for (int i = 0; i < N; ++i) { + dst[i] = Color4uint8(Color4(src[i], 1.0f)); + } +} + + +/** Saves in any of the formats supported by G3D::GImage. */ +void Image4uint8::save(const std::string& filename, GImage::Format fmt) { + GImage im(width(), height(), 4); + System::memcpy(im.byte(), getCArray(), width() * height() * 4); + im.save(filename, fmt); +} + + +ReferenceCountedPointer<class Image1uint8> Image4uint8::getChannel(int c) const { + debugAssert(c >= 0 && c <= 3); + + Image1uint8Ref dst = Image1uint8::createEmpty(width(), height(), wrapMode()); + const Color4uint8* srcArray = getCArray(); + Color1uint8* dstArray = dst->getCArray(); + + const int N = width() * height(); + for (int i = 0; i < N; ++i) { + dstArray[i] = Color1uint8(srcArray[i][c]); + } + + return dst; +} + + +const ImageFormat* Image4uint8::format() const { + return ImageFormat::RGBA8(); +} + +} // G3D diff --git a/dep/src/g3dlite/ImageFormat.cpp b/dep/src/g3dlite/ImageFormat.cpp new file mode 100644 index 00000000000..70de878c11e --- /dev/null +++ b/dep/src/g3dlite/ImageFormat.cpp @@ -0,0 +1,567 @@ +/** + @file ImageFormat.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-05-23 + @edited 2009-12-10 + */ + +#include "GLG3D/glheaders.h" +#include "G3D/ImageFormat.h" + +namespace G3D { + +ImageFormat::ImageFormat( + int _numComponents, + bool _compressed, + int _glFormat, + int _glBaseFormat, + int _luminanceBits, + int _alphaBits, + int _redBits, + int _greenBits, + int _blueBits, + int _depthBits, + int _stencilBits, + int _hardwareBitsPerTexel, + int _packedBitsPerTexel, + int glDataFormat, + bool _opaque, + bool _floatingPoint, + Code _code, + ColorSpace _colorSpace, + BayerPattern _bayerPattern) : + + numComponents(_numComponents), + compressed(_compressed), + code(_code), + colorSpace(_colorSpace), + bayerPattern(_bayerPattern), + openGLFormat(_glFormat), + openGLBaseFormat(_glBaseFormat), + luminanceBits(_luminanceBits), + alphaBits(_alphaBits), + redBits(_redBits), + greenBits(_greenBits), + blueBits(_blueBits), + stencilBits(_stencilBits), + depthBits(_depthBits), + cpuBitsPerPixel(_packedBitsPerTexel), + packedBitsPerTexel(_packedBitsPerTexel), + openGLBitsPerPixel(_hardwareBitsPerTexel), + hardwareBitsPerTexel(_hardwareBitsPerTexel), + openGLDataFormat(glDataFormat), + opaque(_opaque), + floatingPoint(_floatingPoint) { + + debugAssert(_packedBitsPerTexel <= _hardwareBitsPerTexel); +} + +const ImageFormat* ImageFormat::depth(int depthBits) { + + switch (depthBits) { + case 16: + return DEPTH16(); + + case 24: + return DEPTH24(); + + case 32: + return DEPTH32(); + + default: + debugAssertM(false, "Depth must be 16, 24, or 32."); + return DEPTH32(); + } +} + + +const ImageFormat* ImageFormat::stencil(int bits) { + switch (bits) { + case 1: + return STENCIL1(); + + case 4: + return STENCIL4(); + + case 8: + return STENCIL8(); + + case 16: + return STENCIL16(); + + default: + debugAssertM(false, "Stencil must be 1, 4, 8 or 16."); + return STENCIL16(); + } +} + + + static const std::string nameArray[] = + { + "L8", + "L16", + "L16F", + "L32F", + + "A8", + "A16", + "A16F", + "A32F", + + "LA4", + "LA8", + "LA16", + "LA16F", + "LA32F", + + "RGB5", + "RGB5A1", + "RGB8", + "RGB10", + "RGB10A2", + "RGB16", + "RGB16F", + "RGB32F", + "R11G11B10F", + "RGB9E10F", + + "RGB8I", + "RGB8UI", + + "ARGB8", + "BGR8", + + "RG8", + "RG8I", + "RG8UI", + + "RGBA8", + "RGBA16", + "RGBA16F", + "RGBA32F", + + "RGBA32UI", + + "BAYER_RGGB8", + "BAYER_GRBG8", + "BAYER_GBRG8", + "BAYER_BGGR8", + "BAYER_RGGB32F", + "BAYER_GRBG32F", + "BAYER_GBRG32F", + "BAYER_BGGR32F", + + "HSV8", + "HSV32F", + + "YUV420_PLANAR", + "YUV422", + "YUV444", + + "RGB_DXT1", + "RGBA_DXT1", + "RGBA_DXT3", + "RGBA_DXT5", + + "SRGB8", + "SRGBA8", + + "SL8", + "SLA8", + + "SRGB_DXT1", + "SRGBA_DXT1", + "SRGBA_DXT3", + "SRGBA_DXT5", + + "DEPTH16", + "DEPTH24", + "DEPTH32", + "DEPTH32F", + + "STENCIL1", + "STENCIL4", + "STENCIL8", + "STENCIL16", + + "DEPTH24_STENCIL8", + "" + }; + +const std::string& ImageFormat::name() const { + debugAssert(code < CODE_NUM); + return nameArray[code]; +} + + +const ImageFormat* ImageFormat::fromString(const std::string& s) { + + for (int i = 0; ! nameArray[i].empty(); ++i) { + if (s == nameArray[i]) { + return fromCode(ImageFormat::Code(i)); + } + } + return NULL; +} + + +const ImageFormat* ImageFormat::fromCode(ImageFormat::Code code) { + switch (code) { + case ImageFormat::CODE_L8: + return ImageFormat::L8(); + + case ImageFormat::CODE_L16: + return ImageFormat::L16(); + + case ImageFormat::CODE_L16F: + return ImageFormat::L16F(); + + case ImageFormat::CODE_L32F: + return ImageFormat::L32F(); + + case ImageFormat::CODE_A8: + return ImageFormat::A8(); + + case ImageFormat::CODE_A16: + return ImageFormat::A16(); + + case ImageFormat::CODE_A16F: + return ImageFormat::A16F(); + + case ImageFormat::CODE_A32F: + return ImageFormat::A32F(); + + case ImageFormat::CODE_LA4: + return ImageFormat::LA4(); + + case ImageFormat::CODE_LA8: + return ImageFormat::LA8(); + + case ImageFormat::CODE_LA16: + return ImageFormat::LA16(); + + case ImageFormat::CODE_LA16F: + return ImageFormat::LA16F(); + break; + case ImageFormat::CODE_LA32F: + return ImageFormat::LA32F(); + + case ImageFormat::CODE_RGB5: + return ImageFormat::RGB5(); + + case ImageFormat::CODE_RGB5A1: + return ImageFormat::RGB5A1(); + + case ImageFormat::CODE_RGB8: + return ImageFormat::RGB8(); + + case ImageFormat::CODE_RGB10: + return ImageFormat::RGB10(); + + case ImageFormat::CODE_RGB10A2: + return ImageFormat::RGB10A2(); + + case ImageFormat::CODE_RGB16: + return ImageFormat::RGB16(); + + case ImageFormat::CODE_RGB32F: + return ImageFormat::RGB32F(); + + case ImageFormat::CODE_R11G11B10F: + return ImageFormat::R11G11B10F(); + + case ImageFormat::CODE_RGB9E5F: + return ImageFormat::RGB9E5F(); + + case ImageFormat::CODE_RGB8I: + return ImageFormat::RGB8I(); + + case ImageFormat::CODE_RGB8UI: + return ImageFormat::RGB8UI(); + + case ImageFormat::CODE_ARGB8: + return NULL; + + case ImageFormat::CODE_BGR8: + return ImageFormat::BGR8(); + + case ImageFormat::CODE_RG8: + return ImageFormat::RG8(); + + case ImageFormat::CODE_RG8I: + return ImageFormat::RG8I(); + + case ImageFormat::CODE_RG8UI: + return ImageFormat::RG8UI(); + + case ImageFormat::CODE_RGBA8: + return ImageFormat::RGBA8(); + + case ImageFormat::CODE_RGBA16: + return ImageFormat::RGBA16(); + + case ImageFormat::CODE_RGBA16F: + return ImageFormat::RGBA16F(); + + case ImageFormat::CODE_RGBA32F: + return ImageFormat::RGBA32F(); + + case ImageFormat::CODE_RGBA32UI: + return ImageFormat::RGBA32UI(); + + case ImageFormat::CODE_BAYER_RGGB8: + // TODO + case ImageFormat::CODE_BAYER_GRBG8: + // TODO + case ImageFormat::CODE_BAYER_GBRG8: + // TODO + case ImageFormat::CODE_BAYER_BGGR8: + // TODO + case ImageFormat::CODE_BAYER_RGGB32F: + // TODO + case ImageFormat::CODE_BAYER_GRBG32F: + // TODO + case ImageFormat::CODE_BAYER_GBRG32F: + // TODO + case ImageFormat::CODE_BAYER_BGGR32F: + // TODO + + case ImageFormat::CODE_HSV8: + // TODO + case ImageFormat::CODE_HSV32F: + // TODO + return NULL; + break; + + case ImageFormat::CODE_RGB_DXT1: + return ImageFormat::RGB_DXT1(); + break; + case ImageFormat::CODE_RGBA_DXT1: + return ImageFormat::RGBA_DXT1(); + break; + case ImageFormat::CODE_RGBA_DXT3: + return ImageFormat::RGBA_DXT3(); + break; + case ImageFormat::CODE_RGBA_DXT5: + return ImageFormat::RGBA_DXT5(); + break; + + case ImageFormat::CODE_SRGB8: + return ImageFormat::SRGB8(); + break; + + case ImageFormat::CODE_SRGBA8: + return ImageFormat::SRGBA8(); + break; + + case ImageFormat::CODE_SL8: + return ImageFormat::SL8(); + break; + + case ImageFormat::CODE_SLA8: + return ImageFormat::SLA8(); + break; + + case ImageFormat::CODE_SRGB_DXT1: + return ImageFormat::SRGB_DXT1(); + break; + + case ImageFormat::CODE_SRGBA_DXT1: + return ImageFormat::SRGBA_DXT1(); + break; + + case ImageFormat::CODE_SRGBA_DXT3: + return ImageFormat::SRGBA_DXT3(); + break; + + case ImageFormat::CODE_SRGBA_DXT5: + return ImageFormat::SRGBA_DXT5(); + break; + + case ImageFormat::CODE_DEPTH16: + return ImageFormat::DEPTH16(); + break; + case ImageFormat::CODE_DEPTH24: + return ImageFormat::DEPTH24(); + break; + case ImageFormat::CODE_DEPTH32: + return ImageFormat::DEPTH32(); + break; + case ImageFormat::CODE_DEPTH32F: + return ImageFormat::DEPTH32F(); + break; + + case ImageFormat::CODE_STENCIL1: + return ImageFormat::STENCIL1(); + break; + case ImageFormat::CODE_STENCIL4: + return ImageFormat::STENCIL4(); + break; + case ImageFormat::CODE_STENCIL8: + return ImageFormat::STENCIL8(); + break; + case ImageFormat::CODE_STENCIL16: + return ImageFormat::STENCIL16(); + break; + + case ImageFormat::CODE_DEPTH24_STENCIL8: + return ImageFormat::DEPTH24_STENCIL8(); + break; + + case ImageFormat::CODE_YUV420_PLANAR: + return ImageFormat::YUV420_PLANAR(); + break; + + case ImageFormat::CODE_YUV422: + return ImageFormat::YUV422(); + break; + + case ImageFormat::CODE_YUV444: + return ImageFormat::YUV444(); + break; + + default: + return NULL; + } +} + +// Helper variables for defining texture formats + +// Is floating point format +static const bool FLOAT_FORMAT = true; +static const bool INT_FORMAT = false; + +// Is opaque format (no alpha) +static const bool OPAQUE_FORMAT = true; +static const bool CLEAR_FORMAT = false; + +// Is compressed format (not raw component data) +static const bool COMP_FORMAT = true; +static const bool UNCOMP_FORMAT = false; + +#define DEFINE_TEXTUREFORMAT_METHOD(enumname, cmpnts, cmprssd, glf, glbf, lb, ab, rb, gb, bb, db, sb, hbpt, pbpt, gldf, opq, fp, code, cs) \ + const ImageFormat* ImageFormat::enumname() { \ + static const ImageFormat format(cmpnts, cmprssd, glf, glbf, lb, ab, rb, gb, bb, db, sb, hbpt, pbpt, gldf, opq, fp, code, cs); \ + return &format; } + +DEFINE_TEXTUREFORMAT_METHOD(L8, 1, UNCOMP_FORMAT, GL_LUMINANCE8, GL_LUMINANCE, 8, 0, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, CODE_L8, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(L16, 1, UNCOMP_FORMAT, GL_LUMINANCE16, GL_LUMINANCE, 16, 0, 0, 0, 0, 0, 0, 16, 16,GL_UNSIGNED_SHORT, OPAQUE_FORMAT, INT_FORMAT, CODE_L16, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(L16F, 1, UNCOMP_FORMAT, GL_LUMINANCE16F_ARB,GL_LUMINANCE, 16, 0, 0, 0, 0, 0, 0, 16, 16, GL_FLOAT, OPAQUE_FORMAT, FLOAT_FORMAT, CODE_L16F, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(L32F, 1, UNCOMP_FORMAT, GL_LUMINANCE32F_ARB,GL_LUMINANCE, 32, 0, 0, 0, 0, 0, 0, 32, 32, GL_FLOAT, OPAQUE_FORMAT, FLOAT_FORMAT, CODE_L32F, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(A8, 1, UNCOMP_FORMAT, GL_ALPHA8, GL_ALPHA, 0, 8, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, CODE_A8, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(A16, 1, UNCOMP_FORMAT, GL_ALPHA16, GL_ALPHA, 0, 16, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_SHORT, CLEAR_FORMAT, INT_FORMAT, CODE_A16, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(A16F, 1, UNCOMP_FORMAT, GL_ALPHA16F_ARB, GL_ALPHA, 0, 16, 0, 0, 0, 0, 0, 16, 16, GL_FLOAT, CLEAR_FORMAT, FLOAT_FORMAT, CODE_A16F, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(A32F, 1, UNCOMP_FORMAT, GL_ALPHA32F_ARB, GL_ALPHA, 0, 32, 0, 0, 0, 0, 0, 32, 32, GL_FLOAT, CLEAR_FORMAT, FLOAT_FORMAT, CODE_A32F, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(LA4, 2, UNCOMP_FORMAT, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE_ALPHA, 4, 4, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, CODE_LA4, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(LA8, 2, UNCOMP_FORMAT, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE_ALPHA, 8, 8, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, CODE_LA8, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(LA16, 2, UNCOMP_FORMAT, GL_LUMINANCE16_ALPHA16, GL_LUMINANCE_ALPHA, 16, 16, 0, 0, 0, 0, 0, 16*2, 16*2, GL_UNSIGNED_SHORT, CLEAR_FORMAT, INT_FORMAT, CODE_LA16, COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(LA16F, 2, UNCOMP_FORMAT, GL_LUMINANCE_ALPHA16F_ARB, GL_LUMINANCE_ALPHA, 16, 16, 0, 0, 0, 0, 0, 16*2, 16*2, GL_FLOAT, CLEAR_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_LA16F, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(LA32F, 2, UNCOMP_FORMAT, GL_LUMINANCE_ALPHA32F_ARB, GL_LUMINANCE_ALPHA, 32, 32, 0, 0, 0, 0, 0, 32*2, 32*2, GL_FLOAT, CLEAR_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_LA32F, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(BGR8, 3, UNCOMP_FORMAT, GL_RGB8, GL_BGR, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_BGR8, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RG8, 2, UNCOMP_FORMAT, GL_RG8, GL_RG, 0, 0, 8, 8, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RG8, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RG8I, 2, UNCOMP_FORMAT, GL_RG8I, GL_RG, 0, 0, 8, 8, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RG8I, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RG8UI, 2, UNCOMP_FORMAT, GL_RG8UI, GL_RG, 0, 0, 8, 8, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RG8UI, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB5, 3, UNCOMP_FORMAT, GL_RGB5, GL_RGBA, 0, 0, 5, 5, 5, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB5, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB5A1, 4, UNCOMP_FORMAT, GL_RGB5_A1, GL_RGBA, 0, 1, 5, 5, 5, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB5A1, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB8, 3, UNCOMP_FORMAT, GL_RGB8, GL_RGB, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB8, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB10, 3, UNCOMP_FORMAT, GL_RGB10, GL_RGB, 0, 0, 10, 10, 10, 0, 0, 32, 10*3, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB10, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB10A2, 4, UNCOMP_FORMAT, GL_RGB10_A2, GL_RGBA, 0, 2, 10, 10, 10, 0, 0, 32, 32, GL_UNSIGNED_INT_10_10_10_2, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB10A2, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB16, 3, UNCOMP_FORMAT, GL_RGB16, GL_RGB, 0, 0, 16, 16, 16, 0, 0, 16*3, 16*3, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB16, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB16F, 3, UNCOMP_FORMAT, GL_RGB16F_ARB, GL_RGB, 0, 0, 16, 16, 16, 0, 0, 16*3, 16*3, GL_FLOAT, OPAQUE_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_RGB16F, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB32F, 3, UNCOMP_FORMAT, GL_RGB32F_ARB, GL_RGB, 0, 0, 32, 32, 32, 0, 0, 32*3, 32*3, GL_FLOAT, OPAQUE_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_RGB32F, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA8, 4, UNCOMP_FORMAT, GL_RGBA8, GL_RGBA, 0, 8, 8, 8, 8, 0, 0, 32, 32, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_RGBA8, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA16, 4, UNCOMP_FORMAT, GL_RGBA16, GL_RGBA, 0, 16, 16, 16, 16, 0, 0, 16*4, 16*4, GL_UNSIGNED_SHORT, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_RGBA16, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA16F, 4, UNCOMP_FORMAT, GL_RGBA16F_ARB, GL_RGBA, 0, 16, 16, 16, 16, 0, 0, 16*4, 16*4, GL_FLOAT, CLEAR_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_RGBA16F, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA32F, 4, UNCOMP_FORMAT, GL_RGBA32F_ARB, GL_RGBA, 0, 32, 32, 32, 32, 0, 0, 32*4, 32*4, GL_FLOAT, CLEAR_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_RGBA32F, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA32UI, 4, UNCOMP_FORMAT, GL_RGBA32UI, GL_RGBA, 0, 32, 32, 32, 32, 0, 0, 32*4, 32*4, GL_UNSIGNED_INT, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_RGBA32UI, ImageFormat::COLOR_SPACE_RGB); + +// Unsigned +DEFINE_TEXTUREFORMAT_METHOD(R11G11B10F, 3, UNCOMP_FORMAT, GL_R11F_G11F_B10F_EXT, GL_RGB, 0, 0, 11, 11, 10, 0, 0, 32, 32, GL_FLOAT, OPAQUE_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_R11G11B10F, ImageFormat::COLOR_SPACE_RGB); + +// Unsigned +DEFINE_TEXTUREFORMAT_METHOD(RGB9E5F, 3, UNCOMP_FORMAT, GL_RGB9_E5_EXT, GL_RGB, 0, 0, 14, 14, 14, 0, 0, 32, 32, GL_FLOAT, OPAQUE_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_RGB9E5F, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB8I, 3, UNCOMP_FORMAT, GL_RGB8I_EXT, GL_RGB, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB8I, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGB8UI, 3, UNCOMP_FORMAT, GL_RGB8UI_EXT, GL_RGB, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB8UI, ImageFormat::COLOR_SPACE_RGB); + + +DEFINE_TEXTUREFORMAT_METHOD(RGB_DXT1, 3, COMP_FORMAT, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_RGB_DXT1, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA_DXT1, 4, COMP_FORMAT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_RGBA_DXT1, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA_DXT3, 4, COMP_FORMAT, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_RGBA_DXT3, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(RGBA_DXT5, 4, COMP_FORMAT, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_RGBA_DXT5, ImageFormat::COLOR_SPACE_RGB); + +DEFINE_TEXTUREFORMAT_METHOD(SRGB8, 3, UNCOMP_FORMAT, GL_SRGB8, GL_RGB, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_SRGB8, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(SRGBA8, 4, UNCOMP_FORMAT, GL_SRGB8_ALPHA8, GL_RGBA, 0, 8, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_SRGBA8, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(SL8, 1, UNCOMP_FORMAT, GL_SLUMINANCE8, GL_LUMINANCE, 8, 0, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_SL8, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(SLA8, 2, UNCOMP_FORMAT, GL_SLUMINANCE8_ALPHA8, GL_LUMINANCE_ALPHA, 8, 8, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_SLA8, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(SRGB_DXT1, 3, COMP_FORMAT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, GL_RGB, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_SRGB_DXT1, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(SRGBA_DXT1, 4, COMP_FORMAT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_SRGBA_DXT1, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(SRGBA_DXT3, 4, COMP_FORMAT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_SRGBA_DXT3, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(SRGBA_DXT5, 4, COMP_FORMAT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_SRGBA_DXT5, ImageFormat::COLOR_SPACE_SRGB); + +DEFINE_TEXTUREFORMAT_METHOD(DEPTH16, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT16_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 16, 0, 16, 16, GL_UNSIGNED_SHORT, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_DEPTH16, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(DEPTH24, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 24, 0, 32, 24, GL_UNSIGNED_INT, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_DEPTH24, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(DEPTH32, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 32, 0, 32, 32, GL_UNSIGNED_INT, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_DEPTH32, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(DEPTH32F, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 32, 0, 32, 32, GL_FLOAT, CLEAR_FORMAT, FLOAT_FORMAT, ImageFormat::CODE_DEPTH32F, ImageFormat::COLOR_SPACE_NONE); + +// These formats are for use with Renderbuffers only! +DEFINE_TEXTUREFORMAT_METHOD(STENCIL1, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 1, 1, 1, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_STENCIL1, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(STENCIL4, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX4_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 4, 4, 4, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_STENCIL4, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(STENCIL8, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 8, 8, 8, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_STENCIL8, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(STENCIL16, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX16_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 16, 16, 16, GL_UNSIGNED_SHORT, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_STENCIL16, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(DEPTH24_STENCIL8, 2, UNCOMP_FORMAT, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH_STENCIL_EXT,0, 0, 0, 0, 0, 24, 8, 32, 32, GL_UNSIGNED_INT, CLEAR_FORMAT, INT_FORMAT, ImageFormat::CODE_DEPTH24_STENCIL8, ImageFormat::COLOR_SPACE_NONE); + +DEFINE_TEXTUREFORMAT_METHOD(YUV420_PLANAR, 3, UNCOMP_FORMAT, GL_NONE, GL_NONE, 0, 0, 0, 0, 0, 0, 0, 12, 12, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_YUV420_PLANAR, ImageFormat::COLOR_SPACE_YUV); +DEFINE_TEXTUREFORMAT_METHOD(YUV422, 3, UNCOMP_FORMAT, GL_NONE, GL_NONE, 0, 0, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_YUV422, ImageFormat::COLOR_SPACE_YUV); +DEFINE_TEXTUREFORMAT_METHOD(YUV444, 3, UNCOMP_FORMAT, GL_NONE, GL_NONE, 0, 0, 0, 0, 0, 0, 0, 24, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INT_FORMAT, ImageFormat::CODE_YUV444, ImageFormat::COLOR_SPACE_YUV); + +} diff --git a/dep/src/g3dlite/ImageFormat_convert.cpp b/dep/src/g3dlite/ImageFormat_convert.cpp new file mode 100644 index 00000000000..ecefe6319c7 --- /dev/null +++ b/dep/src/g3dlite/ImageFormat_convert.cpp @@ -0,0 +1,1307 @@ +#include "G3D/ImageFormat.h" +#include "G3D/Color1uint8.h" +#include "G3D/Color3uint8.h" +#include "G3D/Color4uint8.h" +#include "G3D/Color1.h" +#include "G3D/Color3.h" +#include "G3D/Color4.h" + + +namespace G3D { + +// this is the signature for all conversion routines (same parameters as ImageFormat::convert) +typedef void (*ConvertFunc)(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg); + +// this defines the conversion routines for converting between compatible formats +static const int NUM_CONVERT_IMAGE_FORMATS = 5; +struct ConvertAttributes { + ConvertFunc m_converter; + ImageFormat::Code m_sourceFormats[NUM_CONVERT_IMAGE_FORMATS]; + ImageFormat::Code m_destFormats[NUM_CONVERT_IMAGE_FORMATS]; + bool m_handlesSourcePadding; + bool m_handlesDestPadding; + bool m_handleInvertY; +}; + +// forward declare the converters we can use them below +#define DECLARE_CONVERT_FUNC(name) static void name(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg); + +DECLARE_CONVERT_FUNC(l8_to_rgb8); +DECLARE_CONVERT_FUNC(l32f_to_rgb8); +DECLARE_CONVERT_FUNC(rgb8_to_rgba8); +DECLARE_CONVERT_FUNC(rgb8_to_bgr8); +DECLARE_CONVERT_FUNC(rgb8_to_rgba32f); +DECLARE_CONVERT_FUNC(bgr8_to_rgb8); +DECLARE_CONVERT_FUNC(bgr8_to_rgba8); +DECLARE_CONVERT_FUNC(bgr8_to_rgba32f); +DECLARE_CONVERT_FUNC(rgba8_to_rgb8); +DECLARE_CONVERT_FUNC(rgba8_to_bgr8); +DECLARE_CONVERT_FUNC(rgba8_to_rgba32f); +DECLARE_CONVERT_FUNC(rgb32f_to_rgba32f); +DECLARE_CONVERT_FUNC(rgba32f_to_rgb8); +DECLARE_CONVERT_FUNC(rgba32f_to_rgba8); +DECLARE_CONVERT_FUNC(rgba32f_to_bgr8); +DECLARE_CONVERT_FUNC(rgba32f_to_rgb32f); +DECLARE_CONVERT_FUNC(rgba32f_to_bayer_rggb8); +DECLARE_CONVERT_FUNC(rgba32f_to_bayer_gbrg8); +DECLARE_CONVERT_FUNC(rgba32f_to_bayer_grbg8); +DECLARE_CONVERT_FUNC(rgba32f_to_bayer_bggr8); +DECLARE_CONVERT_FUNC(bayer_rggb8_to_rgba32f); +DECLARE_CONVERT_FUNC(bayer_gbrg8_to_rgba32f); +DECLARE_CONVERT_FUNC(bayer_grbg8_to_rgba32f); +DECLARE_CONVERT_FUNC(bayer_bggr8_to_rgba32f); +DECLARE_CONVERT_FUNC(rgb8_to_yuv420p); +DECLARE_CONVERT_FUNC(rgb8_to_yuv422); +DECLARE_CONVERT_FUNC(rgb8_to_yuv444); +DECLARE_CONVERT_FUNC(yuv420p_to_rgb8); +DECLARE_CONVERT_FUNC(yuv422_to_rgb8); +DECLARE_CONVERT_FUNC(yuv444_to_rgb8); + +// this is the list of mappings between formats and the routines to perform them +static const ConvertAttributes sConvertMappings[] = { + + // RGB -> RGB color space + // L8 -> + {l8_to_rgb8, {ImageFormat::CODE_L8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, false, true}, + + // L32F -> + {l32f_to_rgb8, {ImageFormat::CODE_L32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, false, true}, + + // RGB8 -> + {rgb8_to_rgba8, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA8, ImageFormat::CODE_NONE}, false, false, true}, + {rgb8_to_bgr8, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_BGR8, ImageFormat::CODE_NONE}, false, false, true}, + {rgb8_to_rgba32f, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, true, false, true}, + + // BGR8 -> + {bgr8_to_rgb8, {ImageFormat::CODE_BGR8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, false, true}, + {bgr8_to_rgba8, {ImageFormat::CODE_BGR8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA8, ImageFormat::CODE_NONE}, false, false, true}, + {bgr8_to_rgba32f, {ImageFormat::CODE_BGR8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, true, false, true}, + + // RGBA8 -> + {rgba8_to_rgb8, {ImageFormat::CODE_RGBA8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, false, true}, + {rgba8_to_bgr8, {ImageFormat::CODE_RGBA8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_BGR8, ImageFormat::CODE_NONE}, false, false, true}, + {rgba8_to_rgba32f, {ImageFormat::CODE_RGBA8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, true, false, true}, + + // RGB32F -> + {rgb32f_to_rgba32f, {ImageFormat::CODE_RGB32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, true, false, true}, + + // RGBA32F -> + {rgba32f_to_rgb8, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, true, true}, + {rgba32f_to_rgba8, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA8, ImageFormat::CODE_NONE}, false, true, true}, + {rgba32f_to_bgr8, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_BGR8, ImageFormat::CODE_NONE}, false, true, true}, + {rgba32f_to_rgb32f, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB32F, ImageFormat::CODE_NONE}, false, true, true}, + + // RGB -> BAYER color space + {rgba32f_to_bayer_rggb8, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_BAYER_RGGB8, ImageFormat::CODE_NONE}, false, true, true}, + {rgba32f_to_bayer_gbrg8, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_BAYER_GBRG8, ImageFormat::CODE_NONE}, false, true, true}, + {rgba32f_to_bayer_grbg8, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_BAYER_GRBG8, ImageFormat::CODE_NONE}, false, true, true}, + {rgba32f_to_bayer_bggr8, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, {ImageFormat::CODE_BAYER_BGGR8, ImageFormat::CODE_NONE}, false, true, true}, + + // BAYER -> RGB color space + {bayer_rggb8_to_rgba32f, {ImageFormat::CODE_BAYER_RGGB8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, false, false, true}, + {bayer_gbrg8_to_rgba32f, {ImageFormat::CODE_BAYER_GBRG8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, false, false, true}, + {bayer_grbg8_to_rgba32f, {ImageFormat::CODE_BAYER_GRBG8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, false, false, true}, + {bayer_bggr8_to_rgba32f, {ImageFormat::CODE_BAYER_BGGR8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGBA32F, ImageFormat::CODE_NONE}, false, false, true}, + + // RGB <-> YUV color space + {rgb8_to_yuv420p, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_YUV420_PLANAR, ImageFormat::CODE_NONE}, false, false, false}, + {rgb8_to_yuv422, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_YUV422, ImageFormat::CODE_NONE}, false, false, false}, + {rgb8_to_yuv444, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, {ImageFormat::CODE_YUV444, ImageFormat::CODE_NONE}, false, false, false}, + {yuv420p_to_rgb8, {ImageFormat::CODE_YUV420_PLANAR, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, false, false}, + {yuv422_to_rgb8, {ImageFormat::CODE_YUV422, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, false, false}, + {yuv444_to_rgb8, {ImageFormat::CODE_YUV444, ImageFormat::CODE_NONE}, {ImageFormat::CODE_RGB8, ImageFormat::CODE_NONE}, false, false, false}, +}; + +static ConvertFunc findConverter(TextureFormat::Code sourceCode, TextureFormat::Code destCode, bool needsSourcePadding, bool needsDestPadding, bool needsInvertY) { + int numRoutines = sizeof(sConvertMappings) / sizeof(ConvertAttributes); + for (int routineIndex = 0; routineIndex < numRoutines; ++routineIndex) { + int sourceIndex = 0; + ConvertAttributes routine = sConvertMappings[routineIndex]; + + while (routine.m_sourceFormats[sourceIndex] != ImageFormat::CODE_NONE) { + // check for matching source + if (routine.m_sourceFormats[sourceIndex] == sourceCode) { + int destIndex = 0; + + // now check for matching dest to see if the routine fits + while (routine.m_destFormats[destIndex] != ImageFormat::CODE_NONE) { + + // check if dest format matches and padding + invert rules match + if ((routine.m_destFormats[destIndex] == destCode) && + (!needsSourcePadding || (routine.m_handlesSourcePadding == needsSourcePadding)) && + (!needsDestPadding || (routine.m_handlesDestPadding == needsDestPadding)) && + (!needsInvertY || (routine.m_handleInvertY == needsInvertY))) { + + // found compatible converter + return routine.m_converter; + } + ++destIndex; + } + } + ++sourceIndex; + } + } + + return NULL; +} + +bool conversionAvailable(const ImageFormat* srcFormat, int srcRowPadBits, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY = false) { + bool conversionAvailable = false; + + // check if a conversion is available + if ( (srcFormat->code == dstFormat->code) && (srcRowPadBits == dstRowPadBits) && !invertY) { + conversionAvailable = true; + } else { + ConvertFunc directConverter = findConverter(srcFormat->code, dstFormat->code, srcRowPadBits > 0, dstRowPadBits > 0, invertY); + + conversionAvailable = (directConverter != NULL); + } + + return conversionAvailable; +} + +bool ImageFormat::convert(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, + const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, + bool invertY, BayerAlgorithm bayerAlg) { + + bool conversionAvailable = false; + + // Handle direct copy of image to same format + if ( (srcFormat->code == dstFormat->code) && (srcRowPadBits == dstRowPadBits) && !invertY) { + + System::memcpy(dstBytes[0], srcBytes[0], iCeil(((srcWidth * srcFormat->cpuBitsPerPixel + srcRowPadBits) * srcHeight) / 8.0f)); + conversionAvailable = true; + } else { + // if no direct conversion routine exists, + // then look for conversion to intermediate + // and then from intermediate to dest. + // intermediate format is RGBA32F + ConvertFunc directConverter = findConverter(srcFormat->code, dstFormat->code, srcRowPadBits > 0, dstRowPadBits > 0, invertY); + + // if we have a direct converter, use it, otherwise find intermdiate path + if (directConverter) { + directConverter(srcBytes, srcWidth, srcHeight, srcFormat, srcRowPadBits, dstBytes, dstFormat, dstRowPadBits, invertY, bayerAlg); + conversionAvailable = true; + } else { + ConvertFunc toInterConverter = findConverter(srcFormat->code, ImageFormat::CODE_RGBA32F, srcRowPadBits > 0, false, false);; + ConvertFunc fromInterConverter = findConverter(ImageFormat::CODE_RGBA32F, dstFormat->code, false, dstRowPadBits > 0, invertY);; + + if (toInterConverter && fromInterConverter) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * ImageFormat::RGBA32F()->cpuBitsPerPixel * 8)); + + toInterConverter(srcBytes, srcWidth, srcHeight, srcFormat, srcRowPadBits, tmp, ImageFormat::RGBA32F(), 0, false, bayerAlg); + fromInterConverter(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, dstBytes, dstFormat, dstRowPadBits, invertY, bayerAlg); + + System::free(tmp[0]); + + conversionAvailable = true; + } + } + } + + return conversionAvailable; +} + + +// ******************* +// RGB -> RGB color space conversions +// ******************* + +// L8 -> +static void l8_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + (void)bayerAlg; + (void)dstRowPadBits; + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x); + int i3 = i * 3; + + dst[i3 + 0] = src[i]; + dst[i3 + 1] = src[i]; + dst[i3 + 2] = src[i]; + } + } +} + +// L32F -> +static void l32f_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + int srcIndex = 0; + int dstByteOffset = 0; + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const float* src = static_cast<const float*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + srcIndex = srcWidth * (srcHeight - y - 1); + } + + for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3) { + Color3uint8& d = *reinterpret_cast<Color3uint8*>(dst + dstByteOffset); + float s = src[srcIndex]; + + uint8 c = iMin(255, iFloor(s * 256)); + d = Color3uint8(c, c, c); + } + } +} + +// RGB8 -> +static void rgb8_to_rgba8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x); + int i3 = i * 3; + int i4 = i3 + i; + + dst[i4 + 0] = src[i3 + 0]; + dst[i4 + 1] = src[i3 + 1]; + dst[i4 + 2] = src[i3 + 2]; + dst[i4 + 3] = 255; + } + } +} + +static void rgb8_to_bgr8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x); + int i3 = i * 3; + dst[i3 + 0] = src[i3 + 2]; + dst[i3 + 1] = src[i3 + 1]; + dst[i3 + 2] = src[i3 + 0]; + } + } +} + +static void rgb8_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format"); + + int dstIndex = 0; + int srcByteOffset = 0; + int srcRowPadBytes = srcRowPadBits / 8; + Color4* dst = static_cast<Color4*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + dstIndex = srcWidth * (srcHeight - 1 - y); + } + for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 3) { + const Color3uint8& s = *reinterpret_cast<const Color3uint8*>(src + srcByteOffset); + dst[dstIndex] = Color4(Color3(s), 1.0f); + } + srcByteOffset += srcRowPadBytes; + } +} + +// BGR8 -> +static void bgr8_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x); + int i3 = i * 3; + dst[i3 + 0] = src[i3 + 2]; + dst[i3 + 1] = src[i3 + 1]; + dst[i3 + 2] = src[i3 + 0]; + } + } +} + +static void bgr8_to_rgba8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x); + int i3 = i * 3; + int i4 = i3 + i; + + dst[i4 + 0] = src[i3 + 2]; + dst[i4 + 1] = src[i3 + 1]; + dst[i4 + 2] = src[i3 + 0]; + dst[i4 + 3] = 255; + } + } +} + +static void bgr8_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format"); + + int dstIndex = 0; + int srcByteOffset = 0; + int srcRowPadBytes = srcRowPadBits / 8; + Color4* dst = static_cast<Color4*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + dstIndex = srcWidth * (srcHeight - 1 - y); + } + + for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 3) { + const Color3uint8& s = *reinterpret_cast<const Color3uint8*>(src + srcByteOffset); + dst[dstIndex] = Color4(Color3(s).bgr(), 1.0f); + } + srcByteOffset += srcRowPadBytes; + } +} + +// RGBA8 -> +static void rgba8_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x); + int i3 = i * 3; + int i4 = i3 + i; + + dst[i3 + 0] = src[i4 + 0]; + dst[i3 + 1] = src[i4 + 1]; + dst[i3 + 2] = src[i4 + 2]; + } + } +} + +static void rgba8_to_bgr8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x); + int i3 = i * 3; + int i4 = i3 + i; + + dst[i3 + 0] = src[i4 + 2]; + dst[i3 + 1] = src[i4 + 1]; + dst[i3 + 2] = src[i4 + 0]; + } + } +} + +static void rgba8_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format"); + + int dstIndex = 0; + int srcByteOffset = 0; + int srcRowPadBytes = srcRowPadBits / 8; + Color4* dst = static_cast<Color4*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + dstIndex = srcWidth * (srcHeight - 1 - y); + } + + for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 4) { + const Color4uint8& s = *reinterpret_cast<const Color4uint8*>(src + srcByteOffset); + dst[dstIndex] = Color4(s); + } + srcByteOffset += srcRowPadBytes; + } +} + +// RGB32F -> +static void rgb32f_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format"); + + int dstIndex = 0; + int srcByteOffset = 0; + int srcRowPadBytes = srcRowPadBits / 8; + Color4* dst = static_cast<Color4*>(dstBytes[0]); + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + dstIndex = srcWidth * (srcHeight - 1 - y); + } + + for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 3 * sizeof(float)) { + const Color3& s = *reinterpret_cast<const Color3*>(src + srcByteOffset); + dst[dstIndex] = Color4(Color3(s), 1.0f); + } + srcByteOffset += srcRowPadBytes; + } +} + +// RGBA32F -> +static void rgba32f_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format"); + + int srcIndex = 0; + int dstByteOffset = 0; + int dstRowPadBytes = dstRowPadBits / 8; + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const Color4* src = static_cast<const Color4*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + srcIndex = srcWidth * (srcHeight - y - 1); + } + + for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3) { + Color3uint8& d = *reinterpret_cast<Color3uint8*>(dst + dstByteOffset); + const Color4& s = src[srcIndex]; + + d = Color3uint8(s.rgb()); + } + dstByteOffset += dstRowPadBytes; + } +} + +static void rgba32f_to_rgba8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format"); + + int srcIndex = 0; + int dstByteOffset = 0; + int dstRowPadBytes = dstRowPadBits / 8; + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const Color4* src = static_cast<const Color4*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + srcIndex = srcWidth * (srcHeight - 1 - y); + } + for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 4) { + Color4uint8& d = *reinterpret_cast<Color4uint8*>(dst + dstByteOffset); + const Color4& s = src[srcIndex]; + + d = Color4uint8(s); + } + dstByteOffset += dstRowPadBytes; + } +} + +static void rgba32f_to_bgr8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format"); + + int srcIndex = 0; + int dstByteOffset = 0; + int dstRowPadBytes = dstRowPadBits / 8; + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const Color4* src = static_cast<const Color4*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + srcIndex = srcWidth * (srcHeight - y - 1); + } + + for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3) { + Color3uint8& d = *reinterpret_cast<Color3uint8*>(dst + dstByteOffset); + const Color4& s = src[srcIndex]; + + d = Color3uint8(s.rgb()).bgr(); + } + dstByteOffset += dstRowPadBytes; + } +} + +static void rgba32f_to_rgb32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format"); + + int srcIndex = 0; + int dstByteOffset = 0; + int dstRowPadBytes = dstRowPadBits / 8; + uint8* dst = static_cast<uint8*>(dstBytes[0]); + const Color4* src = static_cast<const Color4*>(srcBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + if (invertY) { + srcIndex = srcWidth * (srcHeight - 1 - y); + } + for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3 * sizeof(float)) { + Color3& d = *reinterpret_cast<Color3*>(dst + dstByteOffset); + const Color4& s = src[srcIndex]; + d = s.rgb(); + } + dstByteOffset += dstRowPadBytes; + } +} + +// ******************* +// RGB <-> YUV color space conversions +// ******************* + +static uint32 blendPixels(uint32 pixel1, uint32 pixel2) { + static const uint32 rbMask = 0x00FF00FF; + static const uint32 agMask = 0xFF00FF00; + + // Compute two color channels at a time. Use >> 1 for fast division by two + // Using alternating color channels prevents overflow + const uint32 rb = ((pixel1 & rbMask) + (pixel2 & rbMask)) >> 1; + + // Shift first to avoid overflow in alpha channel + const uint32 ag = (((pixel1 & agMask) >> 1) + ((pixel2 & agMask) >> 1)); + + return ((rb & rbMask) | (ag & agMask)); +} + +#define PIXEL_RGB8_TO_YUV_Y(r, g, b) static_cast<uint8>(iClamp(((66 * r + 129 * g + 25 * b + 128) >> 8) + 16, 0, 255)) +#define PIXEL_RGB8_TO_YUV_U(r, g, b) static_cast<uint8>(iClamp(((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128, 0, 255)) +#define PIXEL_RGB8_TO_YUV_V(r, g, b) static_cast<uint8>(iClamp(((112 * r - 94 * g - 18 * b + 128) >> 8) + 128, 0, 255)) + +static void rgb8_to_yuv420p(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format"); + debugAssertM((srcWidth % 2 == 0) && (srcHeight % 2 == 0), "Source width and height must be a multiple of two"); + + const Color3uint8* src = static_cast<const Color3uint8*>(srcBytes[0]); + + uint8* dstY = static_cast<uint8*>(dstBytes[0]); + uint8* dstU = static_cast<uint8*>(dstBytes[1]); + uint8* dstV = static_cast<uint8*>(dstBytes[2]); + + for (int y = 0; y < srcHeight; y += 2) { + for (int x = 0; x < srcWidth; x += 2) { + + // convert 4-pixel block at a time + int srcPixelOffset0 = y * srcWidth + x; + int srcPixelOffset1 = srcPixelOffset0 + 1; + int srcPixelOffset2 = srcPixelOffset0 + srcWidth; + int srcPixelOffset3 = srcPixelOffset2 + 1; + + int yIndex = y * srcWidth + x; + + dstY[yIndex] = PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset0].r, src[srcPixelOffset0].g, src[srcPixelOffset0].b); + dstY[yIndex + 1] = PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset1].r, src[srcPixelOffset1].g, src[srcPixelOffset1].b); + + yIndex += srcWidth; + dstY[yIndex] = PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset2].r, src[srcPixelOffset2].g, src[srcPixelOffset2].b); + dstY[yIndex + 1] = PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset3].r, src[srcPixelOffset3].g, src[srcPixelOffset3].b); + + uint32 blendedPixel = blendPixels(src[srcPixelOffset0].asUInt32(), src[srcPixelOffset2].asUInt32()); + Color3uint8 uvSrcColor = Color3uint8::fromARGB(blendedPixel); + + int uvIndex = y / 2 * srcWidth / 2 + x / 2; + dstU[uvIndex] = PIXEL_RGB8_TO_YUV_U(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b); + dstV[uvIndex] = PIXEL_RGB8_TO_YUV_V(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b); + } + } +} + +static void rgb8_to_yuv422(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format"); + debugAssertM((srcWidth % 2 == 0), "Source width must be a multiple of two"); + + const Color3uint8* src = static_cast<const Color3uint8*>(srcBytes[0]); + + uint8* dst = static_cast<uint8*>(dstBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; x += 2) { + + // convert 2-pixel horizontal block at a time + int srcIndex = y * srcWidth + x; + int dstIndex = srcIndex * 2; + + uint32 blendedPixel = blendPixels(src[srcIndex].asUInt32(), src[srcIndex + 1].asUInt32()); + Color3uint8 uvSrcColor = Color3uint8::fromARGB(blendedPixel); + + dst[dstIndex] = PIXEL_RGB8_TO_YUV_Y(src[srcIndex].r, src[srcIndex].g, src[srcIndex].b); + + dst[dstIndex + 1] = PIXEL_RGB8_TO_YUV_U(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b); + + dst[dstIndex + 2] = PIXEL_RGB8_TO_YUV_Y(src[srcIndex + 1].r, src[srcIndex + 1].g, src[srcIndex + 1].b); + + dst[dstIndex + 3] = PIXEL_RGB8_TO_YUV_V(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b); + + } + } +} + +static void rgb8_to_yuv444(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format"); + + const Color3uint8* src = static_cast<const Color3uint8*>(srcBytes[0]); + + Color3uint8* dst = static_cast<Color3uint8*>(dstBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + + // convert 1-pixels at a time + int index = y * srcWidth + x; + uint8 y = PIXEL_RGB8_TO_YUV_Y(src[index].r, src[index].g, src[index].b); + uint8 u = PIXEL_RGB8_TO_YUV_U(src[index].r, src[index].g, src[index].b); + uint8 v = PIXEL_RGB8_TO_YUV_V(src[index].r, src[index].g, src[index].b); + + dst[index].r = y; + dst[index].g = u; + dst[index].b = v; + } + } +} + + +#define PIXEL_YUV_TO_RGB8_R(y, u, v) static_cast<uint8>(iClamp((298 * (y - 16) + 409 * (v - 128) + 128) >> 8, 0, 255)) +#define PIXEL_YUV_TO_RGB8_G(y, u, v) static_cast<uint8>(iClamp((298 * (y - 16) - 100 * (u - 128) - 208 * (v - 128) + 128) >> 8, 0, 255)) +#define PIXEL_YUV_TO_RGB8_B(y, u, v) static_cast<uint8>(iClamp((298 * (y - 16) + 516 * (u - 128) + 128) >> 8, 0, 255)) + +static void yuv420p_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format"); + debugAssertM((srcWidth % 2 == 0) && (srcHeight % 2 == 0), "Source width and height must be a multiple of two"); + + const uint8* srcY = static_cast<const uint8*>(srcBytes[0]); + const uint8* srcU = static_cast<const uint8*>(srcBytes[1]); + const uint8* srcV = static_cast<const uint8*>(srcBytes[2]); + + Color3uint8* dst = static_cast<Color3uint8*>(dstBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; x += 2) { + + // convert to two rgb pixels in a row + Color3uint8* rgb = &dst[y * srcWidth + x]; + + int yOffset = y * srcWidth + x; + int uvOffset = y / 2 * srcWidth / 2 + x / 2; + + rgb->r = PIXEL_YUV_TO_RGB8_R(srcY[yOffset], srcU[uvOffset], srcV[uvOffset]); + rgb->g = PIXEL_YUV_TO_RGB8_G(srcY[yOffset], srcU[uvOffset], srcV[uvOffset]); + rgb->b = PIXEL_YUV_TO_RGB8_B(srcY[yOffset], srcU[uvOffset], srcV[uvOffset]); + + rgb += 1; + rgb->r = PIXEL_YUV_TO_RGB8_R(srcY[yOffset + 1], srcU[uvOffset], srcV[uvOffset]); + rgb->g = PIXEL_YUV_TO_RGB8_G(srcY[yOffset + 1], srcU[uvOffset], srcV[uvOffset]); + rgb->b = PIXEL_YUV_TO_RGB8_B(srcY[yOffset + 1], srcU[uvOffset], srcV[uvOffset]); + } + } +} + +static void yuv422_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format"); + debugAssertM((srcWidth % 2 == 0), "Source width must be a multiple of two"); + + const uint8* src = static_cast<const uint8*>(srcBytes[0]); + + Color3uint8* dst = static_cast<Color3uint8*>(dstBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; x += 2) { + + // convert to two rgb pixels in a row + Color3uint8* rgb = &dst[y * srcWidth + x]; + + int srcIndex = (y * srcWidth + x) * 2; + uint8 y = src[srcIndex]; + uint8 u = src[srcIndex + 1]; + uint8 y2 = src[srcIndex + 2]; + uint8 v = src[srcIndex + 3]; + + rgb->r = PIXEL_YUV_TO_RGB8_R(y, u, v); + rgb->g = PIXEL_YUV_TO_RGB8_G(y, u, v); + rgb->b = PIXEL_YUV_TO_RGB8_B(y, u, v); + + rgb += 1; + rgb->r = PIXEL_YUV_TO_RGB8_R(y2, u, v); + rgb->g = PIXEL_YUV_TO_RGB8_G(y2, u, v); + rgb->b = PIXEL_YUV_TO_RGB8_B(y2, u, v); + } + } +} + +static void yuv444_to_rgb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format"); + + const Color3uint8* src = static_cast<const Color3uint8*>(srcBytes[0]); + + Color3uint8* dst = static_cast<Color3uint8*>(dstBytes[0]); + + for (int y = 0; y < srcHeight; ++y) { + for (int x = 0; x < srcWidth; ++x) { + + // convert to one rgb pixels at a time + int index = y * srcWidth + x; + Color3uint8* rgb = &dst[index]; + + rgb->r = PIXEL_YUV_TO_RGB8_R(src[index].r, src[index].g, src[index].b); + rgb->g = PIXEL_YUV_TO_RGB8_G(src[index].r, src[index].g, src[index].b); + rgb->b = PIXEL_YUV_TO_RGB8_B(src[index].r, src[index].g, src[index].b); + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +// +// Bayer conversions +// + +// There are two kinds of rows (GR and BG). +// In each row, there are two kinds of pixels (G/R, B/G). +// We express the four kinds of INPUT pixels as: +// GRG, GRG, BGB, BGG +// +// There are three kinds of OUTPUT pixels: R, G, B. +// Thus there are nominally 12 different I/O combinations, +// but several are impulses because needed output at that +// location *is* the input (e.g., G_GRG and G_BGG). +// +// The following 5x5 row-major filters are named as output_input. + +// Green +static const float G_GRR[5][5] = + {{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}, + { 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, + { -1.0f, 2.0f, 4.0f, 2.0f, -1.0f}, + { 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, + { 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}; + +static const float G_BGB[5][5] = + {{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}, + { 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, + { -1.0f, 2.0f, 4.0f, 2.0f, -1.0f}, + { 0.0f, 0.0f, 2.0f, 0.0f, 0.0f}, + { 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}; + +// Red +//(the caption in the paper is wrong for this case: +// "R row B column really means R row G column" +static const float R_GRG[5][5] = + {{ 0.0f, 0.0f, 0.5f, 0.0f, 0.0f}, + { 0.0f, -1.0f, 0.0f, -1.0f, 0.0f}, + { -1.0f, 4.0f, 5.0f, 4.0f, -1.0f}, + { 0.0f, -1.0f, 0.0f, -1.0f, 0.0f}, + { 0.0f, 0.0f, 0.5f, 0.0f, 0.0f}}; + +static const float R_BGG[5][5] = + {{ 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}, + { 0.0f, -1.0f, 4.0f, -1.0f, 0.0f}, + { 0.5f, 0.0f, 5.0f, 0.0f, 0.5f}, + { 0.0f, -1.0f, 4.0f, -1.0f, 0.0f}, + { 0.0f, 0.0f, -1.0f, 0.0f, 0.0f}}; + +static const float R_BGB[5][5] = + {{ 0.0f, 0.0f, -3.0f/2.0f, 0.0f, 0.0f}, + { 0.0f, 2.0f, 0.0f, 2.0f, 0.0f}, + {-3.0f/2.0f, 0.0f, 6.0f, 0.0f, -3.0f/2.0f}, + { 0.0f, 2.0f, 0.0f, 2.0f, 0.0f}, + { 0.0f, 0.0f, -3.0f/2.0f, 0.0f, 0.0f}}; + + +// Blue +//(the caption in the paper is wrong for this case: +// "B row R column really means B row G column") +#define B_BGG R_GRG +#define B_GRG R_BGG +#define B_GRR R_BGB + +// ===================================================================== +// Helper methods +// ===================================================================== + + +/** Applies a 5x5 filter to monochrome image I (wrapping at the boundaries) */ +static uint8 applyFilter(const uint8* I, + int x, + int y, + int w, + int h, + const float filter[5][5]) { + + debugAssert(isEven(w)); + debugAssert(isEven(h)); + + float sum = 0.0f; + float denom = 0.0f; + + for (int dy = 0; dy < 5; ++dy) { + int offset = ((y + dy + h - 2) % h) * w; + + for (int dx = 0; dx < 5; ++dx) { + float f = filter[dy][dx]; + sum += f * I[((x + dx + w - 2) % w) + offset]; + denom += f; + } + } + + return (uint8)iClamp(iRound(sum / denom), 0, 255); +} + +/** Helper method for Bayer grbg and bggr --> rgb8 */ +static void swapRedAndBlue(int N, Color3uint8* out) { + for (int i = N - 1; i >= 0; --i) { + uint8 tmp = out[i].r; + out[i].r = out[i].b; + out[i].b = tmp; + } +} + +// RGB -> BAYER color space + +// ===================================================================== +// rgb8 --> bayer helpers +// ===================================================================== +static void rgb8_to_bayer_rggb8(const int w, const int h, + const uint8* src, uint8* dst) { + Color3uint8* srcColor = (Color3uint8*)src; + Color1uint8* dstColor = (Color1uint8*)dst; + + // Top row pixels + for (int y = 0; y < h - 1; y += 2) { + int offset = y * w; + + // Top left pixels + for(int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].r); + } + + // Top right pixels + for(int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + } + + // Bottom row pixels + for (int y = 1; y < h - 1; y += 2) { + int offset = y * w; + + // Bottom left pixels + for (int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + + // Bottom right pixels + for (int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].b); + } + } +} + + +static void rgb8_to_bayer_grbg8(const int w, const int h, + const uint8* src, uint8* dst) { + Color3uint8* srcColor = (Color3uint8*)src; + Color1uint8* dstColor = (Color1uint8*)dst; + + // Top row pixels + for (int y = 0; y < h - 1; y += 2) { + int offset = y * w; + + // Top left pixels + for (int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + + // Top right pixels + for (int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].r); + } + } + + // Bottom row pixels + for (int y = 1; y < h - 1; y += 2) { + int offset = y * w; + + // Bottom left pixels + for (int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].b); + } + + // Bottom right pixels + for (int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + } +} + + +static void rgb8_to_bayer_bggr8(const int w, const int h, + const uint8* src, uint8* dst) { + Color3uint8* srcColor = (Color3uint8*)src; + Color1uint8* dstColor = (Color1uint8*)dst; + + // Top row pixels + for (int y = 0; y < h - 1; y += 2) { + int offset = y * w; + + // Top left pixels + for (int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].b); + } + + // Top right pixels + for (int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + } + + // Bottom row pixels + for (int y = 1; y < h - 1; y += 2) { + int offset = y * w; + + // Bottom left pixels + for(int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + + // Bottom right pixels + for(int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].r); + } + } +} + + +static void rgb8_to_bayer_gbrg8(const int w, const int h, + const uint8* src, uint8* dst) { + Color3uint8* srcColor = (Color3uint8*)src; + Color1uint8* dstColor = (Color1uint8*)dst; + + // Top row pixels + for(int y = 0; y < h - 1; y += 2) { + int offset = y * w; + + // Top left pixels + for(int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + + // Top right pixels + for(int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].b); + } + } + + // Bottom row pixels + for(int y = 1; y < h - 1; y += 2) { + int offset = y * w; + + // Bottom left pixels + for(int x = 0; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].r); + } + + // Bottom right pixels + for(int x = 1; x < w - 1; x += 2) { + dstColor[x + offset] = Color1(srcColor[x + offset].g); + } + } +} + +// ===================================================================== +// rgba32f (-->rgb8) --> bayer converter implementations +// ===================================================================== +static void rgba32f_to_bayer_rggb8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg); + rgb8_to_bayer_rggb8(srcWidth, srcHeight, static_cast<uint8*>(tmp[0]), static_cast<uint8*>(dstBytes[0])); + + System::free(tmp[0]); +} + +static void rgba32f_to_bayer_gbrg8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg); + rgb8_to_bayer_grbg8(srcWidth, srcHeight, static_cast<uint8*>(tmp[0]), static_cast<uint8*>(dstBytes[0])); + + System::free(tmp[0]); +} + +static void rgba32f_to_bayer_grbg8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg); + rgb8_to_bayer_gbrg8(srcWidth, srcHeight, static_cast<uint8*>(tmp[0]), static_cast<uint8*>(dstBytes[0])); + + System::free(tmp[0]); +} + +static void rgba32f_to_bayer_bggr8(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg); + rgb8_to_bayer_bggr8(srcWidth, srcHeight, static_cast<uint8*>(tmp[0]), static_cast<uint8*>(dstBytes[0])); + + System::free(tmp[0]); +} + +// BAYER -> RGB color space + +// ===================================================================== +// bayer --> rgb8 helpers +// ===================================================================== +static void bayer_rggb8_to_rgb8_mhc(int w, int h, + const uint8* in, uint8* _out) { + debugAssert(in != _out); + + Color3uint8* out = (Color3uint8*)_out; + + for (int y = 0; y < h; ++y) { + + // Row beginning in the input array. + int offset = y * w; + + // RG row + for (int x = 0; x < w; ++x, ++out) { + // R pixel + { + out->r = in[x + offset]; + out->g = applyFilter(in, x, y, w, h, G_GRR); + out->b = applyFilter(in, x, y, w, h, B_GRR); + } + ++x; ++out; + + // G pixel + { + out->r = applyFilter(in, x, y, w, h, R_GRG); + out->g = in[x + offset]; + out->b = applyFilter(in, x, y, w, h, B_GRG); + } + } + + ++y; + offset += w; + + // GB row + for (int x = 0; x < w; ++x, ++out) { + // G pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGG); + out->g = in[x + offset]; + out->b = applyFilter(in, x, y, w, h, B_BGG); + } + ++x; ++out; + + // B pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGB); + out->g = applyFilter(in, x, y, w, h, G_BGB); + out->b = in[x + offset]; + } + } + } +} + + + +static void bayer_gbrg8_to_rgb8_mhc(int w, int h, + const uint8* in, uint8* _out) { + + debugAssert(in != _out); + + Color3uint8* out = (Color3uint8*)_out; + + for (int y = 0; y < h; ++y) { + + // Row beginning in the input array. + int offset = y * w; + + // GB row + for (int x = 0; x < w; ++x, ++out) { + // G pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGG); + out->g = in[x + offset]; + out->b = applyFilter(in, x, y, w, h, B_BGG); + } + ++x; ++out; + + // B pixel + { + out->r = applyFilter(in, x, y, w, h, R_BGB); + out->g = applyFilter(in, x, y, w, h, G_BGB); + out->b = in[x + offset]; + } + } + } +} + + +static void bayer_grbg8_to_rgb8_mhc(int w, int h, + const uint8* in, uint8* _out) { + // Run the equivalent function for red + bayer_gbrg8_to_rgb8_mhc(w, h, in, _out); + + // Now swap red and blue + swapRedAndBlue(w * h, (Color3uint8*)_out); +} + + +static void bayer_bggr8_to_rgb8_mhc(int w, int h, + const uint8* in, uint8* _out) { + // Run the equivalent function for red + bayer_rggb8_to_rgb8_mhc(w, h, in, _out); + + // Now swap red and blue + swapRedAndBlue(w * h, (Color3uint8*)_out); +} + +// ===================================================================== +// bayer (--> rgb8) --> rgba32f converter implementations +// ===================================================================== +static void bayer_rggb8_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + bayer_rggb8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const uint8*>(srcBytes[0]), static_cast<uint8*>(tmp[0])); + rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg); + + System::free(tmp[0]); +} + +static void bayer_gbrg8_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + bayer_grbg8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const uint8*>(srcBytes[0]), static_cast<uint8*>(tmp[0])); + rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg); + + System::free(tmp[0]); +} + +static void bayer_grbg8_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + bayer_gbrg8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const uint8*>(srcBytes[0]), static_cast<uint8*>(tmp[0])); + rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg); + + System::free(tmp[0]); +} + +static void bayer_bggr8_to_rgba32f(const Array<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits, const Array<void*>& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg) { + Array<void*> tmp; + tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3uint8))); + + bayer_bggr8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const uint8*>(srcBytes[0]), static_cast<uint8*>(tmp[0])); + rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg); + + System::free(tmp[0]); +} + + + + + + // TODO: The following region is commented out because so far + // those conversions are not used anywhere else. Until it is + // decided that such conversions are not needed, this region + // remains commented out. + + +// // ===================================================================== +// // bayer --> bgr8 +// // ===================================================================== + +// static void bayer_rggb8_to_bgr8_mhc(int w, int h, +// const uint8* in, uint8* _out) { +// debugAssert(in != _out); + +// Color3uint8* out = (Color3uint8*)_out; + +// for (int y = 0; y < h; ++y) { + +// // Row beginning in the input array. +// int offset = y * w; + +// // RG row +// for (int x = 0; x < w; ++x, ++out) { +// // R pixel +// { +// out->b = in[x + offset]; +// out->g = applyFilter(in, x, y, w, h, G_GRR); +// out->r = applyFilter(in, x, y, w, h, B_GRR); +// } +// ++x; ++out; + +// // G pixel +// { +// out->b = applyFilter(in, x, y, w, h, R_GRG); +// out->g = in[x + offset]; +// out->r = applyFilter(in, x, y, w, h, B_GRG); +// } +// } + +// ++y; +// offset += w; + +// // GB row +// for (int x = 0; x < w; ++x, ++out) { +// // G pixel +// { +// out->b = applyFilter(in, x, y, w, h, R_BGG); +// out->g = in[x + offset]; +// out->r = applyFilter(in, x, y, w, h, B_BGG); +// } +// ++x; ++out; + +// // B pixel +// { +// out->b = applyFilter(in, x, y, w, h, R_BGB); +// out->g = applyFilter(in, x, y, w, h, G_BGB); +// out->r = in[x + offset]; +// } +// } +// } +// } + + +// static void bayer_gbrg8_to_bgr8_mhc(int w, int h, +// const uint8* in, uint8* _out) { + +// debugAssert(in != _out); + +// Color3uint8* out = (Color3uint8*)_out; + +// for (int y = 0; y < h; ++y) { + +// // Row beginning in the input array. +// int offset = y * w; + +// // GB row +// for (int x = 0; x < srcWidth; ++x, ++out) { +// // G pixel +// { +// out->b = applyFilter(in, x, y, w, h, R_BGG); +// out->g = in[x + offset]; +// out->r = applyFilter(in, x, y, w, h, B_BGG); +// } +// ++x; ++out; + +// // B pixel +// { +// out->b = applyFilter(in, x, y, w, h, R_BGB); +// out->g = applyFilter(in, x, y, w, h, G_BGB); +// out->r = in[x + offset]; +// } +// } +// } +// } + +// static void bayer_grbg8_to_bgr8_mhc(int w, int h, +// const uint8* in, uint8* _out) { +// // Run the equivalent function for red +// bayer_gbrg8_to_bgr8_mhc(w, h, in, _out); + +// // Now swap red and blue +// swapRedAndBlue(srcWidth * h, (Color3uint8*)_out); +// } + +// static void bayer_bggr8_to_bgr8_mhc(int w, int h, +// const uint8* in, uint8* _out) { +// // Run the equivalent function for red +// bayer_rggb8_to_bgr8_mhc(w, h, in, _out); + +// // Now swap red and blue +// swapRedAndBlue(srcWidth * h, (Color3uint8*)_out); +// } + + + +/////////////////////////////////////////////////// + +} // namespace G3D diff --git a/dep/src/g3dlite/Intersect.cpp b/dep/src/g3dlite/Intersect.cpp new file mode 100644 index 00000000000..929a2e4e670 --- /dev/null +++ b/dep/src/g3dlite/Intersect.cpp @@ -0,0 +1,844 @@ +/** + @file Intersect.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2009-06-29 + @edited 2009-06-29 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + + From the G3D Innovation Engine + http://g3d.sf.net + */ +#include "G3D/Intersect.h" + +namespace G3D { + +#ifdef _MSC_VER +// Turn on fast floating-point optimizations +#pragma float_control( push ) +#pragma fp_contract( on ) +#pragma fenv_access( off ) +#pragma float_control( except, off ) +#pragma float_control( precise, off ) +#endif + +bool __fastcall Intersect::rayAABox(const Ray& ray, const AABox& box) { + switch (ray.classification) { + case Ray::MMM: + + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.lo.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.lo.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.lo.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.hi.x + ray.c_zx > 0) + ) + return false; + + return true; + + case Ray::MMP: + + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.lo.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.hi.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.lo.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.hi.x + ray.c_zx > 0) + ) + return false; + + return true; + + case Ray::MPM: + + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.lo.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.lo.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.lo.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.hi.x + ray.c_zx > 0) + ) + return false; + + return true; + + case Ray::MPP: + + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.lo.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.hi.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.lo.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.hi.x + ray.c_zx > 0) + ) + return false; + + return true; + + case Ray::PMM: + + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.hi.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.lo.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.hi.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.lo.x + ray.c_zx < 0) + ) + return false; + + return true; + + case Ray::PMP: + + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.hi.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.hi.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.hi.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.lo.x + ray.c_zx < 0) + ) + return false; + + return true; + + case Ray::PPM: + + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.hi.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.lo.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.hi.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.lo.x + ray.c_zx < 0) + ) + return false; + + return true; + + case Ray::PPP: + + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.hi.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.hi.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.hi.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.lo.x + ray.c_zx < 0)) { + return false; + } + + return true; + + case Ray::OMM: + + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyk * box.lo.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.hi.z + ray.c_yz > 0) + ) + return false; + + return true; + + case Ray::OMP: + + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyk * box.hi.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.lo.z + ray.c_yz < 0) + ) + return false; + + return true; + + case Ray::OPM: + + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyk * box.lo.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.hi.z + ray.c_yz > 0) + ) + return false; + + return true; + + case Ray::OPP: + + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyk * box.hi.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.lo.z + ray.c_yz < 0) + ) + return false; + + return true; + + case Ray::MOM: + + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.z < box.lo.z) + || (ray.kbyi * box.lo.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.hi.x + ray.c_zx > 0) + ) + return false; + + return true; + + case Ray::MOP: + + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.z > box.hi.z) + || (ray.kbyi * box.lo.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.hi.x + ray.c_zx > 0) + ) + return false; + + return true; + + case Ray::POM: + + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.z < box.lo.z) + || (ray.kbyi * box.hi.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.lo.x + ray.c_zx < 0) + ) + return false; + + return true; + + case Ray::POP: + + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.z > box.hi.z) + || (ray.kbyi * box.hi.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.lo.x + ray.c_zx < 0) + ) + return false; + + return true; + + case Ray::MMO: + + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.y < box.lo.y) + || (ray.jbyi * box.lo.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.hi.x + ray.c_yx > 0) + ) + return false; + + return true; + + case Ray::MPO: + + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.y > box.hi.y) + || (ray.jbyi * box.lo.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.hi.x + ray.c_yx > 0) + ) + return false; + + return true; + + case Ray::PMO: + + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.y < box.lo.y) + || (ray.jbyi * box.hi.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.lo.x + ray.c_yx < 0) + ) + return false; + + return true; + + case Ray::PPO: + + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.y > box.hi.y) + || (ray.jbyi * box.hi.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.lo.x + ray.c_yx < 0) + ) + return false; + + return true; + + case Ray::MOO: + + if((ray.m_origin.x < box.lo.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + ) + return false; + + return true; + + case Ray::POO: + + if((ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + ) + return false; + + return true; + + case Ray::OMO: + + if((ray.m_origin.y < box.lo.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + ) + return false; + + case Ray::OPO: + + if((ray.m_origin.y > box.hi.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + ) + return false; + + case Ray::OOM: + + if((ray.m_origin.z < box.lo.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + ) + return false; + + case Ray::OOP: + + if((ray.m_origin.z > box.hi.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + ) + return false; + + return true; + + } + + return false; +} + + +bool __fastcall Intersect::rayAABox(const Ray& ray, const AABox& box, float& time) { + + switch (ray.classification) { + case Ray::MMM: + { + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.lo.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.lo.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.lo.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.hi.x + ray.c_zx > 0)) { + return false; + } + + // compute the intersection distance + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::MMP: + { + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.lo.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.hi.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.lo.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.hi.x + ray.c_zx > 0)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::MPM: + { + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.lo.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.lo.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.lo.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.hi.x + ray.c_zx > 0)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::MPP: + { + if ((ray.m_origin.x < box.lo.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.lo.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.hi.x + ray.c_yx > 0) + || (ray.jbyk * box.hi.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.lo.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.hi.x + ray.c_zx > 0)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::PMM: + { + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.hi.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.lo.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.hi.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.lo.x + ray.c_zx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + + case Ray::PMP: + { + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.hi.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.hi.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.hi.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.lo.x + ray.c_zx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::PPM: + { + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyi * box.hi.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.lo.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.hi.z + ray.c_yz > 0) + || (ray.kbyi * box.hi.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.lo.x + ray.c_zx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::PPP: + { + if ((ray.m_origin.x > box.hi.x) || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyi * box.hi.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.lo.x + ray.c_yx < 0) + || (ray.jbyk * box.hi.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.lo.z + ray.c_yz < 0) + || (ray.kbyi * box.hi.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.lo.x + ray.c_zx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::OMM: + { + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyk * box.lo.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.hi.z + ray.c_yz > 0)) { + return false; + } + + time = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::OMP: + { + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyk * box.hi.z - box.hi.y + ray.c_zy > 0) + || (ray.kbyj * box.lo.y - box.lo.z + ray.c_yz < 0)) { + return false; + } + + time = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::OPM: + { + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z < box.lo.z) + || (ray.jbyk * box.lo.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.hi.z + ray.c_yz > 0)) { + return false; + } + + time = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::OPP: + { + if((ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y > box.hi.y) || (ray.m_origin.z > box.hi.z) + || (ray.jbyk * box.hi.z - box.lo.y + ray.c_zy < 0) + || (ray.kbyj * box.hi.y - box.lo.z + ray.c_yz < 0)) { + return false; + } + + time = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + + case Ray::MOM: + { + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.z < box.lo.z) + || (ray.kbyi * box.lo.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.hi.x + ray.c_zx > 0)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + + case Ray::MOP: + { + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.z > box.hi.z) + || (ray.kbyi * box.lo.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.hi.x + ray.c_zx > 0)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::POM: + { + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.z < box.lo.z) + || (ray.kbyi * box.hi.x - box.hi.z + ray.c_xz > 0) + || (ray.ibyk * box.lo.z - box.lo.x + ray.c_zx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t2 = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + + case Ray::POP: + { + if((ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.z > box.hi.z) + || (ray.kbyi * box.hi.x - box.lo.z + ray.c_xz < 0) + || (ray.ibyk * box.hi.z - box.lo.x + ray.c_zx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t2 = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + if (t2 > time) { + time = t2; + } + + return true; + } + + case Ray::MMO: + { + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.y < box.lo.y) + || (ray.jbyi * box.lo.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.hi.x + ray.c_yx > 0)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + + return true; + } + + case Ray::MPO: + { + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.y > box.hi.y) + || (ray.jbyi * box.lo.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.hi.x + ray.c_yx > 0)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + + return true; + } + + + case Ray::PMO: + { + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.y < box.lo.y) + || (ray.jbyi * box.hi.x - box.hi.y + ray.c_xy > 0) + || (ray.ibyj * box.lo.y - box.lo.x + ray.c_yx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + + return true; + } + + case Ray::PPO: + { + if((ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z) + || (ray.m_origin.x > box.hi.x) || (ray.m_origin.y > box.hi.y) + || (ray.jbyi * box.hi.x - box.lo.y + ray.c_xy < 0) + || (ray.ibyj * box.hi.y - box.lo.x + ray.c_yx < 0)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + float t1 = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + if (t1 > time) { + time = t1; + } + + return true; + } + + + case Ray::MOO: + { + if((ray.m_origin.x < box.lo.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z)) { + return false; + } + + time = (box.hi.x - ray.m_origin.x) * ray.m_invDirection.x; + return true; + } + + case Ray::POO: + { + if ((ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z)) { + return false; + } + + time = (box.lo.x - ray.m_origin.x) * ray.m_invDirection.x; + return true; + } + + case Ray::OMO: + { + if ((ray.m_origin.y < box.lo.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z)) { + return false; + } + + time = (box.hi.y - ray.m_origin.y) * ray.m_invDirection.y; + return true; + } + + case Ray::OPO: + { + if ((ray.m_origin.y > box.hi.y) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.z < box.lo.z) || (ray.m_origin.z > box.hi.z)) { + return false; + } + + time = (box.lo.y - ray.m_origin.y) * ray.m_invDirection.y; + return true; + } + + + case Ray::OOM: + { + if ((ray.m_origin.z < box.lo.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y)) { + return false; + } + + time = (box.hi.z - ray.m_origin.z) * ray.m_invDirection.z; + return true; + } + + case Ray::OOP: + { + if ((ray.m_origin.z > box.hi.z) + || (ray.m_origin.x < box.lo.x) || (ray.m_origin.x > box.hi.x) + || (ray.m_origin.y < box.lo.y) || (ray.m_origin.y > box.hi.y)) { + return false; + } + + time = (box.lo.z - ray.m_origin.z) * ray.m_invDirection.z; + return true; + } + } + + return false; +} + +#ifdef _MSC_VER +// Turn off fast floating-point optimizations +#pragma float_control( pop ) +#endif + +} diff --git a/dep/src/g3dlite/Line.cpp b/dep/src/g3dlite/Line.cpp new file mode 100644 index 00000000000..195ae7197f2 --- /dev/null +++ b/dep/src/g3dlite/Line.cpp @@ -0,0 +1,89 @@ +/** + @file Line.cpp + + Line class + + @maintainer Morgan McGuire, graphics3d.com + + @created 2001-06-02 + @edited 2006-01-28 + */ + +#include "G3D/Line.h" +#include "G3D/Plane.h" + +namespace G3D { + +Vector3 Line::intersection(const Plane& plane) const { + float d; + Vector3 normal = plane.normal(); + plane.getEquation(normal, d); + float rate = _direction.dot(normal); + + if (rate == 0) { + + return Vector3::inf(); + + } else { + float t = -(d + _point.dot(normal)) / rate; + + return _point + _direction * t; + } +} + + +Line::Line(class BinaryInput& b) { + deserialize(b); +} + + +void Line::serialize(class BinaryOutput& b) const { + _point.serialize(b); + _direction.serialize(b); +} + + +void Line::deserialize(class BinaryInput& b) { + _point.deserialize(b); + _direction.deserialize(b); +} + + +Vector3 Line::closestPoint(const Vector3& pt) const { + float t = _direction.dot(pt - _point); + return _point + _direction * t; +} + + +Vector3 Line::point() const { + return _point; +} + + +Vector3 Line::direction() const { + return _direction; +} + + +Vector3 Line::closestPoint(const Line& B, float& minDist) const { + const Vector3& P1 = _point; + const Vector3& U1 = _direction; + + Vector3 P2 = B.point(); + Vector3 U2 = B.direction(); + + const Vector3& P21 = P2 - P1; + const Vector3& M = U2.cross(U1); + float m2 = M.length(); + + Vector3 R = P21.cross(M) / m2; + + float t1 = R.dot(U2); + + minDist = abs(P21.dot(M)) / sqrt(m2); + + return P1 + t1 * U1; +} + +} + diff --git a/dep/src/g3dlite/LineSegment.cpp b/dep/src/g3dlite/LineSegment.cpp new file mode 100644 index 00000000000..754600ad554 --- /dev/null +++ b/dep/src/g3dlite/LineSegment.cpp @@ -0,0 +1,236 @@ +/** + @file LineSegment.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-02-08 + @edited 2008-02-02 + */ + +#include "G3D/platform.h" +#include "G3D/LineSegment.h" +#include "G3D/Sphere.h" +#include "G3D/debug.h" + +namespace G3D { + + +Vector3 LineSegment::closestPoint(const Vector3& p) const { + + // The vector from the end of the capsule to the point in question. + Vector3 v(p - _point); + + // Projection of v onto the line segment scaled by + // the length of direction. + float t = direction.dot(v); + + // Avoid some square roots. Derivation: + // t/direction.length() <= direction.length() + // t <= direction.squaredLength() + + if ((t >= 0) && (t <= direction.squaredMagnitude())) { + + // The point falls within the segment. Normalize direction, + // divide t by the length of direction. + return _point + direction * t / direction.squaredMagnitude(); + + } else { + + // The point does not fall within the segment; see which end is closer. + + // Distance from 0, squared + float d0Squared = v.squaredMagnitude(); + + // Distance from 1, squared + float d1Squared = (v - direction).squaredMagnitude(); + + if (d0Squared < d1Squared) { + + // Point 0 is closer + return _point; + + } else { + + // Point 1 is closer + return _point + direction; + + } + } + +} + +Vector3 LineSegment::point(int i) const { + switch (i) { + case 0: + return _point; + + case 1: + return _point + direction; + + default: + debugAssertM(i == 0 || i == 1, "Argument to point must be 0 or 1"); + return _point; + } +} + + +bool LineSegment::intersectsSolidSphere(const class Sphere& s) const { + return distanceSquared(s.center) <= square(s.radius); +} + + +LineSegment::LineSegment(class BinaryInput& b) { + deserialize(b); +} + + +void LineSegment::serialize(class BinaryOutput& b) const { + _point.serialize(b); + direction.serialize(b); +} + + +void LineSegment::deserialize(class BinaryInput& b) { + _point.deserialize(b); + direction.deserialize(b); +} + + +Vector3 LineSegment::randomPoint() const { + return _point + uniformRandom(0, 1) * direction; +} + + +///////////////////////////////////////////////////////////////////////////////////// + +LineSegment2D LineSegment2D::fromTwoPoints(const Vector2& p0, const Vector2& p1) { + LineSegment2D s; + s.m_origin = p0; + s.m_direction = p1 - p0; + s.m_length = s.m_direction.length(); + return s; +} + + +Vector2 LineSegment2D::point(int i) const { + debugAssert(i == 0 || i == 1); + if (i == 0) { + return m_origin; + } else { + return m_direction + m_origin; + } +} + + +Vector2 LineSegment2D::closestPoint(const Vector2& Q) const { + // Two constants that appear in the result + const Vector2 k1(m_origin - Q); + const Vector2& k2 = m_direction; + + if (fuzzyEq(m_length, 0)) { + // This line segment has no length + return m_origin; + } + + // Time [0, 1] at which we hit the closest point travelling from p0 to p1. + // Derivation can be obtained by minimizing the expression + // ||P0 + (P1 - P0)t - Q||. + const float t = -k1.dot(k2) / (m_length * m_length); + + if (t < 0) { + // Clipped to low end point + return m_origin; + } else if (t > 1) { + // Clipped to high end point + return m_origin + m_direction; + } else { + // Subsitute into the line equation to find + // the point on the segment. + return m_origin + k2 * t; + } +} + + +float LineSegment2D::distance(const Vector2& p) const { + Vector2 closest = closestPoint(p); + return (closest - p).length(); +} + + +float LineSegment2D::length() const { + return m_length; +} + + +Vector2 LineSegment2D::intersection(const LineSegment2D& other) const { + + if ((m_origin == other.m_origin) || + (m_origin == other.m_origin + other.m_direction)) { + return m_origin; + } + + if (m_origin + m_direction == other.m_origin) { + return other.m_origin; + } + + // Note: Now that we've checked the endpoints, all other parallel lines can now be assumed + // to not intersect (within numerical precision) + + Vector2 dir1 = m_direction; + Vector2 dir2 = other.m_direction; + Vector2 origin1 = m_origin; + Vector2 origin2 = other.m_origin; + + if (dir1.x == 0) { + // Avoid an upcoming divide by zero + dir1 = dir1.yx(); + dir2 = dir2.yx(); + origin1 = origin1.yx(); + origin2 = origin2.yx(); + } + + // t1 = ((other.m_origin.x - m_origin.x) + other.m_direction.x * t2) / m_direction.x + // + // ((other.m_origin.x - m_origin.x) + other.m_direction.x * t2) * m_direction.y / m_direction.x = + // (other.m_origin.y - m_origin.y) + other.m_direction.y * t2 + // + // m = m_direction.y / m_direction.x + // d = other.m_origin - m_origin + // + // (d.x + other.m_direction.x * t2) * m = d.y + other.m_direction.y * t2 + // + // d.x * m + other.m_direction.x * m * t2 = d.y + other.m_direction.y * t2 + // + // d.x * m - d.y = (other.m_direction.y - other.m_direction.x * m) * t2 + // + // (d.x * m - d.y) / (other.m_direction.y - other.m_direction.x * m) = t2 + // + + Vector2 d = origin2 - origin1; + float m = dir1.y / dir1.x; + + float t2 = (d.x * m - d.y) / (dir2.y - dir2.x * m); + if (! isFinite(t2)) { + // Parallel lines: no intersection + return Vector2::inf(); + } + + if ((t2 < 0.0f) || (t2 > 1.0f)) { + // Intersection occurs past the end of the line segments + return Vector2::inf(); + } + + float t1 = (d.x + dir2.x * t2) / dir1.x; + if ((t1 < 0.0f) || (t1 > 1.0f)) { + // Intersection occurs past the end of the line segments + return Vector2::inf(); + } + + // Return the intersection point (computed from non-transposed + // variables even if we flipped above) + return m_origin + m_direction * t1; + +} + +} + diff --git a/dep/src/g3dlite/Log.cpp b/dep/src/g3dlite/Log.cpp new file mode 100644 index 00000000000..07614fcf563 --- /dev/null +++ b/dep/src/g3dlite/Log.cpp @@ -0,0 +1,146 @@ +/** + @file Log.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2001-08-04 + @edited 2009-01-15 + */ + +#include "G3D/platform.h" +#include "G3D/Log.h" +#include "G3D/format.h" +#include "G3D/Array.h" +#include "G3D/fileutils.h" +#include <time.h> + +#ifdef G3D_WIN32 + #include <imagehlp.h> +#else + #include <stdarg.h> +#endif + +namespace G3D { + +void logPrintf(const char* fmt, ...) { + va_list arg_list; + va_start(arg_list, fmt); + Log::common()->vprintf(fmt, arg_list); + va_end(arg_list); +} + + +void logLazyPrintf(const char* fmt, ...) { + va_list arg_list; + va_start(arg_list, fmt); + Log::common()->lazyvprintf(fmt, arg_list); + va_end(arg_list); +} + +Log* Log::commonLog = NULL; + +Log::Log(const std::string& filename, int stripFromStackBottom) : + stripFromStackBottom(stripFromStackBottom) { + + this->filename = filename; + + logFile = fopen(filename.c_str(), "w"); + + if (logFile == NULL) { + std::string drive, base, ext; + Array<std::string> path; + parseFilename(filename, drive, path, base, ext); + std::string logName = base + ((ext != "") ? ("." + ext) : ""); + + // Write time is greater than 1ms. This may be a network drive.... try another file. + #ifdef G3D_WIN32 + logName = std::string(std::getenv("TEMP")) + logName; + #else + logName = std::string("/tmp/") + logName; + #endif + + logFile = fopen(logName.c_str(), "w"); + } + + // Use a large buffer (although we flush in logPrintf) + setvbuf(logFile, NULL, _IOFBF, 2048); + + fprintf(logFile, "Application Log\n"); + time_t t; + time(&t); + fprintf(logFile, "Start: %s\n", ctime(&t)); + fflush(logFile); + + if (commonLog == NULL) { + commonLog = this; + } +} + + +Log::~Log() { + section("Shutdown"); + println("Closing log file"); + + // Make sure we don't leave a dangling pointer + if (Log::commonLog == this) { + Log::commonLog = NULL; + } + + fclose(logFile); +} + + +FILE* Log::getFile() const { + return logFile; +} + + +Log* Log::common() { + if (commonLog == NULL) { + commonLog = new Log(); + } + return commonLog; +} + + +std::string Log::getCommonLogFilename() { + return common()->filename; +} + + +void Log::section(const std::string& s) { + fprintf(logFile, "_____________________________________________________\n"); + fprintf(logFile, "\n ### %s ###\n\n", s.c_str()); +} + + +void __cdecl Log::printf(const char* fmt, ...) { + va_list arg_list; + va_start(arg_list, fmt); + print(vformat(fmt, arg_list)); + va_end(arg_list); +} + + +void __cdecl Log::vprintf(const char* fmt, va_list argPtr) { + vfprintf(logFile, fmt, argPtr); + fflush(logFile); +} + + +void __cdecl Log::lazyvprintf(const char* fmt, va_list argPtr) { + vfprintf(logFile, fmt, argPtr); +} + + +void Log::print(const std::string& s) { + fprintf(logFile, "%s", s.c_str()); + fflush(logFile); +} + + +void Log::println(const std::string& s) { + fprintf(logFile, "%s\n", s.c_str()); + fflush(logFile); +} + +} diff --git a/dep/src/g3dlite/Makefile.am b/dep/src/g3dlite/Makefile.am new file mode 100644 index 00000000000..d37528b4c72 --- /dev/null +++ b/dep/src/g3dlite/Makefile.am @@ -0,0 +1,69 @@ +## Modified for MaNGOS project <http://getmangos.com> +## +## Permission is hereby granted, free of charge, to any person obtaining a copy +## of this software and associated documentation files (the "Software"), to deal +## in the Software without restriction, including without limitation the rights +## to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +## copies of the Software, and to permit persons to whom the Software is furnished +## to do so, subject to the following conditions: +## +## The above copyright notice and this permission notice shall be included in all +## copies or substantial portions of the Software. +## +## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +## IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +## FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +## AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +## WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +## CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +## Process this file with automake to produce Makefile.in + +## CPP flags for includes, defines, etc. +AM_CPPFLAGS = -I$(srcdir) -I$(srcdir)/../../include -I$(srcdir)/../../include/g3dlite + +noinst_LIBRARIES = libg3dlite.a +libg3dlite_a_SOURCES = \ + AABox.cpp \ + Box.cpp \ + Crypto.cpp \ + format.cpp \ + Matrix3.cpp \ + Plane.cpp \ + System.cpp \ + Triangle.cpp \ + Vector3.cpp \ + Vector4.cpp \ + debugAssert.cpp \ + fileutils.cpp \ + g3dmath.cpp \ + g3dfnmatch.cpp \ + prompt.cpp \ + stringutils.cpp \ + Any.cpp \ + BinaryFormat.cpp \ + BinaryInput.cpp \ + BinaryOutput.cpp \ + Capsule.cpp \ + CollisionDetection.cpp \ + CoordinateFrame.cpp \ + Cylinder.cpp \ + Line.cpp \ + LineSegment.cpp \ + Log.cpp \ + Matrix4.cpp \ + MemoryManager.cpp \ + Quat.cpp \ + Random.cpp \ + Ray.cpp \ + ReferenceCount.cpp \ + Sphere.cpp \ + TextInput.cpp \ + TextOutput.cpp \ + UprightFrame.cpp \ + Vector2.cpp + +EXTRA_DIST = \ + license.html + + diff --git a/dep/src/g3dlite/Matrix.cpp b/dep/src/g3dlite/Matrix.cpp new file mode 100644 index 00000000000..7a668e59e2c --- /dev/null +++ b/dep/src/g3dlite/Matrix.cpp @@ -0,0 +1,1802 @@ +/** + @file Matrix.cpp + @author Morgan McGuire, http://graphics.cs.williams.edu + */ +#include "G3D/Matrix.h" +#include "G3D/TextOutput.h" + +static inline G3D::Matrix::T negate(G3D::Matrix::T x) { + return -x; +} + +namespace G3D { + +int Matrix::debugNumCopyOps = 0; +int Matrix::debugNumAllocOps = 0; + +void Matrix::serialize(TextOutput& t) const { + t.writeSymbol("%"); + t.writeNumber(rows()); + t.writeSymbol("x"); + t.writeNumber(cols()); + t.pushIndent(); + t.writeNewline(); + + t.writeSymbol("["); + for (int r = 0; r < rows(); ++r) { + for (int c = 0; c < cols(); ++c) { + t.writeNumber(impl->get(r, c)); + if (c < cols() - 1) { + t.writeSymbol(","); + } else { + if (r < rows() - 1) { + t.writeSymbol(";"); + t.writeNewline(); + } + } + } + } + t.writeSymbol("]"); + t.popIndent(); + t.writeNewline(); +} + + +std::string Matrix::toString(const std::string& name) const { + std::string s; + + if (name != "") { + s += format("%s = \n", name.c_str()); + } + + s += "["; + for (int r = 0; r < rows(); ++r) { + for (int c = 0; c < cols(); ++c) { + double v = impl->get(r, c); + + if (::fabs(v) < 0.00001) { + // Don't print "negative zero" + s += format("% 10.04g", 0.0); + } else if (v == iRound(v)) { + // Print integers nicely + s += format("% 10.04g", v); + } else { + s += format("% 10.04f", v); + } + + if (c < cols() - 1) { + s += ","; + } else if (r < rows() - 1) { + s += ";\n "; + } else { + s += "]\n"; + } + } + } + return s; +} + + +#define INPLACE(OP)\ + ImplRef A = impl;\ +\ + if (! A.isLastReference()) {\ + impl = new Impl(A->R, A->C);\ + }\ +\ + A->OP(B, *impl); + +Matrix& Matrix::operator*=(const T& B) { + INPLACE(mul) + return *this; +} + + +Matrix& Matrix::operator-=(const T& B) { + INPLACE(sub) + return *this; +} + + +Matrix& Matrix::operator+=(const T& B) { + INPLACE(add) + return *this; +} + + +Matrix& Matrix::operator/=(const T& B) { + INPLACE(div) + return *this; +} + + +Matrix& Matrix::operator*=(const Matrix& B) { + // We can't optimize this one + *this = *this * B; + return *this; +} + + +Matrix& Matrix::operator-=(const Matrix& _B) { + const Impl& B = *_B.impl; + INPLACE(sub) + return *this; +} + + +Matrix& Matrix::operator+=(const Matrix& _B) { + const Impl& B = *_B.impl; + INPLACE(add) + return *this; +} + + +void Matrix::arrayMulInPlace(const Matrix& _B) { + const Impl& B = *_B.impl; + INPLACE(arrayMul) +} + + +void Matrix::arrayDivInPlace(const Matrix& _B) { + const Impl& B = *_B.impl; + INPLACE(arrayDiv) +} + +#undef INPLACE + +Matrix Matrix::fromDiagonal(const Matrix& d) { + debugAssert((d.rows() == 1) || (d.cols() == 1)); + + int n = d.numElements(); + Matrix D = zero(n, n); + for (int i = 0; i < n; ++i) { + D.set(i, i, d.impl->data[i]); + } + + return D; +} + +void Matrix::set(int r, int c, T v) { + if (! impl.isLastReference()) { + // Copy the data before mutating; this object is shared + impl = new Impl(*impl); + } + impl->set(r, c, v); +} + + +void Matrix::setRow(int r, const Matrix& vec) { + debugAssertM(vec.cols() == cols(), + "A row must be set to a vector of the same size."); + debugAssertM(vec.rows() == 1, + "A row must be set to a row vector."); + + debugAssert(r >= 0); + debugAssert(r < rows()); + + if (! impl.isLastReference()) { + // Copy the data before mutating; this object is shared + impl = new Impl(*impl); + } + impl->setRow(r, vec.impl->data); +} + + +void Matrix::setCol(int c, const Matrix& vec) { + debugAssertM(vec.rows() == rows(), + "A column must be set to a vector of the same size."); + debugAssertM(vec.cols() == 1, + "A column must be set to a column vector."); + + debugAssert(c >= 0); + + debugAssert(c < cols()); + + if (! impl.isLastReference()) { + // Copy the data before mutating; this object is shared + impl = new Impl(*impl); + } + impl->setCol(c, vec.impl->data); +} + + +Matrix::T Matrix::get(int r, int c) const { + return impl->get(r, c); +} + + +Matrix Matrix::row(int r) const { + debugAssert(r >= 0); + debugAssert(r < rows()); + Matrix out(1, cols()); + out.impl->setRow(1, impl->elt[r]); + return out; +} + + +Matrix Matrix::col(int c) const { + debugAssert(c >= 0); + debugAssert(c < cols()); + Matrix out(rows(), 1); + + T* outData = out.impl->data; + // Get a pointer to the first element in the column + const T* inElt = &(impl->elt[0][c]); + int R = rows(); + int C = cols(); + for (int r = 0; r < R; ++r) { + outData[r] = *inElt; + // Skip around to the next row + inElt += C; + } + + return out; +} + + +Matrix Matrix::zero(int R, int C) { + Impl* A = new Impl(R, C); + A->setZero(); + return Matrix(A); +} + + +Matrix Matrix::one(int R, int C) { + Impl* A = new Impl(R, C); + for (int i = R * C - 1; i >= 0; --i) { + A->data[i] = 1.0; + } + return Matrix(A); +} + + +Matrix Matrix::random(int R, int C) { + Impl* A = new Impl(R, C); + for (int i = R * C - 1; i >= 0; --i) { + A->data[i] = G3D::uniformRandom(0.0, 1.0); + } + return Matrix(A); +} + + +Matrix Matrix::identity(int N) { + Impl* m = new Impl(N, N); + m->setZero(); + for (int i = 0; i < N; ++i) { + m->elt[i][i] = 1.0; + } + return Matrix(m); +} + + +// Implement an explicit-output unary method by trampolining to the impl +#define TRAMPOLINE_EXPLICIT_1(method)\ +void Matrix::method(Matrix& out) const {\ + if ((out.impl == impl) && impl.isLastReference()) {\ + impl->method(*out.impl);\ + } else {\ + out = this->method();\ + }\ +} + +TRAMPOLINE_EXPLICIT_1(abs) +TRAMPOLINE_EXPLICIT_1(negate) +TRAMPOLINE_EXPLICIT_1(arrayLog) +TRAMPOLINE_EXPLICIT_1(arrayExp) +TRAMPOLINE_EXPLICIT_1(arrayCos) +TRAMPOLINE_EXPLICIT_1(arraySin) + +void Matrix::mulRow(int r, const T& v) { + debugAssert(r >= 0 && r < rows()); + + if (! impl.isLastReference()) { + impl = new Impl(*impl); + } + + impl->mulRow(r, v); +} + + +void Matrix::transpose(Matrix& out) const { + if ((out.impl == impl) && impl.isLastReference() && (impl->R == impl->C)) { + // In place + impl->transpose(*out.impl); + } else { + out = this->transpose(); + } +} + + +Matrix3 Matrix::toMatrix3() const { + debugAssert(impl->R == 3); + debugAssert(impl->C == 3); + return Matrix3( + impl->get(0,0), impl->get(0,1), impl->get(0,2), + impl->get(1,0), impl->get(1,1), impl->get(1,2), + impl->get(2,0), impl->get(2,1), impl->get(2,2)); +} + + +Matrix4 Matrix::toMatrix4() const { + debugAssert(impl->R == 4); + debugAssert(impl->C == 4); + return Matrix4( + impl->get(0,0), impl->get(0,1), impl->get(0,2), impl->get(0,3), + impl->get(1,0), impl->get(1,1), impl->get(1,2), impl->get(1,3), + impl->get(2,0), impl->get(2,1), impl->get(2,2), impl->get(2,3), + impl->get(3,0), impl->get(3,1), impl->get(3,2), impl->get(3,3)); +} + + +Vector2 Matrix::toVector2() const { + debugAssert(impl->R * impl->C == 2); + if (impl->R > impl->C) { + return Vector2(impl->get(0,0), impl->get(1,0)); + } else { + return Vector2(impl->get(0,0), impl->get(0,1)); + } +} + + +Vector3 Matrix::toVector3() const { + debugAssert(impl->R * impl->C == 3); + if (impl->R > impl->C) { + return Vector3(impl->get(0,0), impl->get(1,0), impl->get(2, 0)); + } else { + return Vector3(impl->get(0,0), impl->get(0,1), impl->get(0, 2)); + } +} + + +Vector4 Matrix::toVector4() const { + debugAssert( + ((impl->R == 4) && (impl->C == 1)) || + ((impl->R == 1) && (impl->C == 4))); + + if (impl->R > impl->C) { + return Vector4(impl->get(0,0), impl->get(1,0), impl->get(2, 0), impl->get(3,0)); + } else { + return Vector4(impl->get(0,0), impl->get(0,1), impl->get(0, 2), impl->get(0,3)); + } +} + + +void Matrix::swapRows(int r0, int r1) { + debugAssert(r0 >= 0 && r0 < rows()); + debugAssert(r1 >= 0 && r1 < rows()); + + if (r0 == r1) { + return; + } + + if (! impl.isLastReference()) { + impl = new Impl(*impl); + } + + impl->swapRows(r0, r1); +} + + +void Matrix::swapAndNegateCols(int c0, int c1) { + debugAssert(c0 >= 0 && c0 < cols()); + debugAssert(c1 >= 0 && c1 < cols()); + + if (c0 == c1) { + return; + } + + if (! impl.isLastReference()) { + impl = new Impl(*impl); + } + + impl->swapAndNegateCols(c0, c1); +} + +Matrix Matrix::subMatrix(int r1, int r2, int c1, int c2) const { + debugAssert(r2>=r1); + debugAssert(c2>=c1); + debugAssert(c2<cols()); + debugAssert(r2<rows()); + debugAssert(r1>=0); + debugAssert(c1>=0); + + Matrix X(r2 - r1 + 1, c2 - c1 + 1); + + for (int r = 0; r < X.rows(); ++r) { + for (int c = 0; c < X.cols(); ++c) { + X.set(r, c, get(r + r1, c + c1)); + } + } + + return X; +} + + +bool Matrix::anyNonZero() const { + return impl->anyNonZero(); +} + + +bool Matrix::allNonZero() const { + return impl->allNonZero(); +} + + +void Matrix::svd(Matrix& U, Array<T>& d, Matrix& V, bool sort) const { + debugAssert(rows() >= cols()); + debugAssertM(&U != &V, "Arguments to SVD must be different matrices"); + debugAssertM(&U != this, "Arguments to SVD must be different matrices"); + debugAssertM(&V != this, "Arguments to SVD must be different matrices"); + + int R = rows(); + int C = cols(); + + // Make sure we don't overwrite a shared matrix + if (! V.impl.isLastReference()) { + V = Matrix::zero(C, C); + } else { + V.impl->setSize(C, C); + } + + if (&U != this || ! impl.isLastReference()) { + // Make a copy of this for in-place SVD + U.impl = new Impl(*impl); + } + + d.resize(C); + const char* ret = svdCore(U.impl->elt, R, C, d.getCArray(), V.impl->elt); + + debugAssertM(ret == NULL, ret); + (void)ret; + + if (sort) { + // Sort the singular values from greatest to least + + Array<SortRank> rank; + rank.resize(C); + for (int c = 0; c < C; ++c) { + rank[c].col = c; + rank[c].value = d[c]; + } + + rank.sort(SORT_INCREASING); + + Matrix Uold = U; + Matrix Vold = V; + + U = Matrix(U.rows(), U.cols()); + V = Matrix(V.rows(), V.cols()); + + // Now permute U, d, and V appropriately + for (int c0 = 0; c0 < C; ++c0) { + const int c1 = rank[c0].col; + + d[c0] = rank[c0].value; + U.setCol(c0, Uold.col(c1)); + V.setCol(c0, Vold.col(c1)); + } + + } +} + + +#define COMPARE_SCALAR(OP)\ +Matrix Matrix::operator OP (const T& scalar) const {\ + int R = rows();\ + int C = cols();\ + int N = R * C;\ + Matrix out = Matrix::zero(R, C);\ +\ + const T* raw = impl->data;\ + T* outRaw = out.impl->data;\ + for (int i = 0; i < N; ++i) {\ + outRaw[i] = raw[i] OP scalar;\ + }\ +\ + return out;\ +} + +COMPARE_SCALAR(<) +COMPARE_SCALAR(<=) +COMPARE_SCALAR(>) +COMPARE_SCALAR(>=) +COMPARE_SCALAR(==) +COMPARE_SCALAR(!=) + +#undef COMPARE_SCALAR + +double Matrix::normSquared() const { + int R = rows(); + int C = cols(); + int N = R * C; + + double sum = 0.0; + + const T* raw = impl->data; + for (int i = 0; i < N; ++i) { + sum += square(raw[i]); + } + + return sum; +} + +double Matrix::norm() const { + return sqrt(normSquared()); +} + +/////////////////////////////////////////////////////////// + +Matrix::Impl::Impl(const Matrix3& M) : elt(NULL), data(NULL), R(0), C(0), dataSize(0){ + setSize(3, 3); + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + set(r, c, M[r][c]); + } + } + +} + + +Matrix::Impl::Impl(const Matrix4& M): elt(NULL), data(NULL), R(0), C(0), dataSize(0) { + setSize(4, 4); + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + set(r, c, M[r][c]); + } + } +} + + +void Matrix::Impl::setSize(int newRows, int newCols) { + if ((R == newRows) && (C == newCols)) { + // Nothing to do + return; + } + + int newSize = newRows * newCols; + + R = newRows; C = newCols; + + // Only allocate if we need more space + // or the size difference is ridiculous + if ((newSize > dataSize) || (newSize < dataSize / 4)) { + System::alignedFree(data); + data = (float*)System::alignedMalloc(R * C * sizeof(T), 16); + ++Matrix::debugNumAllocOps; + dataSize = newSize; + } + + // Construct the row pointers + //delete[] elt; + System::free(elt); + elt = (T**)System::malloc(R * sizeof(T*));// new T*[R]; + + for (int r = 0; r < R; ++ r) { + elt[r] = data + r * C; + } +} + + +Matrix::Impl::~Impl() { + //delete[] elt; + System::free(elt); + System::alignedFree(data); +} + + +Matrix::Impl& Matrix::Impl::operator=(const Impl& m) { + setSize(m.R, m.C); + System::memcpy(data, m.data, R * C * sizeof(T)); + ++Matrix::debugNumCopyOps; + return *this; +} + + +void Matrix::Impl::setZero() { + System::memset(data, 0, R * C * sizeof(T)); +} + + +void Matrix::Impl::swapRows(int r0, int r1) { + T* R0 = elt[r0]; + T* R1 = elt[r1]; + + for (int c = 0; c < C; ++c) { + T temp = R0[c]; + R0[c] = R1[c]; + R1[c] = temp; + } +} + + +void Matrix::Impl::swapAndNegateCols(int c0, int c1) { + for (int r = 0; r < R; ++r) { + T* row = elt[r]; + + const T temp = -row[c0]; + row[c0] = -row[c1]; + row[c1] = temp; + } +} + + +void Matrix::Impl::mulRow(int r, const T& v) { + T* row = elt[r]; + + for (int c = 0; c < C; ++c) { + row[c] *= v; + } +} + + +void Matrix::Impl::mul(const Impl& B, Impl& out) const { + const Impl& A = *this; + + debugAssertM( + (this != &out) && (&B != &out), + "Output argument to mul cannot be the same as an input argument."); + + debugAssert(A.C == B.R); + debugAssert(A.R == out.R); + debugAssert(B.C == out.C); + + for (int r = 0; r < out.R; ++r) { + for (int c = 0; c < out.C; ++c) { + T sum = 0.0; + for (int i = 0; i < A.C; ++i) { + sum += A.get(r, i) * B.get(i, c); + } + out.set(r, c, sum); + } + } +} + + +// We're about to define several similar methods, +// so use a macro to share implementations. This +// must be a macro because the difference between +// the macros is the operation in the inner loop. +#define IMPLEMENT_ARRAY_2(method, OP)\ +void Matrix::Impl::method(const Impl& B, Impl& out) const {\ + const Impl& A = *this;\ + \ + debugAssert(A.C == B.C);\ + debugAssert(A.R == B.R);\ + debugAssert(A.C == out.C);\ + debugAssert(A.R == out.R);\ + \ + for (int i = R * C - 1; i >= 0; --i) {\ + out.data[i] = A.data[i] OP B.data[i];\ + }\ +} + + +#define IMPLEMENT_ARRAY_1(method, f)\ +void Matrix::Impl::method(Impl& out) const {\ + const Impl& A = *this;\ + \ + debugAssert(A.C == out.C);\ + debugAssert(A.R == out.R);\ + \ + for (int i = R * C - 1; i >= 0; --i) {\ + out.data[i] = f(A.data[i]);\ + }\ +} + + +#define IMPLEMENT_ARRAY_SCALAR(method, OP)\ +void Matrix::Impl::method(Matrix::T B, Impl& out) const {\ + const Impl& A = *this;\ + \ + debugAssert(A.C == out.C);\ + debugAssert(A.R == out.R);\ + \ + for (int i = R * C - 1; i >= 0; --i) {\ + out.data[i] = A.data[i] OP B;\ + }\ +} + +IMPLEMENT_ARRAY_2(add, +) +IMPLEMENT_ARRAY_2(sub, -) +IMPLEMENT_ARRAY_2(arrayMul, *) +IMPLEMENT_ARRAY_2(arrayDiv, /) + +IMPLEMENT_ARRAY_SCALAR(add, +) +IMPLEMENT_ARRAY_SCALAR(sub, -) +IMPLEMENT_ARRAY_SCALAR(mul, *) +IMPLEMENT_ARRAY_SCALAR(div, /) + +IMPLEMENT_ARRAY_1(abs, ::fabs) +IMPLEMENT_ARRAY_1(negate, ::negate) +IMPLEMENT_ARRAY_1(arrayLog, ::log) +IMPLEMENT_ARRAY_1(arraySqrt, ::sqrt) +IMPLEMENT_ARRAY_1(arrayExp, ::exp) +IMPLEMENT_ARRAY_1(arrayCos, ::cos) +IMPLEMENT_ARRAY_1(arraySin, ::sin) + +#undef IMPLEMENT_ARRAY_SCALAR +#undef IMPLEMENT_ARRAY_1 +#undef IMPLEMENT_ARRAY_2 + +// lsub is special because the argument order is reversed +void Matrix::Impl::lsub(Matrix::T B, Impl& out) const { + const Impl& A = *this; + + debugAssert(A.C == out.C); + debugAssert(A.R == out.R); + + for (int i = R * C - 1; i >= 0; --i) { + out.data[i] = B - A.data[i]; + } +} + + +void Matrix::Impl::inverseViaAdjoint(Impl& out) const { + debugAssert(&out != this); + + // Inverse = adjoint / determinant + + adjoint(out); + + // Don't call the determinant method when we already have an + // adjoint matrix; there's a faster way of computing it: the dot + // product of the first row and the adjoint's first col. + double det = 0.0; + for (int r = R - 1; r >= 0; --r) { + det += elt[0][r] * out.elt[r][0]; + } + + out.div(Matrix::T(det), out); +} + + +void Matrix::Impl::transpose(Impl& out) const { + debugAssert(out.R == C); + debugAssert(out.C == R); + + if (&out == this) { + // Square matrix in place + for (int r = 0; r < R; ++r) { + for (int c = r + 1; c < C; ++c) { + T temp = get(r, c); + out.set(r, c, get(c, r)); + out.set(c, r, temp); + } + } + } else { + for (int r = 0; r < R; ++r) { + for (int c = 0; c < C; ++c) { + out.set(c, r, get(r, c)); + } + } + } +} + + +void Matrix::Impl::adjoint(Impl& out) const { + cofactor(out); + // Transpose is safe to perform in place + out.transpose(out); +} + + +void Matrix::Impl::cofactor(Impl& out) const { + debugAssert(&out != this); + for(int r = 0; r < R; ++r) { + for(int c = 0; c < C; ++c) { + out.set(r, c, cofactor(r, c)); + } + } +} + + +Matrix::T Matrix::Impl::cofactor(int r, int c) const { + // Strang p. 217 + float s = isEven(r + c) ? 1.0f : -1.0f; + + return s * determinant(r, c); +} + + +Matrix::T Matrix::Impl::determinant(int nr, int nc) const { + debugAssert(R > 0); + debugAssert(C > 0); + Impl A(R - 1, C - 1); + withoutRowAndCol(nr, nc, A); + return A.determinant(); +} + + +void Matrix::Impl::setRow(int r, const T* vals) { + debugAssert(r >= 0); + System::memcpy(elt[r], vals, sizeof(T) * C); +} + + +void Matrix::Impl::setCol(int c, const T* vals) { + for (int r = 0; r < R; ++r) { + elt[r][c] = vals[r]; + } +} + + +Matrix::T Matrix::Impl::determinant() const { + + debugAssert(R == C); + + // Compute using cofactors + switch(R) { + case 0: + return 0; + + case 1: + // Determinant of a 1x1 is the element + return elt[0][0]; + + case 2: + // Determinant of a 2x2 is ad-bc + return elt[0][0] * elt[1][1] - elt[0][1] * elt[1][0]; + + case 3: + { + // Determinant of an nxn matrix is the dot product of the first + // row with the first row of cofactors. The base cases of this + // method get called a lot, so we spell out the implementation + // for the 3x3 case. + + float cofactor00 = elt[1][1] * elt[2][2] - elt[1][2] * elt[2][1]; + float cofactor10 = elt[1][2] * elt[2][0] - elt[1][0] * elt[2][2]; + float cofactor20 = elt[1][0] * elt[2][1] - elt[1][1] * elt[2][0]; + + return Matrix::T( + elt[0][0] * cofactor00 + + elt[0][1] * cofactor10 + + elt[0][2] * cofactor20); + } + + default: + { + // Determinant of an n x n matrix is the dot product of the first + // row with the first row of cofactors + T det = 0; + + for (int c = 0; c < C; ++c) { + det += elt[0][c] * cofactor(0, c); + } + + return det; + } + } +} + + +void Matrix::Impl::withoutRowAndCol(int excludeRow, int excludeCol, Impl& out) const { + debugAssert(out.R == R - 1); + debugAssert(out.C == C - 1); + + for (int r = 0; r < out.R; ++r) { + for (int c = 0; c < out.C; ++c) { + out.elt[r][c] = elt[r + ((r >= excludeRow) ? 1 : 0)][c + ((c >= excludeCol) ? 1 : 0)]; + } + } +} + + +Matrix Matrix::pseudoInverse(float tolerance) const { + if ((cols() == 1) || (rows() == 1)) { + return vectorPseudoInverse(); + } else if ((cols() <= 4) || (rows() <= 4)) { + return partitionPseudoInverse(); + } else { + return svdPseudoInverse(tolerance); + } +} + +/* + Public function for testing purposes only. Use pseudoInverse(), as it contains optimizations for + nonsingular matrices with at least one small (<5) dimension. +*/ +Matrix Matrix::svdPseudoInverse(float tolerance) const { + if (cols() > rows()) { + return transpose().svdPseudoInverse(tolerance).transpose(); + } + + // Matrices from SVD + Matrix U, V; + + // Diagonal elements + Array<T> d; + + svd(U, d, V); + + if (rows() == 1) { + d.resize(1, false); + } + + if (tolerance < 0) { + // TODO: Should be eps(d[0]), which is the largest diagonal + tolerance = G3D::max(rows(), cols()) * 0.0001f; + } + + Matrix X; + + int r = 0; + for (int i = 0; i < d.size(); ++i) { + if (d[i] > tolerance) { + d[i] = Matrix::T(1) / d[i]; + ++r; + } + } + + if (r == 0) { + // There were no non-zero elements + X = zero(cols(), rows()); + } else { + // Use the first r columns + + // Test code (the rest is below) + /* + d.resize(r); + Matrix testU = U.subMatrix(0, U.rows() - 1, 0, r - 1); + Matrix testV = V.subMatrix(0, V.rows() - 1, 0, r - 1); + Matrix testX = testV * Matrix::fromDiagonal(d) * testU.transpose(); + X = testX; + */ + + + // We want to do this: + // + // d.resize(r); + // U = U.subMatrix(0, U.rows() - 1, 0, r - 1); + // X = V * Matrix::fromDiagonal(d) * U.transpose(); + // + // but creating a large diagonal matrix and then + // multiplying by it is wasteful. So we instead + // explicitly perform A = (D * U')' = U * D, and + // then multiply X = V * A'. + + Matrix A = Matrix(U.rows(), r); + + const T* dPtr = d.getCArray(); + for (int i = 0; i < A.rows(); ++i) { + const T* Urow = U.impl->elt[i]; + T* Arow = A.impl->elt[i]; + const int Acols = A.cols(); + for (int j = 0; j < Acols; ++j) { + // A(i,j) = U(i,:) * D(:,j) + // This is non-zero only at j = i because D is diagonal + // A(i,j) = U(i,j) * D(j,j) + Arow[j] = Urow[j] * dPtr[j]; + } + } + + // + // Compute X = V.subMatrix(0, V.rows() - 1, 0, r - 1) * A.transpose() + // + // Avoid the explicit subMatrix call, and by storing A' instead of A, avoid + // both the transpose and the memory incoherence of striding across memory + // in big steps. + + alwaysAssertM(A.cols() == r, + "Internal dimension mismatch during pseudoInverse()"); + alwaysAssertM(V.cols() >= r, + "Internal dimension mismatch during pseudoInverse()"); + + X = Matrix(V.rows(), A.rows()); + T** Xelt = X.impl->elt; + for (int i = 0; i < X.rows(); ++i) { + const T* Vrow = V.impl->elt[i]; + for (int j = 0; j < X.cols(); ++j) { + const T* Arow = A.impl->elt[j]; + T sum = 0; + for (int k = 0; k < r; ++k) { + sum += Vrow[k] * Arow[k]; + } + Xelt[i][j] = sum; + } + } + + /* + // Test that results are the same after optimizations: + Matrix diff = X - testX; + T n = diff.norm(); + debugAssert(n < 0.0001); + */ + } + return X; +} + +// Computes pseudoinverse for a vector +Matrix Matrix::vectorPseudoInverse() const { + // If vector A has nonzero elements: transpose A, then divide each elt. by the squared norm + // If A is zero vector: transpose A + double x = 0.0; + + if (anyNonZero()) { + x = 1.0 / normSquared(); + } + + Matrix A(cols(), rows()); + T** Aelt = A.impl->elt; + for (int r = 0; r < rows(); ++r) { + const T* MyRow = impl->elt[r]; + for (int c = 0; c < cols(); ++c) { + Aelt[c][r] = T(MyRow[c] * x); + } + } + return Matrix(A); +} + + +Matrix Matrix::rowPartPseudoInverse() const{ + int m = rows(); + int n = cols(); + alwaysAssertM((m<=n),"Row-partitioned block matrix pseudoinverse requires R<C"); + + // B = A * A' + Matrix A = *this; + Matrix B = Matrix(m,m); + + T** Aelt = A.impl->elt; + T** Belt = B.impl->elt; + for (int i = 0; i < m; ++i) { + const T* Arow = Aelt[i]; + for (int j = 0; j < m; ++j) { + const T* Brow = Aelt[j]; + T sum = 0; + for (int k = 0; k < n; ++k) { + sum += Arow[k] * Brow[k]; + } + Belt[i][j] = sum; + } + } + + // B has size m x m + switch (m) { + case 2: + return row2PseudoInverse(B); + + case 3: + return row3PseudoInverse(B); + + case 4: + return row4PseudoInverse(B); + + default: + alwaysAssertM(false, "G3D internal error: Should have used the vector or general case!"); + return Matrix(); + } +} + +Matrix Matrix::colPartPseudoInverse() const{ + int m = rows(); + int n = cols(); + alwaysAssertM((m>=n),"Column-partitioned block matrix pseudoinverse requires R>C"); + // TODO: Put each of the individual cases in its own helper function + // TODO: Push the B computation down into the individual cases + // B = A' * A + Matrix A = *this; + Matrix B = Matrix(n, n); + T** Aelt = A.impl->elt; + T** Belt = B.impl->elt; + for (int i = 0; i < n; ++i) { + for (int j = 0; j < n; ++j) { + T sum = 0; + for (int k = 0; k < m; ++k) { + sum += Aelt[k][i] * Aelt[k][j]; + } + Belt[i][j] = sum; + } + } + + // B has size n x n + switch (n) { + case 2: + return col2PseudoInverse(B); + + case 3: + return col3PseudoInverse(B); + + case 4: + return col4PseudoInverse(B); + + default: + alwaysAssertM(false, "G3D internal error: Should have used the vector or general case!"); + return Matrix(); + } +} + +Matrix Matrix::col2PseudoInverse(const Matrix& B) const { + + Matrix A = *this; + int m = rows(); + int n = cols(); + (void)n; + + // Row-major 2x2 matrix + const float B2[2][2] = + {{B.get(0,0), B.get(0,1)}, + {B.get(1,0), B.get(1,1)}}; + + float det = (B2[0][0]*B2[1][1]) - (B2[0][1]*B2[1][0]); + + if (fuzzyEq(det, T(0))) { + + // Matrix was singular; the block matrix pseudo-inverse can't + // handle that, so fall back to the old case + return svdPseudoInverse(); + + } else { + // invert using formula at http://www.netsoc.tcd.ie/~jgilbert/maths_site/applets/algebra/matrix_inversion.html + + // Multiply by Binv * A' + Matrix X(cols(), rows()); + + T** Xelt = X.impl->elt; + T** Aelt = A.impl->elt; + float binv00 = B2[1][1]/det, binv01 = -B2[1][0]/det; + float binv10 = -B2[0][1]/det, binv11 = B2[0][0]/det; + for (int j = 0; j < m; ++j) { + const T* Arow = Aelt[j]; + float a0 = Arow[0]; + float a1 = Arow[1]; + Xelt[0][j] = binv00 * a0 + binv01 * a1; + Xelt[1][j] = binv10 * a0 + binv11 * a1; + } + return X; + } +} + +Matrix Matrix::col3PseudoInverse(const Matrix& B) const { + Matrix A = *this; + int m = rows(); + int n = cols(); + + Matrix3 B3 = B.toMatrix3(); + if (fuzzyEq(B3.determinant(), (T)0.0)) { + + // Matrix was singular; the block matrix pseudo-inverse can't + // handle that, so fall back to the old case + return svdPseudoInverse(); + + } else { + Matrix3 B3inv = B3.inverse(); + + // Multiply by Binv * A' + Matrix X(cols(), rows()); + + T** Xelt = X.impl->elt; + T** Aelt = A.impl->elt; + for (int i = 0; i < n; ++i) { + T* Xrow = Xelt[i]; + for (int j = 0; j < m; ++j) { + const T* Arow = Aelt[j]; + T sum = 0; + const float* Binvrow = B3inv[i]; + for (int k = 0; k < n; ++k) { + sum += Binvrow[k] * Arow[k]; + } + Xrow[j] = sum; + } + } + return X; + } +} + +Matrix Matrix::col4PseudoInverse(const Matrix& B) const { + Matrix A = *this; + int m = rows(); + int n = cols(); + + Matrix4 B4 = B.toMatrix4(); + if (fuzzyEq(B4.determinant(), (T)0.0)) { + + // Matrix was singular; the block matrix pseudo-inverse can't + // handle that, so fall back to the old case + return svdPseudoInverse(); + + } else { + Matrix4 B4inv = B4.inverse(); + + // Multiply by Binv * A' + Matrix X(cols(), rows()); + + T** Xelt = X.impl->elt; + T** Aelt = A.impl->elt; + for (int i = 0; i < n; ++i) { + T* Xrow = Xelt[i]; + for (int j = 0; j < m; ++j) { + const T* Arow = Aelt[j]; + T sum = 0; + const float* Binvrow = B4inv[i]; + for (int k = 0; k < n; ++k) { + sum += Binvrow[k] * Arow[k]; + } + Xrow[j] = sum; + } + } + return X; + } +} + +Matrix Matrix::row2PseudoInverse(const Matrix& B) const { + + Matrix A = *this; + int m = rows(); + int n = cols(); + (void)m; + + // Row-major 2x2 matrix + const float B2[2][2] = + {{B.get(0,0), B.get(0,1)}, + {B.get(1,0), B.get(1,1)}}; + + float det = (B2[0][0]*B2[1][1]) - (B2[0][1]*B2[1][0]); + + if (fuzzyEq(det, T(0))) { + + // Matrix was singular; the block matrix pseudo-inverse can't + // handle that, so fall back to the old case + return svdPseudoInverse(); + + } else { + // invert using formula at http://www.netsoc.tcd.ie/~jgilbert/maths_site/applets/algebra/matrix_inversion.html + + // Multiply by Binv * A' + Matrix X(cols(), rows()); + + T** Xelt = X.impl->elt; + T** Aelt = A.impl->elt; + float binv00 = B2[1][1]/det, binv01 = -B2[1][0]/det; + float binv10 = -B2[0][1]/det, binv11 = B2[0][0]/det; + for (int j = 0; j < n; ++j) { + Xelt[j][0] = Aelt[0][j] * binv00 + Aelt[1][j] * binv10; + Xelt[j][1] = Aelt[0][j] * binv01 + Aelt[1][j] * binv11; + } + return X; + } +} + +Matrix Matrix::row3PseudoInverse(const Matrix& B) const { + + Matrix A = *this; + int m = rows(); + int n = cols(); + + Matrix3 B3 = B.toMatrix3(); + if (fuzzyEq(B3.determinant(), (T)0.0)) { + + // Matrix was singular; the block matrix pseudo-inverse can't + // handle that, so fall back to the old case + return svdPseudoInverse(); + + } else { + Matrix3 B3inv = B3.inverse(); + + // Multiply by Binv * A' + Matrix X(cols(), rows()); + + T** Xelt = X.impl->elt; + T** Aelt = A.impl->elt; + for (int i = 0; i < n; ++i) { + T* Xrow = Xelt[i]; + for (int j = 0; j < m; ++j) { + T sum = 0; + for (int k = 0; k < m; ++k) { + sum += Aelt[k][i] * B3inv[j][k]; + } + Xrow[j] = sum; + } + } + return X; + } +} + +Matrix Matrix::row4PseudoInverse(const Matrix& B) const { + + Matrix A = *this; + int m = rows(); + int n = cols(); + + Matrix4 B4 = B.toMatrix4(); + if (fuzzyEq(B4.determinant(), (T)0.0)) { + + // Matrix was singular; the block matrix pseudo-inverse can't + // handle that, so fall back to the old case + return svdPseudoInverse(); + + } else { + Matrix4 B4inv = B4.inverse(); + + // Multiply by Binv * A' + Matrix X(cols(), rows()); + + T** Xelt = X.impl->elt; + T** Aelt = A.impl->elt; + for (int i = 0; i < n; ++i) { + T* Xrow = Xelt[i]; + for (int j = 0; j < m; ++j) { + T sum = 0; + for (int k = 0; k < m; ++k) { + sum += Aelt[k][i] * B4inv[j][k]; + } + Xrow[j] = sum; + } + } + return X; + } +} + +// Uses the block matrix pseudoinverse to compute the pseudoinverse of a full-rank mxn matrix with m >= n +// http://en.wikipedia.org/wiki/Block_matrix_pseudoinverse +Matrix Matrix::partitionPseudoInverse() const { + + // Logic: + // A^-1 = (A'A)^-1 A' + // A has few (n) columns, so A'A is small (n x n) and fast to invert + + int m = rows(); + int n = cols(); + + if (m < n) { + // TODO: optimize by pushing through the transpose + //return transpose().partitionPseudoInverse().transpose(); + return rowPartPseudoInverse(); + + } else { + return colPartPseudoInverse(); + } +} + +void Matrix::Impl::inverseInPlaceGaussJordan() { + debugAssertM(R == C, + format( + "Cannot perform Gauss-Jordan inverse on a non-square matrix." + " (Argument was %dx%d)", + R, C)); + + // Exchange to float elements +# define SWAP(x, y) {float temp = x; x = y; y = temp;} + + // The integer arrays pivot, rowIndex, and colIndex are + // used for bookkeeping on the pivoting + static Array<int> colIndex, rowIndex, pivot; + + int col = 0, row = 0; + + colIndex.resize(R); + rowIndex.resize(R); + pivot.resize(R); + + static const int NO_PIVOT = -1; + + // Initialize the pivot array to default values. + for (int i = 0; i < R; ++i) { + pivot[i] = NO_PIVOT; + } + + // This is the main loop over the columns to be reduced + // Loop over the columns. + for (int c = 0; c < R; ++c) { + + // Find the largest element and use that as a pivot + float largestMagnitude = 0.0; + + // This is the outer loop of the search for a pivot element + for (int r = 0; r < R; ++r) { + + // Unless we've already found the pivot, keep going + if (pivot[r] != 0) { + + // Find the largest pivot + for (int k = 0; k < R; ++k) { + if (pivot[k] == NO_PIVOT) { + const float mag = fabs(elt[r][k]); + + if (mag >= largestMagnitude) { + largestMagnitude = mag; + row = r; col = k; + } + } + } + } + } + + pivot[col] += 1; + + // Interchange columns so that the pivot element is on the diagonal (we'll have to undo this + // at the end) + if (row != col) { + for (int k = 0; k < R; ++k) { + SWAP(elt[row][k], elt[col][k]) + } + } + + // The pivot is now at [row, col] + rowIndex[c] = row; + colIndex[c] = col; + + double piv = elt[col][col]; + + debugAssertM(piv != 0.0, "Matrix is singular"); + + // Divide everything by the pivot (avoid computing the division + // multiple times). + const double pivotInverse = 1.0 / piv; + elt[col][col] = 1.0; + + for (int k = 0; k < R; ++k) { + elt[col][k] *= Matrix::T(pivotInverse); + } + + // Reduce all rows + for (int r = 0; r < R; ++r) { + // Skip over the pivot row + if (r != col) { + + double oldValue = elt[r][col]; + elt[r][col] = 0.0; + + for (int k = 0; k < R; ++k) { + elt[r][k] -= Matrix::T(elt[col][k] * oldValue); + } + } + } + } + + + // Put the columns back in the correct locations + for (int i = R - 1; i >= 0; --i) { + if (rowIndex[i] != colIndex[i]) { + for (int k = 0; k < R; ++k) { + SWAP(elt[k][rowIndex[i]], elt[k][colIndex[i]]); + } + } + } + +# undef SWAP +} + + +bool Matrix::Impl::anyNonZero() const { + int N = R * C; + for (int i = 0; i < N; ++i) { + if (data[i] != 0.0) { + return true; + } + } + return false; +} + + +bool Matrix::Impl::allNonZero() const { + int N = R * C; + for (int i = 0; i < N; ++i) { + if (data[i] == 0.0) { + return false; + } + } + return true; +} + + +/** Helper for svdCore */ +static double pythag(double a, double b) { + + double at = fabs(a), bt = fabs(b), ct, result; + + if (at > bt) { + ct = bt / at; + result = at * sqrt(1.0 + square(ct)); + } else if (bt > 0.0) { + ct = at / bt; + result = bt * sqrt(1.0 + square(ct)); + } else { + result = 0.0; + } + + return result; +} + +#define SIGN(a, b) ((b) >= 0.0 ? fabs(a) : -fabs(a)) + +const char* Matrix::svdCore(float** U, int rows, int cols, float* D, float** V) { + const int MAX_ITERATIONS = 30; + + int flag, i, its, j, jj, k, l = 0, nm = 0; + double c, f, h, s, x, y, z; + double anorm = 0.0, g = 0.0, scale = 0.0; + + // Temp row vector + double* rv1; + + debugAssertM(rows >= cols, "Must have more rows than columns"); + + rv1 = (double*)System::alignedMalloc(cols * sizeof(double), 16); + debugAssert(rv1); + + // Householder reduction to bidiagonal form + for (i = 0; i < cols; ++i) { + + // Left-hand reduction + l = i + 1; + rv1[i] = scale * g; + g = s = scale = 0.0; + + if (i < rows) { + + for (k = i; k < rows; ++k) { + scale += fabs((double)U[k][i]); + } + + if (scale) { + for (k = i; k < rows; ++k) { + U[k][i] = (float)((double)U[k][i]/scale); + s += ((double)U[k][i] * (double)U[k][i]); + } + + f = (double)U[i][i]; + + // TODO: what is this 2-arg sign function? + g = -SIGN(sqrt(s), f); + h = f * g - s; + U[i][i] = (float)(f - g); + + if (i != cols - 1) { + for (j = l; j < cols; j++) { + + for (s = 0.0, k = i; k < rows; ++k) { + s += ((double)U[k][i] * (double)U[k][j]); + } + + f = s / h; + for (k = i; k < rows; ++k) { + U[k][j] += (float)(f * (double)U[k][i]); + } + } + } + for (k = i; k < rows; ++k) { + U[k][i] = (float)((double)U[k][i]*scale); + } + } + } + D[i] = (float)(scale * g); + + // right-hand reduction + g = s = scale = 0.0; + if (i < rows && i != cols - 1) { + for (k = l; k < cols; ++k) { + scale += fabs((double)U[i][k]); + } + + if (scale) { + for (k = l; k < cols; ++k) { + U[i][k] = (float)((double)U[i][k]/scale); + s += ((double)U[i][k] * (double)U[i][k]); + } + + f = (double)U[i][l]; + g = -SIGN(sqrt(s), f); + h = f * g - s; + U[i][l] = (float)(f - g); + + for (k = l; k < cols; ++k) { + rv1[k] = (double)U[i][k] / h; + } + + if (i != rows - 1) { + + for (j = l; j < rows; ++j) { + for (s = 0.0, k = l; k < cols; ++k) { + s += ((double)U[j][k] * (double)U[i][k]); + } + + for (k = l; k < cols; ++k) { + U[j][k] += (float)(s * rv1[k]); + } + } + } + + for (k = l; k < cols; ++k) { + U[i][k] = (float)((double)U[i][k]*scale); + } + } + } + + anorm = max(anorm, fabs((double)D[i]) + fabs(rv1[i])); + } + + // accumulate the right-hand transformation + for (i = cols - 1; i >= 0; --i) { + if (i < cols - 1) { + if (g) { + for (j = l; j < cols; j++) { + V[j][i] = (float)(((double)U[i][j] / (double)U[i][l]) / g); + } + + // double division to avoid underflow + for (j = l; j < cols; ++j) { + for (s = 0.0, k = l; k < cols; k++) { + s += ((double)U[i][k] * (double)V[k][j]); + } + + for (k = l; k < cols; ++k) { + V[k][j] += (float)(s * (double)V[k][i]); + } + } + } + + for (j = l; j < cols; ++j) { + V[i][j] = V[j][i] = 0.0; + } + } + + V[i][i] = 1.0; + g = rv1[i]; + l = i; + } + + // accumulate the left-hand transformation + for (i = cols - 1; i >= 0; --i) { + l = i + 1; + g = (double)D[i]; + if (i < cols - 1) { + for (j = l; j < cols; ++j) { + U[i][j] = 0.0; + } + } + + if (g) { + g = 1.0 / g; + if (i != cols - 1) { + for (j = l; j < cols; ++j) { + for (s = 0.0, k = l; k < rows; ++k) { + s += ((double)U[k][i] * (double)U[k][j]); + } + + f = (s / (double)U[i][i]) * g; + + for (k = i; k < rows; ++k) { + U[k][j] += (float)(f * (double)U[k][i]); + } + } + } + + for (j = i; j < rows; ++j) { + U[j][i] = (float)((double)U[j][i]*g); + } + + } else { + for (j = i; j < rows; ++j) { + U[j][i] = 0.0; + } + } + ++U[i][i]; + } + + // diagonalize the bidiagonal form + for (k = cols - 1; k >= 0; --k) { + // loop over singular values + for (its = 0; its < MAX_ITERATIONS; ++its) { + // loop over allowed iterations + flag = 1; + + for (l = k; l >= 0; --l) { + // test for splitting + nm = l - 1; + if (fabs(rv1[l]) + anorm == anorm) { + flag = 0; + break; + } + + if (fabs((double)D[nm]) + anorm == anorm) { + break; + } + } + + if (flag) { + c = 0.0; + s = 1.0; + for (i = l; i <= k; ++i) { + f = s * rv1[i]; + if (fabs(f) + anorm != anorm) { + g = (double)D[i]; + h = pythag(f, g); + D[i] = (float)h; + h = 1.0 / h; + c = g * h; + s = (- f * h); + for (j = 0; j < rows; ++j) { + y = (double)U[j][nm]; + z = (double)U[j][i]; + U[j][nm] = (float)(y * c + z * s); + U[j][i] = (float)(z * c - y * s); + } + } + } + } + + z = (double)D[k]; + if (l == k) { + // convergence + if (z < 0.0) { + // make singular value nonnegative + D[k] = (float)(-z); + + for (j = 0; j < cols; ++j) { + V[j][k] = (-V[j][k]); + } + } + break; + } + + if (its >= MAX_ITERATIONS) { + free(rv1); + rv1 = NULL; + return "Failed to converge."; + } + + // shift from bottom 2 x 2 minor + x = (double)D[l]; + nm = k - 1; + y = (double)D[nm]; + g = rv1[nm]; + h = rv1[k]; + f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y); + g = pythag(f, 1.0); + f = ((x - z) * (x + z) + h * ((y / (f + SIGN(g, f))) - h)) / x; + + // next QR transformation + c = s = 1.0; + for (j = l; j <= nm; ++j) { + i = j + 1; + g = rv1[i]; + y = (double)D[i]; + h = s * g; + g = c * g; + z = pythag(f, h); + rv1[j] = z; + c = f / z; + s = h / z; + f = x * c + g * s; + g = g * c - x * s; + h = y * s; + y = y * c; + + for (jj = 0; jj < cols; ++jj) { + x = (double)V[jj][j]; + z = (double)V[jj][i]; + V[jj][j] = (float)(x * c + z * s); + V[jj][i] = (float)(z * c - x * s); + } + z = pythag(f, h); + D[j] = (float)z; + if (z) { + z = 1.0 / z; + c = f * z; + s = h * z; + } + f = (c * g) + (s * y); + x = (c * y) - (s * g); + for (jj = 0; jj < rows; jj++) { + y = (double)U[jj][j]; + z = (double)U[jj][i]; + U[jj][j] = (float)(y * c + z * s); + U[jj][i] = (float)(z * c - y * s); + } + } + rv1[l] = 0.0; + rv1[k] = f; + D[k] = (float)x; + } + } + + System::alignedFree(rv1); + rv1 = NULL; + + return NULL; +} + +#undef SIGN + +} diff --git a/dep/src/g3dlite/Matrix3.cpp b/dep/src/g3dlite/Matrix3.cpp index 76864e1b60c..b32d938f0f9 100644 --- a/dep/src/g3dlite/Matrix3.cpp +++ b/dep/src/g3dlite/Matrix3.cpp @@ -6,21 +6,51 @@ @author Morgan McGuire, graphics3d.com @created 2001-06-02 - @edited 2006-04-06 + @edited 2009-11-15 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. */ #include "G3D/platform.h" -#include "G3D/format.h" #include <memory.h> #include <assert.h> #include "G3D/Matrix3.h" #include "G3D/g3dmath.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" #include "G3D/Quat.h" +#include "G3D/Any.h" namespace G3D { const float Matrix3::EPSILON = 1e-06f; +Matrix3::Matrix3(const Any& any) { + any.verifyName("Matrix3"); + any.verifyType(Any::ARRAY); + any.verifySize(9); + + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + elt[r][c] = any[r * 3 + c]; + } + } +} + + +Matrix3::operator Any() const { + Any any(Any::ARRAY, "Matrix3"); + any.resize(9); + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + any[r * 3 + c] = elt[r][c]; + } + } + + return any; +} + const Matrix3& Matrix3::zero() { static Matrix3 m(0, 0, 0, 0, 0, 0, 0, 0, 0); return m; @@ -31,13 +61,14 @@ const Matrix3& Matrix3::identity() { return m; } -// Deprecated. -const Matrix3 Matrix3::ZERO(0, 0, 0, 0, 0, 0, 0, 0, 0); -const Matrix3 Matrix3::IDENTITY(1, 0, 0, 0, 1, 0, 0, 0, 1); const float Matrix3::ms_fSvdEpsilon = 1e-04f; const int Matrix3::ms_iSvdMaxIterations = 32; +Matrix3::Matrix3(BinaryInput& b) { + deserialize(b); +} + bool Matrix3::fuzzyEq(const Matrix3& b) const { for (int r = 0; r < 3; ++r) { for (int c = 0; c < 3; ++c) { @@ -49,12 +80,25 @@ bool Matrix3::fuzzyEq(const Matrix3& b) const { return true; } + +bool Matrix3::isRightHanded() const{ + + const Vector3& X = column(0); + const Vector3& Y = column(1); + const Vector3& Z = column(2); + + const Vector3& W = X.cross(Y); + + return W.dot(Z) > 0.0f; +} + + bool Matrix3::isOrthonormal() const { - Vector3 X = getColumn(0); - Vector3 Y = getColumn(1); - Vector3 Z = getColumn(2); + const Vector3& X = column(0); + const Vector3& Y = column(1); + const Vector3& Z = column(2); - return + return (G3D::fuzzyEq(X.dot(Y), 0.0f) && G3D::fuzzyEq(Y.dot(Z), 0.0f) && G3D::fuzzyEq(X.dot(Z), 0.0f) && @@ -66,8 +110,9 @@ bool Matrix3::isOrthonormal() const { //---------------------------------------------------------------------------- Matrix3::Matrix3(const Quat& _q) { // Implementation from Watt and Watt, pg 362 - // See also http://www.flipcode.com/documents/matrfaq.html#Q54 - Quat q = _q.unitize(); + // See also http://www.flipcode.com/documents/matrfaq.html#Q54 + Quat q = _q; + q.unitize(); float xx = 2.0f * q.x * q.x; float xy = 2.0f * q.x * q.y; float xz = 2.0f * q.x * q.z; @@ -108,7 +153,7 @@ Matrix3::Matrix3( void Matrix3::set( float fEntry00, float fEntry01, float fEntry02, - float fEntry10, float fEntry11, float fEntry12, + float fEntry10, float fEntry11, float fEntry12, float fEntry20, float fEntry21, float fEntry22) { elt[0][0] = fEntry00; @@ -122,17 +167,41 @@ void Matrix3::set( elt[2][2] = fEntry22; } + +void Matrix3::deserialize(BinaryInput& b) { + int r,c; + for (c = 0; c < 3; ++c) { + for (r = 0; r < 3; ++r) { + elt[r][c] = b.readFloat32(); + } + } +} + + +void Matrix3::serialize(BinaryOutput& b) const { + int r,c; + for (c = 0; c < 3; ++c) { + for (r = 0; r < 3; ++r) { + b.writeFloat32(elt[r][c]); + } + } +} + + //---------------------------------------------------------------------------- -Vector3 Matrix3::getColumn (int iCol) const { +Vector3 Matrix3::column (int iCol) const { assert((0 <= iCol) && (iCol < 3)); return Vector3(elt[0][iCol], elt[1][iCol], elt[2][iCol]); } -Vector3 Matrix3::getRow (int iRow) const { - return Vector3(elt[iRow][0], elt[iRow][1], elt[iRow][2]); + +const Vector3& Matrix3::row (int iRow) const { + assert((0 <= iRow) && (iRow < 3)); + return *reinterpret_cast<const Vector3*>(elt[iRow]); } + void Matrix3::setColumn(int iCol, const Vector3 &vector) { debugAssert((iCol >= 0) && (iCol < 3)); elt[0][iCol] = vector.x; @@ -140,6 +209,7 @@ void Matrix3::setColumn(int iCol, const Vector3 &vector) { elt[2][iCol] = vector.z; } + void Matrix3::setRow(int iRow, const Vector3 &vector) { debugAssert((iRow >= 0) && (iRow < 3)); elt[iRow][0] = vector.x; @@ -147,6 +217,7 @@ void Matrix3::setRow(int iRow, const Vector3 &vector) { elt[iRow][2] = vector.z; } + //---------------------------------------------------------------------------- bool Matrix3::operator== (const Matrix3& rkMatrix) const { for (int iRow = 0; iRow < 3; iRow++) { @@ -269,6 +340,21 @@ Matrix3 Matrix3::operator* (float fScalar) const { return kProd; } +Matrix3& Matrix3::operator/= (float fScalar) { + return *this *= (1.0f / fScalar); +} + +Matrix3& Matrix3::operator*= (float fScalar) { + + for (int iRow = 0; iRow < 3; iRow++) { + for (int iCol = 0; iCol < 3; iCol++) { + elt[iRow][iCol] *= fScalar; + } + } + + return *this; +} + //---------------------------------------------------------------------------- Matrix3 operator* (double fScalar, const Matrix3& rkMatrix) { Matrix3 kProd; @@ -286,6 +372,7 @@ Matrix3 operator* (float fScalar, const Matrix3& rkMatrix) { return (double)fScalar * rkMatrix; } + Matrix3 operator* (int fScalar, const Matrix3& rkMatrix) { return (double)fScalar * rkMatrix; } @@ -914,6 +1001,97 @@ void Matrix3::qDUDecomposition (Matrix3& kQ, } //---------------------------------------------------------------------------- +void Matrix3::polarDecomposition(Matrix3 &R, Matrix3 &S) const{ + /* + Polar decomposition of a matrix. Based on pseudocode from + Nicholas J Higham, "Computing the Polar Decomposition -- with + Applications Siam Journal of Science and Statistical Computing, Vol 7, No. 4, + October 1986. + + Decomposes A into R*S, where R is orthogonal and S is symmetric. + + Ken Shoemake's "Matrix animation and polar decomposition" + in Proceedings of the conference on Graphics interface '92 + seems to be better known in the world of graphics, but Higham's version + uses a scaling constant that can lead to faster convergence than + Shoemake's when the initial matrix is far from orthogonal. + */ + + Matrix3 X = *this; + Matrix3 tmp = X.inverse(); + Matrix3 Xit = tmp.transpose(); + int iter = 0; + + const int MAX_ITERS = 100; + + const double eps = 50 * std::numeric_limits<float>::epsilon(); + const float BigEps = 50 * eps; + + /* Higham suggests using OneNorm(Xit-X) < eps * OneNorm(X) + * as the convergence criterion, but OneNorm(X) should quickly + * settle down to something between 1 and 1.7, so just comparing + * with eps seems sufficient. + *--------------------------------------------------------------- */ + + double resid = X.diffOneNorm(Xit); + while (resid > eps && iter < MAX_ITERS) { + + tmp = X.inverse(); + Xit = tmp.transpose(); + + if (resid < BigEps) { + // close enough use simple iteration + X += Xit; + X *= 0.5f; + } + else { + // not close to convergence, compute acceleration factor + float gamma = sqrt( sqrt( + (Xit.l1Norm()* Xit.lInfNorm())/(X.l1Norm()*X.lInfNorm()) ) ); + + X *= 0.5f * gamma; + tmp = Xit; + tmp *= 0.5f / gamma; + X += tmp; + } + + resid = X.diffOneNorm(Xit); + iter++; + } + + R = X; + tmp = R.transpose(); + + S = tmp * (*this); + + // S := (S + S^t)/2 one more time to make sure it is symmetric + tmp = S.transpose(); + + S += tmp; + S *= 0.5f; + +#ifdef G3D_DEBUG + // Check iter limit + assert(iter < MAX_ITERS); + + // Check A = R*S + tmp = R*S; + resid = tmp.diffOneNorm(*this); + assert(resid < eps); + + // Check R is orthogonal + tmp = R*R.transpose(); + resid = tmp.diffOneNorm(Matrix3::identity()); + assert(resid < eps); + + // Check that S is symmetric + tmp = S.transpose(); + resid = tmp.diffOneNorm(S); + assert(resid < eps); +#endif +} + +//---------------------------------------------------------------------------- float Matrix3::maxCubicRoot (float afCoeff[3]) { // Spectral norm is for A^T*A, so characteristic polynomial // P(x) = c[0]+c[1]*x+c[2]*x^2+x^3 has three positive float roots. @@ -1006,9 +1184,74 @@ float Matrix3::spectralNorm () const { } //---------------------------------------------------------------------------- +float Matrix3::squaredFrobeniusNorm() const { + float norm2 = 0; + const float* e = &elt[0][0]; + + for (int i = 0; i < 9; ++i){ + norm2 += (*e) * (*e); + } + + return norm2; +} + +//---------------------------------------------------------------------------- +float Matrix3::frobeniusNorm() const { + return sqrtf(squaredFrobeniusNorm()); +} + +//---------------------------------------------------------------------------- +float Matrix3::l1Norm() const { + // The one norm of a matrix is the max column sum in absolute value. + float oneNorm = 0; + for (int c = 0; c < 3; ++c) { + + float f = fabs(elt[0][c])+ fabs(elt[1][c]) + fabs(elt[2][c]); + + if (f > oneNorm) { + oneNorm = f; + } + } + return oneNorm; +} + +//---------------------------------------------------------------------------- +float Matrix3::lInfNorm() const { + // The infinity norm of a matrix is the max row sum in absolute value. + float infNorm = 0; + + for (int r = 0; r < 3; ++r) { + + float f = fabs(elt[r][0]) + fabs(elt[r][1])+ fabs(elt[r][2]); + + if (f > infNorm) { + infNorm = f; + } + } + return infNorm; +} + +//---------------------------------------------------------------------------- +float Matrix3::diffOneNorm(const Matrix3 &y) const{ + float oneNorm = 0; + + for (int c = 0; c < 3; ++c){ + + float f = fabs(elt[0][c] - y[0][c]) + fabs(elt[1][c] - y[1][c]) + + fabs(elt[2][c] - y[2][c]); + + if (f > oneNorm) { + oneNorm = f; + } + } + return oneNorm; +} + +//---------------------------------------------------------------------------- void Matrix3::toAxisAngle (Vector3& rkAxis, float& rfRadians) const { + // // Let (x,y,z) be the unit-length axis and let A be an angle of rotation. - // The rotation matrix is R = I + sin(A)*P + (1-cos(A))*P^2 where + // The rotation matrix is R = I + sin(A)*P + (1-cos(A))*P^2 (Rodrigues' formula) where // I is the identity and // // +- -+ @@ -1030,11 +1273,11 @@ void Matrix3::toAxisAngle (Vector3& rkAxis, float& rfRadians) const { // it does not matter which sign you choose on the square roots. float fTrace = elt[0][0] + elt[1][1] + elt[2][2]; - float fCos = 0.5 * (fTrace - 1.0); + float fCos = 0.5f * (fTrace - 1.0f); rfRadians = G3D::aCos(fCos); // in [0,PI] if ( rfRadians > 0.0 ) { - if ( rfRadians < G3D_PI ) { + if ( rfRadians < pi() ) { rkAxis.x = elt[2][1] - elt[1][2]; rkAxis.y = elt[0][2] - elt[2][0]; rkAxis.z = elt[1][0] - elt[0][1]; @@ -1089,28 +1332,31 @@ void Matrix3::toAxisAngle (Vector3& rkAxis, float& rfRadians) const { } //---------------------------------------------------------------------------- -Matrix3 Matrix3::fromAxisAngle (const Vector3& rkAxis, float fRadians) { - Matrix3 m; +Matrix3 Matrix3::fromAxisAngle (const Vector3& _axis, float fRadians) { + Vector3 axis = _axis.direction(); - float fCos = cos(fRadians); - float fSin = sin(fRadians); + Matrix3 m; + float fCos = cos(fRadians); + float fSin = sin(fRadians); float fOneMinusCos = 1.0 - fCos; - float fX2 = rkAxis.x * rkAxis.x; - float fY2 = rkAxis.y * rkAxis.y; - float fZ2 = rkAxis.z * rkAxis.z; - float fXYM = rkAxis.x * rkAxis.y * fOneMinusCos; - float fXZM = rkAxis.x * rkAxis.z * fOneMinusCos; - float fYZM = rkAxis.y * rkAxis.z * fOneMinusCos; - float fXSin = rkAxis.x * fSin; - float fYSin = rkAxis.y * fSin; - float fZSin = rkAxis.z * fSin; + float fX2 = square(axis.x); + float fY2 = square(axis.y); + float fZ2 = square(axis.z); + float fXYM = axis.x * axis.y * fOneMinusCos; + float fXZM = axis.x * axis.z * fOneMinusCos; + float fYZM = axis.y * axis.z * fOneMinusCos; + float fXSin = axis.x * fSin; + float fYSin = axis.y * fSin; + float fZSin = axis.z * fSin; m.elt[0][0] = fX2 * fOneMinusCos + fCos; m.elt[0][1] = fXYM - fZSin; m.elt[0][2] = fXZM + fYSin; + m.elt[1][0] = fXYM + fZSin; m.elt[1][1] = fY2 * fOneMinusCos + fCos; m.elt[1][2] = fYZM - fXSin; + m.elt[2][0] = fXZM - fYSin; m.elt[2][1] = fYZM + fXSin; m.elt[2][2] = fZ2 * fOneMinusCos + fCos; @@ -1134,14 +1380,14 @@ bool Matrix3::toEulerAnglesXYZ (float& rfXAngle, float& rfYAngle, } else { // WARNING. Not unique. XA - ZA = -atan2(r10,r11) rfXAngle = -G3D::aTan2(elt[1][0], elt[1][1]); - rfYAngle = -(float)G3D_HALF_PI; + rfYAngle = -(float)halfPi(); rfZAngle = 0.0f; return false; } } else { // WARNING. Not unique. XAngle + ZAngle = atan2(r10,r11) rfXAngle = G3D::aTan2(elt[1][0], elt[1][1]); - rfYAngle = (float)G3D_HALF_PI; + rfYAngle = (float)halfPi(); rfZAngle = 0.0f; return false; } @@ -1163,14 +1409,14 @@ bool Matrix3::toEulerAnglesXZY (float& rfXAngle, float& rfZAngle, } else { // WARNING. Not unique. XA - YA = atan2(r20,r22) rfXAngle = G3D::aTan2(elt[2][0], elt[2][2]); - rfZAngle = (float)G3D_HALF_PI; + rfZAngle = (float)halfPi(); rfYAngle = 0.0; return false; } } else { // WARNING. Not unique. XA + YA = atan2(-r20,r22) rfXAngle = G3D::aTan2( -elt[2][0], elt[2][2]); - rfZAngle = -(float)G3D_HALF_PI; + rfZAngle = -(float)halfPi(); rfYAngle = 0.0f; return false; } @@ -1192,14 +1438,14 @@ bool Matrix3::toEulerAnglesYXZ (float& rfYAngle, float& rfXAngle, } else { // WARNING. Not unique. YA - ZA = atan2(r01,r00) rfYAngle = G3D::aTan2(elt[0][1], elt[0][0]); - rfXAngle = (float)G3D_HALF_PI; + rfXAngle = (float)halfPi(); rfZAngle = 0.0; return false; } } else { // WARNING. Not unique. YA + ZA = atan2(-r01,r00) rfYAngle = G3D::aTan2( -elt[0][1], elt[0][0]); - rfXAngle = -(float)G3D_HALF_PI; + rfXAngle = -(float)halfPi(); rfZAngle = 0.0f; return false; } @@ -1221,14 +1467,14 @@ bool Matrix3::toEulerAnglesYZX (float& rfYAngle, float& rfZAngle, } else { // WARNING. Not unique. YA - XA = -atan2(r21,r22); rfYAngle = -G3D::aTan2(elt[2][1], elt[2][2]); - rfZAngle = -(float)G3D_HALF_PI; + rfZAngle = -(float)halfPi(); rfXAngle = 0.0; return false; } } else { // WARNING. Not unique. YA + XA = atan2(r21,r22) rfYAngle = G3D::aTan2(elt[2][1], elt[2][2]); - rfZAngle = (float)G3D_HALF_PI; + rfZAngle = (float)halfPi(); rfXAngle = 0.0f; return false; } @@ -1250,14 +1496,14 @@ bool Matrix3::toEulerAnglesZXY (float& rfZAngle, float& rfXAngle, } else { // WARNING. Not unique. ZA - YA = -atan(r02,r00) rfZAngle = -G3D::aTan2(elt[0][2], elt[0][0]); - rfXAngle = -(float)G3D_HALF_PI; + rfXAngle = -(float)halfPi(); rfYAngle = 0.0f; return false; } } else { // WARNING. Not unique. ZA + YA = atan2(r02,r00) rfZAngle = G3D::aTan2(elt[0][2], elt[0][0]); - rfXAngle = (float)G3D_HALF_PI; + rfXAngle = (float)halfPi(); rfYAngle = 0.0f; return false; } @@ -1279,14 +1525,14 @@ bool Matrix3::toEulerAnglesZYX (float& rfZAngle, float& rfYAngle, } else { // WARNING. Not unique. ZA - XA = -atan2(r01,r02) rfZAngle = -G3D::aTan2(elt[0][1], elt[0][2]); - rfYAngle = (float)G3D_HALF_PI; + rfYAngle = (float)halfPi(); rfXAngle = 0.0f; return false; } } else { // WARNING. Not unique. ZA + XA = atan2(-r01,-r02) rfZAngle = G3D::aTan2( -elt[0][1], -elt[0][2]); - rfYAngle = -(float)G3D_HALF_PI; + rfYAngle = -(float)halfPi(); rfXAngle = 0.0f; return false; } @@ -1335,10 +1581,10 @@ Matrix3 Matrix3::fromEulerAnglesXZY (float fYAngle, float fPAngle, //---------------------------------------------------------------------------- Matrix3 Matrix3::fromEulerAnglesYXZ( - float fYAngle, + float fYAngle, float fPAngle, float fRAngle) { - + float fCos, fSin; fCos = cos(fYAngle); @@ -1358,7 +1604,7 @@ Matrix3 Matrix3::fromEulerAnglesYXZ( //---------------------------------------------------------------------------- Matrix3 Matrix3::fromEulerAnglesYZX( - float fYAngle, + float fYAngle, float fPAngle, float fRAngle) { @@ -1600,9 +1846,9 @@ void Matrix3::tensorProduct (const Vector3& rkU, const Vector3& rkV, // Runs in 52 cycles on AMD, 76 cycles on Intel Centrino // -// The loop unrolling is necessary for performance. +// The loop unrolling is necessary for performance. // I was unable to improve performance further by flattening the matrices -// into float*'s instead of 2D arrays. +// into float*'s instead of 2D arrays. // // -morgan void Matrix3::_mul(const Matrix3& A, const Matrix3& B, Matrix3& out) { @@ -1669,12 +1915,13 @@ void Matrix3::_transpose(const Matrix3& A, Matrix3& out) { //----------------------------------------------------------------------------- std::string Matrix3::toString() const { - return G3D::format("[%g, %g, %g; %g, %g, %g; %g, %g, %g]", - elt[0][0], elt[0][1], elt[0][2], - elt[1][0], elt[1][1], elt[1][2], - elt[2][0], elt[2][1], elt[2][2]); + return G3D::format("[%g, %g, %g; %g, %g, %g; %g, %g, %g]", + elt[0][0], elt[0][1], elt[0][2], + elt[1][0], elt[1][1], elt[1][2], + elt[2][0], elt[2][1], elt[2][2]); } -} // namespace +} // namespace + diff --git a/dep/src/g3dlite/Matrix4.cpp b/dep/src/g3dlite/Matrix4.cpp new file mode 100644 index 00000000000..cd38a1a3602 --- /dev/null +++ b/dep/src/g3dlite/Matrix4.cpp @@ -0,0 +1,523 @@ +/** + @file Matrix4.cpp + + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-10-02 + @edited 2010-01-29 + */ + +#include "G3D/platform.h" +#include "G3D/Matrix4.h" +#include "G3D/Matrix3.h" +#include "G3D/Vector4.h" +#include "G3D/Vector3.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/CoordinateFrame.h" +#include "G3D/Rect2D.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + + +Matrix4::Matrix4(const Any& any) { + any.verifyName("Matrix4"); + any.verifyType(Any::ARRAY); + + const std::string& name = toLower(any.name()); + if (name == "matrix4") { + any.verifySize(16); + + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + elt[r][c] = any[r * 4 + c]; + } + } + } else if (name == "matrix4::scale") { + if (any.size() == 1) { + *this = scale(any[0].number()); + } else if (any.size() == 3) { + *this = scale(any[0], any[1], any[2]); + } else { + any.verify(false, "Matrix4::scale() takes either 1 or 3 arguments"); + } + } else { + any.verify(false, "Expected Matrix4 constructor"); + } +} + + +Matrix4::operator Any() const { + Any any(Any::ARRAY, "Matrix4"); + any.resize(16); + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + any[r * 4 + c] = elt[r][c]; + } + } + + return any; +} + +const Matrix4& Matrix4::identity() { + static Matrix4 m( + 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1); + return m; +} + + +const Matrix4& Matrix4::zero() { + static Matrix4 m( + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0); + return m; +} + + +Matrix4::Matrix4(const class CoordinateFrame& cframe) { + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + elt[r][c] = cframe.rotation[r][c]; + } + elt[r][3] = cframe.translation[r]; + } + elt[3][0] = 0.0f; + elt[3][1] = 0.0f; + elt[3][2] = 0.0f; + elt[3][3] = 1.0f; +} + +Matrix4::Matrix4(const Matrix3& upper3x3, const Vector3& lastCol) { + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + elt[r][c] = upper3x3[r][c]; + } + elt[r][3] = lastCol[r]; + } + elt[3][0] = 0.0f; + elt[3][1] = 0.0f; + elt[3][2] = 0.0f; + elt[3][3] = 1.0f; +} + + +Matrix3 Matrix4::upper3x3() const { + return Matrix3(elt[0][0], elt[0][1], elt[0][2], + elt[1][0], elt[1][1], elt[1][2], + elt[2][0], elt[2][1], elt[2][2]); +} + + +Matrix4 Matrix4::orthogonalProjection( + const class Rect2D& rect, + float nearval, + float farval, + float upDirection) { + return Matrix4::orthogonalProjection(rect.x0(), rect.x1(), rect.y1(), rect.y0(), nearval, farval, upDirection); +} + + +Matrix4 Matrix4::orthogonalProjection( + float left, + float right, + float bottom, + float top, + float nearval, + float farval, + float upDirection) { + + // Adapted from Mesa. Note that Microsoft (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/glfunc03_8qnj.asp) + // and Linux (http://www.xfree86.org/current/glOrtho.3.html) have different matrices shown in their documentation. + + float x, y, z; + float tx, ty, tz; + + x = 2.0f / (right-left); + y = 2.0f / (top-bottom); + z = -2.0f / (farval-nearval); + tx = -(right+left) / (right-left); + ty = -(top+bottom) / (top-bottom); + tz = -(farval+nearval) / (farval-nearval); + + y *= upDirection; + ty *= upDirection; + + return + Matrix4( x , 0.0f, 0.0f, tx, + 0.0f, y , 0.0f, ty, + 0.0f, 0.0f, z , tz, + 0.0f, 0.0f, 0.0f, 1.0f); +} + + +Matrix4 Matrix4::perspectiveProjection( + float left, + float right, + float bottom, + float top, + float nearval, + float farval, + float upDirection) { + + float x, y, a, b, c, d; + + x = (2.0f*nearval) / (right-left); + y = (2.0f*nearval) / (top-bottom); + a = (right+left) / (right-left); + b = (top+bottom) / (top-bottom); + + if (farval >= finf()) { + // Infinite view frustum + c = -1.0f; + d = -2.0f * nearval; + } else { + c = -(farval+nearval) / (farval-nearval); + d = -(2.0f*farval*nearval) / (farval-nearval); + } + + debugAssertM(abs(upDirection) == 1.0f, "upDirection must be -1 or +1"); + y *= upDirection; + b *= upDirection; + + return Matrix4( + x, 0, a, 0, + 0, y, b, 0, + 0, 0, c, d, + 0, 0, -1, 0); +} + + +void Matrix4::getPerspectiveProjectionParameters( + float& left, + float& right, + float& bottom, + float& top, + float& nearval, + float& farval, + float upDirection) const { + + debugAssertM(abs(upDirection) == 1.0f, "upDirection must be -1 or +1"); + + float x = elt[0][0]; + float y = elt[1][1] * upDirection; + float a = elt[0][2]; + float b = elt[1][2] * upDirection; + float c = elt[2][2]; + float d = elt[2][3]; + + // Verify that this really is a projection matrix + debugAssertM(elt[3][2] == -1, "Not a projection matrix"); + debugAssertM(elt[0][1] == 0, "Not a projection matrix"); + debugAssertM(elt[0][3] == 0, "Not a projection matrix"); + debugAssertM(elt[1][3] == 0, "Not a projection matrix"); + debugAssertM(elt[3][3] == 0, "Not a projection matrix"); + debugAssertM(elt[1][0] == 0, "Not a projection matrix"); + debugAssertM(elt[2][0] == 0, "Not a projection matrix"); + debugAssertM(elt[2][1] == 0, "Not a projection matrix"); + debugAssertM(elt[3][0] == 0, "Not a projection matrix"); + debugAssertM(elt[3][1] == 0, "Not a projection matrix"); + + if (c == -1) { + farval = finf(); + nearval = -d / 2.0f; + } else { + nearval = d * ((c - 1.0f) / (c + 1.0f) - 1.0f) / (-2.0f * (c - 1.0f) / (c + 1.0f)); + farval = nearval * ((c - 1.0f) / (c + 1.0f)); + } + + + left = (a - 1.0f) * nearval / x; + right = 2.0f * nearval / x + left; + + bottom = (b - 1.0f) * nearval / y; + top = 2.0f * nearval / y + bottom; +} + + +Matrix4::Matrix4( + float r1c1, float r1c2, float r1c3, float r1c4, + float r2c1, float r2c2, float r2c3, float r2c4, + float r3c1, float r3c2, float r3c3, float r3c4, + float r4c1, float r4c2, float r4c3, float r4c4) { + elt[0][0] = r1c1; elt[0][1] = r1c2; elt[0][2] = r1c3; elt[0][3] = r1c4; + elt[1][0] = r2c1; elt[1][1] = r2c2; elt[1][2] = r2c3; elt[1][3] = r2c4; + elt[2][0] = r3c1; elt[2][1] = r3c2; elt[2][2] = r3c3; elt[2][3] = r3c4; + elt[3][0] = r4c1; elt[3][1] = r4c2; elt[3][2] = r4c3; elt[3][3] = r4c4; +} + +/** + init should be <B>row major</B>. + */ +Matrix4::Matrix4(const float* init) { + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + elt[r][c] = init[r * 4 + c]; + } + } +} + + +Matrix4::Matrix4(const double* init) { + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + elt[r][c] = (float)init[r * 4 + c]; + } + } +} + + +Matrix4::Matrix4() { + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + elt[r][c] = 0; + } + } +} + + +void Matrix4::setRow(int r, const Vector4& v) { + for (int c = 0; c < 4; ++c) { + elt[r][c] = v[c]; + } +} + + +void Matrix4::setColumn(int c, const Vector4& v) { + for (int r = 0; r < 4; ++r) { + elt[r][c] = v[r]; + } +} + + +const Vector4& Matrix4::row(int r) const { + return reinterpret_cast<const Vector4*>(elt[r])[0]; +} + + +Vector4 Matrix4::column(int c) const { + Vector4 v; + for (int r = 0; r < 4; ++r) { + v[r] = elt[r][c]; + } + return v; +} + + +Matrix4 Matrix4::operator*(const Matrix4& other) const { + Matrix4 result; + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + for (int i = 0; i < 4; ++i) { + result.elt[r][c] += elt[r][i] * other.elt[i][c]; + } + } + } + + return result; +} + + +Matrix4 Matrix4::operator*(const float s) const { + Matrix4 result; + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + result.elt[r][c] = elt[r][c] * s; + } + } + + return result; +} + + +Vector3 Matrix4::homoMul(const class Vector3& v, float w) const { + Vector4 r = (*this) * Vector4(v, w); + return r.xyz() * (1.0f / r.w); +} + + +Vector4 Matrix4::operator*(const Vector4& vector) const { + Vector4 result(0,0,0,0); + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + result[r] += elt[r][c] * vector[c]; + } + } + + return result; +} + + +Matrix4 Matrix4::transpose() const { + Matrix4 result; + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + result.elt[c][r] = elt[r][c]; + } + } + + return result; +} + + +bool Matrix4::operator!=(const Matrix4& other) const { + return ! (*this == other); +} + + +bool Matrix4::operator==(const Matrix4& other) const { + + // If the bit patterns are identical, they must be + // the same matrix. If not, they *might* still have + // equal elements due to floating point weirdness. + if (memcmp(this, &other, sizeof(Matrix4) == 0)) { + return true; + } + + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + if (elt[r][c] != other.elt[r][c]) { + return false; + } + } + } + + return true; +} + + +float Matrix4::determinant() const { + // Determinant is the dot product of the first row and the first row + // of cofactors (i.e. the first col of the adjoint matrix) + return cofactor().row(0).dot(row(0)); +} + + +Matrix4 Matrix4::adjoint() const { + return cofactor().transpose(); +} + + +Matrix4 Matrix4::inverse() const { + // Inverse = adjoint / determinant + + Matrix4 A = adjoint(); + + // Determinant is the dot product of the first row and the first row + // of cofactors (i.e. the first col of the adjoint matrix) + float det = A.column(0).dot(row(0)); + + return A * (1.0f / det); +} + + +Matrix4 Matrix4::cofactor() const { + Matrix4 out; + + // We'll use i to incrementally compute -1 ^ (r+c) + int i = 1; + + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + // Compute the determinant of the 3x3 submatrix + float det = subDeterminant(r, c); + out.elt[r][c] = i * det; + i = -i; + } + i = -i; + } + + return out; +} + + +float Matrix4::subDeterminant(int excludeRow, int excludeCol) const { + // Compute non-excluded row and column indices + int row[3]; + int col[3]; + + for (int i = 0; i < 3; ++i) { + row[i] = i; + col[i] = i; + + if (i >= excludeRow) { + ++row[i]; + } + if (i >= excludeCol) { + ++col[i]; + } + } + + // Compute the first row of cofactors + float cofactor00 = + elt[row[1]][col[1]] * elt[row[2]][col[2]] - + elt[row[1]][col[2]] * elt[row[2]][col[1]]; + + float cofactor10 = + elt[row[1]][col[2]] * elt[row[2]][col[0]] - + elt[row[1]][col[0]] * elt[row[2]][col[2]]; + + float cofactor20 = + elt[row[1]][col[0]] * elt[row[2]][col[1]] - + elt[row[1]][col[1]] * elt[row[2]][col[0]]; + + // Product of the first row and the cofactors along the first row + return + elt[row[0]][col[0]] * cofactor00 + + elt[row[0]][col[1]] * cofactor10 + + elt[row[0]][col[2]] * cofactor20; +} + + +CoordinateFrame Matrix4::approxCoordinateFrame() const { + CoordinateFrame cframe; + + for (int r = 0; r < 3; ++r) { + for (int c = 0; c < 3; ++c) { + cframe.rotation[r][c] = elt[r][c]; + } + cframe.translation[r] = elt[r][3]; + } + + // Ensure that the rotation matrix is orthonormal + cframe.rotation.orthonormalize(); + + return cframe; +} + + +void Matrix4::serialize(class BinaryOutput& b) const { + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + b.writeFloat32(elt[r][c]); + } + } +} + + +void Matrix4::deserialize(class BinaryInput& b) { + for (int r = 0; r < 4; ++r) { + for (int c = 0; c < 4; ++c) { + elt[r][c] = b.readFloat32(); + } + } +} + +std::string Matrix4::toString() const { + return G3D::format("[%g, %g, %g, %g; %g, %g, %g, %g; %g, %g, %g, %g; %g, %g, %g, %g]", + elt[0][0], elt[0][1], elt[0][2], elt[0][3], + elt[1][0], elt[1][1], elt[1][2], elt[1][3], + elt[2][0], elt[2][1], elt[2][2], elt[2][3], + elt[3][0], elt[3][1], elt[3][2], elt[3][3]); +} + +} // namespace + + diff --git a/dep/src/g3dlite/MemoryManager.cpp b/dep/src/g3dlite/MemoryManager.cpp new file mode 100644 index 00000000000..240188a1f0e --- /dev/null +++ b/dep/src/g3dlite/MemoryManager.cpp @@ -0,0 +1,91 @@ +/** + @file MemoryManager.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2009-04-20 + @edited 2009-05-29 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/MemoryManager.h" +#include "G3D/System.h" + +namespace G3D { + +MemoryManager::MemoryManager() {} + + +void* MemoryManager::alloc(size_t s) { + return System::malloc(s); +} + + +void MemoryManager::free(void* ptr) { + System::free(ptr); +} + + +bool MemoryManager::isThreadsafe() const { + return true; +} + + +MemoryManager::Ref MemoryManager::create() { + static MemoryManager::Ref m = new MemoryManager(); + return m; +} + + +/////////////////////////////////////////////////// + +AlignedMemoryManager::AlignedMemoryManager() {} + + +void* AlignedMemoryManager::alloc(size_t s) { + return System::alignedMalloc(s, 16); +} + + +void AlignedMemoryManager::free(void* ptr) { + System::alignedFree(ptr); +} + + +bool AlignedMemoryManager::isThreadsafe() const { + return true; +} + + +AlignedMemoryManager::Ref AlignedMemoryManager::create() { + static AlignedMemoryManager::Ref m = new AlignedMemoryManager(); + return m; +} + + +/////////////////////////////////////////////////// + +CRTMemoryManager::CRTMemoryManager() {} + + +void* CRTMemoryManager::alloc(size_t s) { + return ::malloc(s); +} + + +void CRTMemoryManager::free(void* ptr) { + return ::free(ptr); +} + + +bool CRTMemoryManager::isThreadsafe() const { + return true; +} + + +CRTMemoryManager::Ref CRTMemoryManager::create() { + static CRTMemoryManager::Ref m = new CRTMemoryManager(); + return m; +} +} diff --git a/dep/src/g3dlite/MeshAlg.cpp b/dep/src/g3dlite/MeshAlg.cpp new file mode 100644 index 00000000000..626fed92920 --- /dev/null +++ b/dep/src/g3dlite/MeshAlg.cpp @@ -0,0 +1,637 @@ +/** + @file MeshAlg.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2003-09-14 + @edited 2008-09-03 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + + */ + +#include "G3D/MeshAlg.h" +#include "G3D/Table.h" +#include "G3D/Set.h" +#include "G3D/Box.h" +#include "G3D/Sphere.h" +#include "G3D/vectorMath.h" +#include "G3D/AABox.h" +#include "G3D/Image1.h" + +#include <climits> + +namespace G3D { + +const int MeshAlg::Face::NONE = INT_MIN; + +void MeshAlg::generateGrid( + Array<Vector3>& vertex, + Array<Vector2>& texCoord, + Array<int>& index, + int wCells, + int hCells, + const Vector2& textureScale, + bool spaceCentered, + bool twoSided, + const CoordinateFrame& xform, + const Image1::Ref& height) { + + vertex.fastClear(); + texCoord.fastClear(); + index.fastClear(); + + // Generate vertices + for (int z = 0; z <= hCells; ++z) { + for (int x = 0; x <= wCells; ++x) { + Vector3 v(x / (float)wCells, 0, z / (float)hCells); + + Vector2 t = v.xz() * textureScale; + + texCoord.append(t); + + if (height.notNull()) { + v.y = height->nearest(v.x * (height->width() - 1), v.z * (height->height() - 1)).value; + } + if (spaceCentered) { + v -= Vector3(0.5f, 0, 0.5f); + } + v = xform.pointToWorldSpace(v); + vertex.append(v); + } + } + + // Generate indices + for (int z = 0; z < hCells; ++z) { + for (int x = 0; x < wCells; ++x) { + int A = x + z * (wCells + 1); + int B = A + 1; + int C = A + (wCells + 1); + int D = C + 1; + + // A B + // *-----* + // | \ | + // | \ | + // *-----* + // C D + + index.append(A, D, B); + index.append(A, C, D); + } + } + + if (twoSided) { + // The index array needs to have reversed winding for the bottom + // and offset by the original number of vertices + Array<int> ti = index; + ti.reverse(); + for (int i = 0; i < ti.size(); ++i) { + ti[i] += vertex.size(); + } + index.append(ti); + + // Duplicate the arrays + vertex.append(Array<Vector3>(vertex)); + texCoord.append(Array<Vector2>(texCoord)); + } +} + +MeshAlg::Face::Face() { + for (int i = 0; i < 3; ++i) { + edgeIndex[i] = 0; + vertexIndex[i] = 0; + } +} + + +MeshAlg::Edge::Edge() { + for (int i = 0; i < 2; ++i) { + vertexIndex[i] = 0; + // Negative face indices are faces that don't exist + faceIndex[i] = -1; + } +} + + +MeshAlg::Geometry& MeshAlg::Geometry::operator=(const MeshAlg::Geometry& src) { + vertexArray.resize(src.vertexArray.size()); + normalArray.resize(src.vertexArray.size()); + + System::memcpy(vertexArray.getCArray(), src.vertexArray.getCArray(), sizeof(Vector3)*vertexArray.size()); + System::memcpy(normalArray.getCArray(), src.normalArray.getCArray(), sizeof(Vector3)*normalArray.size()); + + return *this; +} + + +void MeshAlg::computeNormals( + Geometry& geometry, + const Array<int>& indexArray) { + + Array<Face> faceArray; + Array<Vertex> vertexArray; + Array<Edge> edgeArray; + Array<Vector3> faceNormalArray; + + computeAdjacency(geometry.vertexArray, indexArray, faceArray, edgeArray, vertexArray); + + computeNormals(geometry.vertexArray, faceArray, vertexArray, + geometry.normalArray, faceNormalArray); +} + + +void MeshAlg::computeNormals( + const Array<Vector3>& vertexGeometry, + const Array<Face>& faceArray, + const Array< Array<int> >& adjacentFaceArray, + Array<Vector3>& vertexNormalArray, + Array<Vector3>& faceNormalArray) { + + // Construct a fake vertex array for backwards compatibility + Array<Vertex> fakeVertexArray; + fakeVertexArray.resize(adjacentFaceArray.size()); + + for (int v = 0; v < adjacentFaceArray.size(); ++v) { + fakeVertexArray[v].faceIndex.resize(adjacentFaceArray[v].size()); + for (int i = 0; i < fakeVertexArray[v].faceIndex.size(); ++i) { + fakeVertexArray[v].faceIndex[i] = adjacentFaceArray[v][i]; + } + // We leave out the edges because they aren't used to compute normals + } + + computeNormals(vertexGeometry, faceArray, fakeVertexArray, + vertexNormalArray, faceNormalArray); +} + + +void MeshAlg::computeNormals( + const Array<Vector3>& vertexGeometry, + const Array<Face>& faceArray, + const Array<Vertex>& vertexArray, + Array<Vector3>& vertexNormalArray, + Array<Vector3>& faceNormalArray) { + + // Face normals (not unit length) + faceNormalArray.resize(faceArray.size()); + for (int f = 0; f < faceArray.size(); ++f) { + const Face& face = faceArray[f]; + + Vector3 vertex[3]; + for (int j = 0; j < 3; ++j) { + vertex[j] = vertexGeometry[face.vertexIndex[j]]; + debugAssert(vertex[j].isFinite()); + } + + faceNormalArray[f] = (vertex[1] - vertex[0]).cross(vertex[2] - vertex[0]); +# ifdef G3D_DEBUG + const Vector3& N = faceNormalArray[f]; + debugAssert(N.isFinite()); +# endif + } + + // Per-vertex normals, computed by averaging + vertexNormalArray.resize(vertexGeometry.size()); + for (int v = 0; v < vertexNormalArray.size(); ++v) { + Vector3 sum = Vector3::zero(); + for (int k = 0; k < vertexArray[v].faceIndex.size(); ++k) { + const int f = vertexArray[v].faceIndex[k]; + sum += faceNormalArray[f]; + } + vertexNormalArray[v] = sum.directionOrZero(); +# ifdef G3D_DEBUG + const Vector3& N = vertexNormalArray[v]; + debugAssert(N.isUnit() || N.isZero()); +# endif + } + + + for (int f = 0; f < faceArray.size(); ++f) { + faceNormalArray[f] = faceNormalArray[f].directionOrZero(); +# ifdef G3D_DEBUG + const Vector3& N = faceNormalArray[f]; + debugAssert(N.isUnit() || N.isZero()); +# endif + } + +} + + +void MeshAlg::computeFaceNormals( + const Array<Vector3>& vertexArray, + const Array<MeshAlg::Face>& faceArray, + Array<Vector3>& faceNormals, + bool normalize) { + + faceNormals.resize(faceArray.size()); + + for (int f = 0; f < faceArray.size(); ++f) { + const MeshAlg::Face& face = faceArray[f]; + + const Vector3& v0 = vertexArray[face.vertexIndex[0]]; + const Vector3& v1 = vertexArray[face.vertexIndex[1]]; + const Vector3& v2 = vertexArray[face.vertexIndex[2]]; + + faceNormals[f] = (v1 - v0).cross(v2 - v0); + } + + if (normalize) { + for (int f = 0; f < faceArray.size(); ++f) { + faceNormals[f] = faceNormals[f].direction(); + } + } +} + + +void MeshAlg::identifyBackfaces( + const Array<Vector3>& vertexArray, + const Array<MeshAlg::Face>& faceArray, + const Vector4& HP, + Array<bool>& backface) { + + Vector3 P = HP.xyz(); + + backface.resize(faceArray.size()); + + if (fuzzyEq(HP.w, 0.0)) { + // Infinite case + for (int f = faceArray.size() - 1; f >= 0; --f) { + const MeshAlg::Face& face = faceArray[f]; + + const Vector3& v0 = vertexArray[face.vertexIndex[0]]; + const Vector3& v1 = vertexArray[face.vertexIndex[1]]; + const Vector3& v2 = vertexArray[face.vertexIndex[2]]; + + const Vector3 N = (v1 - v0).cross(v2 - v0); + + backface[f] = N.dot(P) < 0; + } + } else { + // Finite case + for (int f = faceArray.size() - 1; f >= 0; --f) { + const MeshAlg::Face& face = faceArray[f]; + + const Vector3& v0 = vertexArray[face.vertexIndex[0]]; + const Vector3& v1 = vertexArray[face.vertexIndex[1]]; + const Vector3& v2 = vertexArray[face.vertexIndex[2]]; + + const Vector3 N = (v1 - v0).cross(v2 - v0); + + backface[f] = N.dot(P - v0) < 0; + } + } +} + + +void MeshAlg::identifyBackfaces( + const Array<Vector3>& vertexArray, + const Array<MeshAlg::Face>& faceArray, + const Vector4& HP, + Array<bool>& backface, + const Array<Vector3>& faceNormals) { + + Vector3 P = HP.xyz(); + + backface.resize(faceArray.size()); + + if (fuzzyEq(HP.w, 0.0)) { + // Infinite case + for (int f = faceArray.size() - 1; f >= 0; --f) { + const Vector3& N = faceNormals[f]; + backface[f] = N.dot(P) < 0; + } + } else { + // Finite case + for (int f = faceArray.size() - 1; f >= 0; --f) { + const MeshAlg::Face& face = faceArray[f]; + const Vector3& v0 = vertexArray[face.vertexIndex[0]]; + const Vector3& N = faceNormals[f]; + + backface[f] = N.dot(P - v0) < 0; + } + } +} + + +void MeshAlg::createIndexArray(int n, Array<int>& array, int start, int run, int skip) { + debugAssert(skip >= 0); + debugAssert(run >= 0); + + array.resize(n); + if (skip == 0) { + for (int i = 0; i < n; ++i) { + array[i] = start + i; + } + } else { + int rcount = 0; + int j = start; + for (int i = 0; i < n; ++i) { + array[i] = j; + + ++j; + ++rcount; + + if (rcount == run) { + rcount = 0; + j += skip; + } + } + } +} + + +void MeshAlg::computeAreaStatistics( + const Array<Vector3>& vertexArray, + const Array<int>& indexArray, + double& minEdgeLength, + double& meanEdgeLength, + double& medianEdgeLength, + double& maxEdgeLength, + double& minFaceArea, + double& meanFaceArea, + double& medianFaceArea, + double& maxFaceArea) { + + debugAssert(indexArray.size() % 3 == 0); + + Array<double> area; + area.resize(indexArray.size() / 3); + Array<double> magnitude; + magnitude.resize(indexArray.size()); + + for (int i = 0; i < indexArray.size(); i += 3) { + const Vector3& v0 = vertexArray[indexArray[i]]; + const Vector3& v1 = vertexArray[indexArray[i + 1]]; + const Vector3& v2 = vertexArray[indexArray[i + 2]]; + + area[i / 3] = (v1 - v0).cross(v2 - v0).magnitude() / 2.0; + magnitude[i] = (v1 - v0).magnitude(); + magnitude[i + 1] = (v2 - v1).magnitude(); + magnitude[i + 2] = (v0 - v2).magnitude(); + } + + area.sort(); + magnitude.sort(); + + minEdgeLength = max(0.0, magnitude[0]); + maxEdgeLength = max(0.0, magnitude.last()); + medianEdgeLength = max(0.0, magnitude[magnitude.size() / 2]); + meanEdgeLength = 0; + for (int i = 0; i < magnitude.size(); ++i) { + meanEdgeLength += magnitude[i]; + } + meanEdgeLength /= magnitude.size(); + + minFaceArea = max(0.0, area[0]); + maxFaceArea = max(0.0, area.last()); + medianFaceArea = max(0.0, area[area.size() / 2]); + meanFaceArea = 0; + for (int i = 0; i < area.size(); ++i) { + meanFaceArea += area[i]; + } + meanFaceArea /= area.size(); + + + // Make sure round-off hasn't pushed values less than zero + meanFaceArea = max(0.0, meanFaceArea); + meanEdgeLength = max(0.0, meanEdgeLength); +} + + +int MeshAlg::countBoundaryEdges(const Array<MeshAlg::Edge>& edgeArray) { + int b = 0; + + for (int i = 0; i < edgeArray.size(); ++i) { + if ((edgeArray[i].faceIndex[0] == MeshAlg::Face::NONE) != + (edgeArray[i].faceIndex[1] == MeshAlg::Face::NONE)) { + ++b; + } + } + + return b; +} + +void MeshAlg::computeBounds( + const Array<Vector3>& vertexArray, + const Array<int>& indexArray, + AABox& box, + Sphere& sphere) { + + Array<Vector3> newArray; + newArray.resize(indexArray.size()); + for (int i = 0; i < indexArray.size(); ++i) { + newArray[i] = vertexArray[indexArray[i]]; + } + computeBounds(newArray, box, sphere); +} + + +void MeshAlg::computeBounds( + const Array<Vector3>& vertexArray, + AABox& box, + Sphere& sphere) { + + Vector3 xmin, xmax, ymin, ymax, zmin, zmax; + + // FIRST PASS: find 6 minima/maxima points + xmin.x = ymin.y = zmin.z = finf(); + xmax.x = ymax.y = zmax.z = -finf(); + + for (int v = 0; v < vertexArray.size(); ++v) { + const Vector3& vertex = vertexArray[v]; + + if (vertex.x < xmin.x) { + xmin = vertex; + } + + if (vertex.x > xmax.x) { + xmax = vertex; + } + + if (vertex.y < ymin.y) { + ymin = vertex; + } + + if (vertex.y > ymax.y) { + ymax = vertex; + } + + if (vertex.z < zmin.z) { + zmin = vertex; + } + + if (vertex.z > zmax.z) { + zmax = vertex; + } + } + + // Set points dia1 & dia2 to the maximally separated pair + Vector3 dia1 = xmin; + Vector3 dia2 = xmax; + { + // Set xspan = distance between the 2 points xmin & xmax (squared) + double xspan = (xmax - xmin).squaredMagnitude(); + + // Same for y & z spans + double yspan = (ymax - ymin).squaredMagnitude(); + double zspan = (zmax - zmin).squaredMagnitude(); + + double maxspan = xspan; + + if (yspan > maxspan) { + maxspan = yspan; + dia1 = ymin; + dia2 = ymax; + } + + if (zspan > maxspan) { + maxspan = zspan; + dia1 = zmin; + dia2 = zmax; + } + } + + + // dia1, dia2 is a diameter of initial sphere + + // calc initial center + Vector3 center = (dia1 + dia2) / 2.0; + + // calculate initial radius^2 and radius + Vector3 d = dia2 - sphere.center; + + double radSq = d.squaredMagnitude(); + double rad = sqrt(radSq); + + // SECOND PASS: increment current sphere + double old_to_p, old_to_new; + + for (int v = 0; v < vertexArray.size(); ++v) { + const Vector3& vertex = vertexArray[v]; + + d = vertex - center; + + double old_to_p_sq = d.squaredMagnitude(); + + // do r^2 test first + if (old_to_p_sq > radSq) { + // this point is outside of current sphere + old_to_p = sqrt(old_to_p_sq); + + // calc radius of new sphere + rad = (rad + old_to_p) / 2.0; + + // for next r^2 compare + radSq = rad * rad; + old_to_new = old_to_p - rad; + + // calc center of new sphere + center = (rad * center + old_to_new * vertex) / old_to_p; + } + } + + const Vector3 min(xmin.x, ymin.y, zmin.z); + const Vector3 max(xmax.x, ymax.y, zmax.z); + + box = AABox(min, max); + + const float boxRadSq = (max - min).squaredMagnitude() * 0.25f; + + if (boxRadSq >= radSq){ + if (isNaN(center.x) || ! isFinite(rad)) { + sphere = Sphere(Vector3::zero(), finf()); + } else { + sphere = Sphere(center, rad); + } + } else { + sphere = Sphere((max + min) * 0.5f, sqrt(boxRadSq)); + } +} + +void MeshAlg::computeTangentSpaceBasis( + const Array<Vector3>& vertexArray, + const Array<Vector2>& texCoordArray, + const Array<Vector3>& vertexNormalArray, + const Array<Face>& faceArray, + Array<Vector3>& tangent, + Array<Vector3>& binormal) { + + debugAssertM(faceArray.size() != 0, "Unable to calculate valid tangent space without faces."); + + tangent.resize(vertexArray.size()); + binormal.resize(vertexArray.size()); + + // Zero the output arrays. + System::memset(tangent.getCArray(), 0, sizeof(Vector3) * tangent.size()); + System::memset(binormal.getCArray(), 0, sizeof(Vector3) * binormal.size()); + + // Iterate over faces, computing the tangent vectors for each + // vertex. Accumulate those into the tangent and binormal arrays + // and then orthonormalize at the end. + + for (int f = 0; f < faceArray.size(); ++f) { + const Face& face = faceArray[f]; + + const int i0 = face.vertexIndex[0]; + const int i1 = face.vertexIndex[1]; + const int i2 = face.vertexIndex[2]; + + const Vector3& v0 = vertexArray[i0]; + const Vector3& v1 = vertexArray[i1]; + const Vector3& v2 = vertexArray[i2]; + + const Vector2& t0 = texCoordArray[i0]; + const Vector2& t1 = texCoordArray[i1]; + const Vector2& t2 = texCoordArray[i2]; + + // See http://www.terathon.com/code/tangent.html for a derivation of the following code + + // vertex edges + Vector3 ve1 = v1 - v0; + Vector3 ve2 = v2 - v0; + + // texture edges + Vector2 te1 = t1 - t0; + Vector2 te2 = t2 - t0; + + Vector3 n(ve1.cross(ve2).direction()); + Vector3 t, b; + + float r = te1.x * te2.y - te1.y * te2.x; + if (r == 0.0) { + // degenerate case + Vector3::generateOrthonormalBasis(t, b, n, true); + } else { + r = 1.0f / r; + t = (te2.y * ve1 - te1.y * ve2) * r; + b = (te2.x * ve1 - te1.x * ve2) * r; + } + + for (int v = 0; v < 3; ++v) { + int i = face.vertexIndex[v]; + tangent[i] += t; + binormal[i] += b; + } + } + + // Normalize the basis vectors + for (int v = 0; v < vertexArray.size(); ++v) { + // Remove the component parallel to the normal + const Vector3& N = vertexNormalArray[v]; + Vector3& T = tangent[v]; + Vector3& B = binormal[v]; + + debugAssertM(N.isUnit() || N.isZero(), "Input normals must have unit length"); + + T -= T.dot(N) * N; + B -= B.dot(N) * N; + + // Normalize + T = T.directionOrZero(); + B = B.directionOrZero(); + } +} + + + +} // G3D namespace diff --git a/dep/src/g3dlite/MeshAlgAdjacency.cpp b/dep/src/g3dlite/MeshAlgAdjacency.cpp new file mode 100644 index 00000000000..24b5d207c88 --- /dev/null +++ b/dep/src/g3dlite/MeshAlgAdjacency.cpp @@ -0,0 +1,739 @@ +/** + @file MeshAlgAdjacency.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2003-09-14 + @edited 2009-04-26 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + + */ + +#include "G3D/Table.h" +#include "G3D/MeshAlg.h" +#include "G3D/Set.h" +#include "G3D/Stopwatch.h" +#include "G3D/SmallArray.h" + +namespace G3D { + +/** Two-level table mapping index 0 -> index 1 -> list of face indices */ +class MeshEdgeTable { +public: + + /** We expect 2 faces per edge. */ + typedef SmallArray<int, 2> FaceIndexArray; + + class Edge { + public: + int i1; + + FaceIndexArray faceIndexArray; + }; + + /** We expect at most 6 edges per vertex; that matches a typical regular grid mesh */ + typedef SmallArray<Edge, 6> EdgeArray; + + typedef Array< EdgeArray > ET; + +private: + + ET table; + +public: + + void clear() { + table.clear(); + } + + void resize(int maxV) { + table.resize(maxV); + } + + /** + Inserts the faceIndex into the edge's face list. + The index may be a negative number indicating a backface. + + \param v0 Vertex index 0 + \param v1 Vertex index 1 + */ + void insert(int v0, int v1, int faceIndex) { + + debugAssert(v0 <= v1); + EdgeArray& edgeArray = table[v0]; + for (int i = 0; i < edgeArray.size(); ++i) { + if (edgeArray[i].i1 == v1) { + edgeArray[i].faceIndexArray.push(faceIndex); + return; + } + } + + Edge& p = edgeArray.next(); + p.i1 = v1; + p.faceIndexArray.push(faceIndex); + } + + class Iterator { + friend class MeshEdgeTable; + private: + + int m_i0; + /** Pair index */ + int m_p; + ET& m_array; + EdgeArray* m_edgeArray; + bool m_end; + + public: + + int i0() const { + return m_i0; + } + + int i1() const { + return (*m_edgeArray)[m_p].i1; + } + + FaceIndexArray& faceIndex() { + return (*m_edgeArray)[m_p].faceIndexArray; + } + + Iterator& operator++() { + if ((m_i0 >= 0) && (m_p < m_edgeArray->size() - 1)) { + ++m_p; + } else { + // Skip over elements with no face array + do { + ++m_i0; + if (m_i0 == m_array.size()) { + m_end = true; + return *this; + } else { + m_edgeArray = &m_array[m_i0]; + m_p = 0; + } + } while (m_edgeArray->size() == 0); + } + + return *this; + } + + bool hasMore() const { + return ! m_end; + } + + private: + + Iterator(ET& a) : m_i0(-1), m_p(-1), m_array(a), m_edgeArray(NULL), m_end(false) { + ++(*this); + } + + }; + + Iterator begin() { + return Iterator(table); + } +}; + + +/** + Assigns the edge index into the next unassigned edge + index. The edge index may be negative, indicating + a reverse edge. + */ +static void assignEdgeIndex(MeshAlg::Face& face, int e) { + for (int i = 0; i < 3; ++i) { + if (face.edgeIndex[i] == MeshAlg::Face::NONE) { + face.edgeIndex[i] = e; + return; + } + } + + debugAssertM(false, "Face has already been assigned 3 edges"); +} + + +void MeshAlg::computeAdjacency( + const Array<Vector3>& vertexGeometry, + const Array<int>& indexArray, + Array<Face>& faceArray, + Array<Edge>& edgeArray, + Array< Array<int> >& adjacentFaceArray) { + + Array<Vertex> vertexArray; + + computeAdjacency(vertexGeometry, indexArray, faceArray, edgeArray, vertexArray); + + // Convert the vertexArray into adjacentFaceArray + adjacentFaceArray.clear(); + adjacentFaceArray.resize(vertexArray.size()); + for (int v = 0; v < adjacentFaceArray.size(); ++v) { + const SmallArray<int, 6>& src = vertexArray[v].faceIndex; + Array<int>& dst = adjacentFaceArray[v]; + dst.resize(src.size()); + for (int f = 0; f < dst.size(); ++f) { + dst[f] = src[f]; + } + } +} + + +void MeshAlg::computeAdjacency( + const Array<Vector3>& vertexGeometry, + const Array<int>& indexArray, + Array<Face>& faceArray, + Array<Edge>& edgeArray, + Array<Vertex>& vertexArray) { + + MeshEdgeTable edgeTable; + + edgeArray.clear(); + vertexArray.clear(); + faceArray.clear(); + + // Face normals + Array<Vector3> faceNormal; + faceNormal.resize(indexArray.size() / 3); + faceArray.resize(faceNormal.size()); + + // This array has the same size as the vertex array + vertexArray.resize(vertexGeometry.size()); + + edgeTable.resize(vertexArray.size()); + + // Iterate through the triangle list + for (int q = 0, f = 0; q < indexArray.size(); ++f, q += 3) { + + Vector3 vertex[3]; + MeshAlg::Face& face = faceArray[f]; + + // Construct the face + for (int j = 0; j < 3; ++j) { + int v = indexArray[q + j]; + face.vertexIndex[j] = v; + face.edgeIndex[j] = Face::NONE; + + // Store back pointers in the vertices + vertexArray[v].faceIndex.append(f); + + // We'll need these vertices to find the face normal + vertex[j] = vertexGeometry[v]; + } + + // Compute the face normal + const Vector3& N = (vertex[1] - vertex[0]).cross(vertex[2] - vertex[0]); + faceNormal[f] = N.directionOrZero(); + + static const int nextIndex[] = {1, 2, 0}; + + // Add each edge to the edge table. + for (int j = 0; j < 3; ++j) { + const int i0 = indexArray[q + j]; + const int i1 = indexArray[q + nextIndex[j]]; + + if (i0 < i1) { + // The edge was directed in the same manner as in the face + edgeTable.insert(i0, i1, f); + } else { + // The edge was directed in the opposite manner as in the face + edgeTable.insert(i1, i0, ~f); + } + } + } + + // For each edge in the edge table, create an edge in the edge array. + // Collapse every 2 edges from adjacent faces. + + MeshEdgeTable::Iterator cur = edgeTable.begin(); + + Array<Edge> tempEdgeArray; + while (cur.hasMore()) { + MeshEdgeTable::FaceIndexArray& faceIndexArray = cur.faceIndex(); + + // Process this edge + while (faceIndexArray.size() > 0) { + + // Remove the last index + int f0 = faceIndexArray.pop(); + + // Find the normal to that face + const Vector3& n0 = faceNormal[(f0 >= 0) ? f0 : ~f0]; + + bool found = false; + + // We try to find the matching face with the closest + // normal. This ensures that we don't introduce a lot + // of artificial ridges into flat parts of a mesh. + float ndotn = -2; + int f1 = -1, i1 = -1; + + // Try to find the face with the matching edge + for (int i = faceIndexArray.size() - 1; i >= 0; --i) { + int f = faceIndexArray[i]; + + if ((f >= 0) != (f0 >= 0)) { + // This face contains the oppositely oriented edge + // and has not been assigned too many edges + + const Vector3& n1 = faceNormal[(f >= 0) ? f : ~f]; + float d = n1.dot(n0); + + if (found) { + // We previously found a good face; see if this + // one is better. + if (d > ndotn) { + // This face is better. + ndotn = d; + f1 = f; + i1 = i; + } + } else { + // This is the first face we've found + found = true; + ndotn = d; + f1 = f; + i1 = i; + } + } + } + + // Create the new edge + int e = tempEdgeArray.size(); + Edge& edge = tempEdgeArray.next(); + + edge.vertexIndex[0] = cur.i0(); + edge.vertexIndex[1] = cur.i1(); + + if (f0 >= 0) { + edge.faceIndex[0] = f0; + edge.faceIndex[1] = Face::NONE; + assignEdgeIndex(faceArray[f0], e); + } else { + // The face indices above are two's complemented. + // this code restores them to regular indices. + debugAssert((~f0) >= 0); + edge.faceIndex[1] = ~f0; + edge.faceIndex[0] = Face::NONE; + + // The edge index *does* need to be inverted, however. + assignEdgeIndex(faceArray[~f0], ~e); + } + + if (found) { + // We found a matching face; remove both + // faces from the active list. + faceIndexArray.fastRemove(i1); + + if (f1 >= 0) { + edge.faceIndex[0] = f1; + assignEdgeIndex(faceArray[f1], e); + } else { + edge.faceIndex[1] = ~f1; + assignEdgeIndex(faceArray[~f1], ~e); + } + } + } + + ++cur; + } + + edgeTable.clear(); + + // Move boundary edges to the end of the list and then + // clean up the face references into them + { + // Map old edge indices to new edge indices + Array<int> newIndex; + newIndex.resize(tempEdgeArray.size()); + + // Index of the start and end of the edge array + int i = 0; + int j = tempEdgeArray.size() - 1; + + edgeArray.resize(tempEdgeArray.size()); + for (int e = 0; e < tempEdgeArray.size(); ++e) { + if (tempEdgeArray[e].boundary()) { + newIndex[e] = j; + --j; + } else { + newIndex[e] = i; + ++i; + } + edgeArray[newIndex[e]] = tempEdgeArray[e]; + } + + debugAssertM(i == j + 1, "Counting from front and back of array did not match"); + + // Fix the faces + for (int f = 0; f < faceArray.size(); ++f) { + Face& face = faceArray[f]; + for (int q = 0; q < 3; ++q) { + int e = face.edgeIndex[q]; + if (e < 0) { + // Backwards edge; twiddle before and after conversion + face.edgeIndex[q] = ~newIndex[~e]; + } else { + // Regular edge; remap the index + face.edgeIndex[q] = newIndex[e]; + } + } + } + } + + // Now order the edge indices inside the faces correctly. + for (int f = 0; f < faceArray.size(); ++f) { + Face& face = faceArray[f]; + int e0 = face.edgeIndex[0]; + int e1 = face.edgeIndex[1]; + int e2 = face.edgeIndex[2]; + + // e0 will always remain first. The only + // question is whether e1 and e2 should be swapped. + + // See if e1 begins at the vertex where e1 ends. + const int e0End = (e0 < 0) ? + edgeArray[~e0].vertexIndex[0] : + edgeArray[e0].vertexIndex[1]; + + const int e1Begin = (e1 < 0) ? + edgeArray[~e1].vertexIndex[1] : + edgeArray[e1].vertexIndex[0]; + + if (e0End != e1Begin) { + // We must swap e1 and e2 + face.edgeIndex[1] = e2; + face.edgeIndex[2] = e1; + } + } + + // Fill out the edge adjacency information in the vertex array + for (int e = 0; e < edgeArray.size(); ++e) { + const Edge& edge = edgeArray[e]; + vertexArray[edge.vertexIndex[0]].edgeIndex.append(e); + vertexArray[edge.vertexIndex[1]].edgeIndex.append(~e); + } +} + + +void MeshAlg::weldBoundaryEdges( + Array<Face>& faceArray, + Array<Edge>& edgeArray, + Array<Vertex>& vertexArray) { + + // Copy over the original edge array + Array<Edge> oldEdgeArray = edgeArray; + + // newEdgeIndex[e] is the new index of the old edge with index e + // Note that newEdgeIndex[e] might be negative, indicating that + // the edge switched direction between the arrays. + Array<int> newEdgeIndex; + newEdgeIndex.resize(edgeArray.size()); + edgeArray.resize(0); + + // boundaryEdgeIndices[v_low] is an array of the indices of + // all boundary edges whose lower vertex is v_low. + Table<int, Array<int> > boundaryEdgeIndices; + + // Copy over non-boundary edges to the new array + for (int e = 0; e < oldEdgeArray.size(); ++e) { + if (oldEdgeArray[e].boundary()) { + + // Add to the boundary table + const int v_low = iMin(oldEdgeArray[e].vertexIndex[0], oldEdgeArray[e].vertexIndex[1]); + if (! boundaryEdgeIndices.containsKey(v_low)) { + boundaryEdgeIndices.set(v_low, Array<int>()); + } + boundaryEdgeIndices[v_low].append(e); + + // We'll fill out newEdgeIndex[e] later, when we find pairs + + } else { + + // Copy the edge to the new array + newEdgeIndex[e] = edgeArray.size(); + edgeArray.append(oldEdgeArray[e]); + + } + } + + + // Remove all edges from the table that have pairs. + Table<int, Array<int> >::Iterator cur = boundaryEdgeIndices.begin(); + Table<int, Array<int> >::Iterator end = boundaryEdgeIndices.end(); + while (cur != end) { + Array<int>& boundaryEdge = cur->value; + + for (int i = 0; i < boundaryEdge.size(); ++i) { + int ei = boundaryEdge[i]; + const Edge& edgei = oldEdgeArray[ei]; + + for (int j = i + 1; j < boundaryEdge.size(); ++j) { + int ej = boundaryEdge[j]; + const Edge& edgej = oldEdgeArray[ej]; + + // See if edge ei is the reverse (match) of edge ej. + + // True if the edges match + bool match = false; + + // True if edgej's vertex indices are reversed from + // edgei's (usually true). + bool reversej = false; + + int u = edgei.vertexIndex[0]; + int v = edgei.vertexIndex[1]; + + if (edgei.faceIndex[0] != Face::NONE) { + // verts|faces + // edgei = [u v A /] + + if (edgej.faceIndex[0] != Face::NONE) { + if ((edgej.vertexIndex[0] == v) && (edgej.vertexIndex[1] == u)) { + // This is the most common of the four cases + + // edgej = [v u B /] + match = true; + reversej = true; + } + } else { + if ((edgej.vertexIndex[0] == u) && (edgej.vertexIndex[1] == v)) { + // edgej = [u v / B] + match = true; + } + } + } else { + // edgei = [u v / A] + if (edgej.faceIndex[0] != Face::NONE) { + if ((edgej.vertexIndex[0] == u) && (edgej.vertexIndex[1] == v)) { + // edgej = [u v B /] + match = true; + } + } else { + if ((edgej.vertexIndex[0] == v) && (edgej.vertexIndex[1] == u)) { + // edgej = [v u / B] + match = true; + reversej = true; + } + } + } + + if (match) { + // ei and ej can be paired as a single edge + int e = edgeArray.size(); + Edge& edge = edgeArray.next(); + + // Follow the direction of edgei. + edge = edgei; + newEdgeIndex[ei] = e; + + // Insert the face index for edgej. + int fj = edgej.faceIndex[0]; + if (fj == Face::NONE) { + fj = edgej.faceIndex[1]; + } + + if (edge.faceIndex[0] == Face::NONE) { + edge.faceIndex[0] = fj; + } else { + edge.faceIndex[1] = fj; + } + + if (reversej) { + // The new edge is backwards of the old edge for ej + newEdgeIndex[ej] = ~e; + } else { + newEdgeIndex[ej] = e; + } + + // Remove both ei and ej from being candidates for future pairing. + // Remove ej first since it comes later in the list (removing + // ei would decrease the index of ej to j - 1). + boundaryEdge.fastRemove(j); + boundaryEdge.fastRemove(i); + + // Re-process element i, which is now a new edge index + --i; + + // Jump out of the j for-loop + break; + } + } + } + ++cur; + } + + // Anything remaining in the table is a real boundary edge; just copy it to + // the end of the array. + cur = boundaryEdgeIndices.begin(); + end = boundaryEdgeIndices.end(); + while (cur != end) { + Array<int>& boundaryEdge = cur->value; + + for (int b = 0; b < boundaryEdge.size(); ++b) { + const int e = boundaryEdge[b]; + + newEdgeIndex[e] = edgeArray.size(); + edgeArray.append(oldEdgeArray[e]); + } + + ++cur; + } + + // Finally, fix up edge indices in the face and vertex arrays + for (int f = 0; f < faceArray.size(); ++f) { + Face& face = faceArray[f]; + for (int i = 0; i < 3; ++i) { + int e = face.edgeIndex[i]; + + if (e < 0) { + face.edgeIndex[i] = ~newEdgeIndex[~e]; + } else { + face.edgeIndex[i] = newEdgeIndex[e]; + } + } + } + + for (int v = 0; v < vertexArray.size(); ++v) { + Vertex& vertex = vertexArray[v]; + for (int i = 0; i < vertex.edgeIndex.size(); ++i) { + int e = vertex.edgeIndex[i]; + + if (e < 0) { + vertex.edgeIndex[i] = ~newEdgeIndex[~e]; + } else { + vertex.edgeIndex[i] = newEdgeIndex[e]; + } + } + } +} + + +void MeshAlg::weldAdjacency( + const Array<Vector3>& originalGeometry, + Array<Face>& faceArray, + Array<Edge>& edgeArray, + Array<Vertex>& vertexArray, + double radius) { + + // Num vertices + const int n = originalGeometry.size(); + + // canonical[v] = first occurance of any vertex near oldVertexArray[v] + Array<int> canonical; + canonical.resize(n); + + Array<int> toNew, toOld; + // Throw away the new vertex array + Array<Vector3> dummy; + computeWeld(originalGeometry, dummy, toNew, toOld, radius); + + for (int v = 0; v < canonical.size(); ++v) { + // Round-trip through the toNew/toOld process. This will give + // us the original vertex. + canonical[v] = toOld[toNew[v]]; + } + + // Destroy vertexArray (we reconstruct it below) + vertexArray.clear(); + vertexArray.resize(n); + + bool hasBoundaryEdges = false; + + // Fix edge vertex indices + for (int e = 0; e < edgeArray.size(); ++e) { + Edge& edge = edgeArray[e]; + + const int v0 = canonical[edge.vertexIndex[0]]; + const int v1 = canonical[edge.vertexIndex[1]]; + + edge.vertexIndex[0] = v0; + edge.vertexIndex[1] = v1; + + vertexArray[v0].edgeIndex.append(e); + vertexArray[v1].edgeIndex.append(~e); + + hasBoundaryEdges = hasBoundaryEdges || edge.boundary(); + } + + // Fix face vertex indices + for (int f = 0; f < faceArray.size(); ++f) { + Face& face = faceArray[f]; + for (int i = 0; i < 3; ++i) { + const int v = canonical[face.vertexIndex[i]]; + + face.vertexIndex[i] = v; + + // Add the back pointer + vertexArray[v].faceIndex.append(f); + } + } + + if (hasBoundaryEdges) { + // As a result of the welding, some of the boundary edges at + // the end of the array may now have mates and no longer be + // boundaries. Try to pair these up. + + weldBoundaryEdges(faceArray, edgeArray, vertexArray); + } +} + + +void MeshAlg::debugCheckConsistency( + const Array<Face>& faceArray, + const Array<Edge>& edgeArray, + const Array<Vertex>& vertexArray) { + +#ifdef _DEBUG + for (int v = 0; v < vertexArray.size(); ++v) { + const MeshAlg::Vertex& vertex = vertexArray[v]; + + for (int i = 0; i < vertex.edgeIndex.size(); ++i) { + const int e = vertex.edgeIndex[i]; + debugAssert(edgeArray[(e >= 0) ? e : ~e].containsVertex(v)); + } + + for (int i = 0; i < vertex.faceIndex.size(); ++i) { + const int f = vertex.faceIndex[i]; + debugAssert(faceArray[f].containsVertex(v)); + } + + } + + for (int e = 0; e < edgeArray.size(); ++e) { + const MeshAlg::Edge& edge = edgeArray[e]; + + for (int i = 0; i < 2; ++i) { + debugAssert((edge.faceIndex[i] == MeshAlg::Face::NONE) || + faceArray[edge.faceIndex[i]].containsEdge(e)); + + debugAssert(vertexArray[edge.vertexIndex[i]].inEdge(e)); + } + } + + // Every face's edge must be on that face + for (int f = 0; f < faceArray.size(); ++f) { + const MeshAlg::Face& face = faceArray[f]; + for (int i = 0; i < 3; ++i) { + int e = face.edgeIndex[i]; + int ei = (e >= 0) ? e : ~e; + debugAssert(edgeArray[ei].inFace(f)); + + // Make sure the edge is oriented appropriately + if (e >= 0) { + debugAssert(edgeArray[ei].faceIndex[0] == (int)f); + } else { + debugAssert(edgeArray[ei].faceIndex[1] == (int)f); + } + + debugAssert(vertexArray[face.vertexIndex[i]].inFace(f)); + } + } +#else + (void)faceArray; + (void)edgeArray; + (void)vertexArray; +#endif // _DEBUG +} + +} // G3D namespace diff --git a/dep/src/g3dlite/MeshAlgWeld.cpp b/dep/src/g3dlite/MeshAlgWeld.cpp new file mode 100644 index 00000000000..6067f17c2fb --- /dev/null +++ b/dep/src/g3dlite/MeshAlgWeld.cpp @@ -0,0 +1,213 @@ +/** + @file MeshAlgWeld.cpp + + The MeshAlg::computeWeld method. + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2003-10-22 + @edited 2005-02-24 + + Copyright 2000-2003, Morgan McGuire. + All rights reserved. + + */ + +#include "G3D/MeshAlg.h" +#include "G3D/Table.h" +#include "G3D/Set.h" + +namespace G3D { + +namespace _internal { + +class Welder { +private: + + // Intentionally illegal + Welder& operator=(const Welder& w); + +public: + /** Indices of newVertexArray elements in <B>or near</B> a grid cell. */ + typedef Array<int> List; + + enum {GRID_RES = 32}; + + List grid[GRID_RES][GRID_RES][GRID_RES]; + + const Array<Vector3>& oldVertexArray; + Array<Vector3>& newVertexArray; + Array<int>& toNew; + Array<int>& toOld; + + /** Must be less than one grid cell, not checked */ + const double radius; + + /** (oldVertexArray[i] - offset) * scale is on the range [0, 1] */ + Vector3 offset; + Vector3 scale; + + Welder( + const Array<Vector3>& _oldVertexArray, + Array<Vector3>& _newVertexArray, + Array<int>& _toNew, + Array<int>& _toOld, + double _radius); + + /** + Computes the grid index from an ordinate. + */ + void toGridCoords(Vector3 v, int& x, int& y, int& z) const; + + /** Gets the index of a vertex, adding it to + newVertexArray if necessary. */ + int getIndex(const Vector3& vertex); + + void weld(); +}; + +} // namespace _internal + +} // namespace G3D + +template<> struct HashTrait<G3D::_internal::Welder::List*> { + static size_t hashCode(const G3D::_internal::Welder::List* key) { return reinterpret_cast<size_t>(key); } +}; + +namespace G3D { +namespace _internal { + +Welder::Welder( + const Array<Vector3>& _oldVertexArray, + Array<Vector3>& _newVertexArray, + Array<int>& _toNew, + Array<int>& _toOld, + double _radius) : + oldVertexArray(_oldVertexArray), + newVertexArray(_newVertexArray), + toNew(_toNew), + toOld(_toOld), + radius(_radius) { + + // Compute a scale factor that moves the range + // of all ordinates to [0, 1] + Vector3 minBound = Vector3::inf(); + Vector3 maxBound = -minBound; + + for (int i = 0; i < oldVertexArray.size(); ++i) { + minBound = minBound.min(oldVertexArray[i]); + maxBound = maxBound.max(oldVertexArray[i]); + } + + offset = minBound; + scale = maxBound - minBound; + for (int i = 0; i < 3; ++i) { + // The model might have zero extent along some axis + if (fuzzyEq(scale[i], 0.0)) { + scale[i] = 1.0; + } else { + scale[i] = 1.0 / scale[i]; + } + } +} + + +void Welder::toGridCoords(Vector3 v, int& x, int& y, int& z) const { + v = (v - offset) * scale; + x = iClamp(iFloor(v.x * GRID_RES), 0, GRID_RES - 1); + y = iClamp(iFloor(v.y * GRID_RES), 0, GRID_RES - 1); + z = iClamp(iFloor(v.z * GRID_RES), 0, GRID_RES - 1); +} + + +int Welder::getIndex(const Vector3& vertex) { + + int closestIndex = -1; + double distanceSquared = inf(); + + int ix, iy, iz; + toGridCoords(vertex, ix, iy, iz); + + // Check against all vertices within radius of this grid cube + const List& list = grid[ix][iy][iz]; + + for (int i = 0; i < list.size(); ++i) { + double d = (newVertexArray[list[i]] - vertex).squaredMagnitude(); + + if (d < distanceSquared) { + distanceSquared = d; + closestIndex = list[i]; + } + } + + if (distanceSquared <= radius * radius) { + + return closestIndex; + + } else { + + // This is a new vertex + int newIndex = newVertexArray.size(); + newVertexArray.append(vertex); + + // Create a new vertex and store its index in the + // neighboring grid cells (usually, only 1 neighbor) + + Set<List*> neighbors; + + for (float dx = -1; dx <= +1; ++dx) { + for (float dy = -1; dy <= +1; ++dy) { + for (float dz = -1; dz <= +1; ++dz) { + int ix, iy, iz; + toGridCoords(vertex + Vector3(dx, dy, dz) * radius, ix, iy, iz); + neighbors.insert(&(grid[ix][iy][iz])); + } + } + } + + Set<List*>::Iterator neighbor(neighbors.begin()); + Set<List*>::Iterator none(neighbors.end()); + + while (neighbor != none) { + (*neighbor)->append(newIndex); + ++neighbor; + } + + return newIndex; + } +} + + +void Welder::weld() { + newVertexArray.resize(0); + + // Prime the vertex positions + for (int i = 0; i < oldVertexArray.size(); ++i) { + getIndex(oldVertexArray[i]); + } + + // Now create the official remapping by snapping to + // nearby vertices. + toNew.resize(oldVertexArray.size()); + toOld.resize(newVertexArray.size()); + + for (int oi = 0; oi < oldVertexArray.size(); ++oi) { + toNew[oi] = getIndex(oldVertexArray[oi]); + toOld[toNew[oi]] = oi; + } +} + +} // internal namespace + + +void MeshAlg::computeWeld( + const Array<Vector3>& oldVertexArray, + Array<Vector3>& newVertexArray, + Array<int>& toNew, + Array<int>& toOld, + double radius) { + + _internal::Welder welder(oldVertexArray, newVertexArray, toNew, toOld, radius); + welder.weld(); +} + +} // G3D namespace diff --git a/dep/src/g3dlite/MeshBuilder.cpp b/dep/src/g3dlite/MeshBuilder.cpp new file mode 100644 index 00000000000..1bf2bab5d1c --- /dev/null +++ b/dep/src/g3dlite/MeshBuilder.cpp @@ -0,0 +1,113 @@ +/** + @file MeshBuilder.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2002-02-27 + @edited 2005-02-24 + */ + +#include "G3D/MeshBuilder.h" +#include "G3D/MeshAlg.h" + +namespace G3D { + +void MeshBuilder::setName(const std::string& n) { + name = n; +} + + +void MeshBuilder::commit(std::string& n, Array<int>& indexArray, Array<Vector3>& outvertexArray) { + n = name; + + // Make the data fit in a unit cube + centerTriList(); + + Array<int> toNew, toOld; + + if (close == MeshBuilder::AUTO_WELD) { + Array<int> index; + MeshAlg::createIndexArray(triList.size(), index); + double minEdgeLen, maxEdgeLen, meanEdgeLen, medianEdgeLen; + double minFaceArea, maxFaceArea, meanFaceArea, medianFaceArea; + MeshAlg::computeAreaStatistics(triList, index, + minEdgeLen, meanEdgeLen, medianEdgeLen, maxEdgeLen, + minFaceArea, meanFaceArea, medianFaceArea, maxFaceArea); + close = minEdgeLen * 0.1; + } + + MeshAlg::computeWeld(triList, outvertexArray, toNew, toOld, close); + + // Construct triangles + for (int t = 0; t < triList.size(); t += 3) { + int index[3]; + + for (int i = 0; i < 3; ++i) { + index[i] = toNew[t + i]; + } + + // Throw out zero size triangles + if ((index[0] != index[1]) && + (index[1] != index[2]) && + (index[2] != index[0])) { + indexArray.append(index[0], index[1], index[2]); + } + } +} + + +void MeshBuilder::centerTriList() { + // Compute the range of the vertices + Vector3 vmin, vmax; + + computeBounds(vmin, vmax); + + Vector3 diagonal = vmax - vmin; + double scale = max(max(diagonal.x, diagonal.y), diagonal.z) / 2; + debugAssert(scale > 0); + + Vector3 translation = vmin + diagonal / 2; + + // Center and scale all vertices in the input list + int v; + + //Matrix3 rot90 = Matrix3::fromAxisAngle(Vector3::UNIT_Y, toRadians(180)) * Matrix3::fromAxisAngle(Vector3::UNIT_X, toRadians(90)); + for (v = 0; v < triList.size(); ++v) { + triList[v] = (triList[v] - translation) / scale; + //triList[v] = rot90 * triList[v]; + } +} + + +void MeshBuilder::computeBounds(Vector3& min, Vector3& max) { + min = Vector3::inf(); + max = -min; + + int v; + for (v = 0; v < triList.size(); ++v) { + min = min.min(triList[v]); + max = max.max(triList[v]); + } +} + + +void MeshBuilder::addTriangle(const Vector3& a, const Vector3& b, const Vector3& c) { + triList.append(a, b, c); + + if (_twoSided) { + triList.append(c, b, a); + } +} + + +void MeshBuilder::addQuad(const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d) { + addTriangle(a, b, c); + addTriangle(a, c, d); +} + + +void MeshBuilder::addTriangle(const Triangle& t) { + addTriangle(t.vertex(0), t.vertex(1), t.vertex(2)); +} + +} // namespace diff --git a/dep/src/g3dlite/NetAddress.cpp b/dep/src/g3dlite/NetAddress.cpp new file mode 100644 index 00000000000..64d692d4763 --- /dev/null +++ b/dep/src/g3dlite/NetAddress.cpp @@ -0,0 +1,164 @@ +/** + @file NetMessage.cpp + + @maintainer Morgan McGuire, morgan@cs.brown.edu + @created 2005-02-06 + @edited 2005-02-06 + */ +#include "G3D/platform.h" +#include "G3D/NetAddress.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Array.h" +#include "G3D/stringutils.h" +#include "G3D/System.h" +#include "G3D/NetworkDevice.h" + +#if defined(G3D_LINUX) || defined(G3D_OSX) + #include <unistd.h> + #include <errno.h> + #include <sys/socket.h> + #include <netinet/in.h> + #include <arpa/inet.h> + #include <netdb.h> + #include <netinet/tcp.h> + #define _alloca alloca + +# ifndef SOCKADDR_IN +# define SOCKADDR_IN struct sockaddr_in +# endif +# ifndef SOCKET +# define SOCKET int +# endif + +// SOCKADDR_IN is supposed to be defined in NetAddress.h +#ifndef SOCKADDR_IN +# error Network headers included in wrong order +#endif +#endif + + +namespace G3D { + +NetAddress::NetAddress() { + System::memset(&addr, 0, sizeof(addr)); +} + +void NetAddress::init(uint32 host, uint16 port) { + if ((host != 0) || (port != 0)) { + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + if (host == 0) { + host = INADDR_ANY; + } + addr.sin_addr.s_addr = htonl(host); + } else { + System::memset(&addr, 0, sizeof(addr)); + } +} + + +NetAddress::NetAddress( + const std::string& hostname, + uint16 port) { + init(hostname, port); +} + + +void NetAddress::init( + const std::string& hostname, + uint16 port) { + + uint32 addr; + + if (hostname == "") { + addr = INADDR_NONE; + } else { + addr = inet_addr(hostname.c_str()); + } + + // The address wasn't in numeric form, resolve it + if (addr == INADDR_NONE) { + // Get the IP address of the server and store it in host + struct hostent* host = gethostbyname(hostname.c_str()); + + if (host == NULL) { + init(0, 0); + return; + } + + System::memcpy(&addr, host->h_addr_list[0], host->h_length); + } + + if (addr != INADDR_NONE) { + addr = ntohl(addr); + } + init(addr, port); +} + + +NetAddress::NetAddress(uint32 hostip, uint16 port) { + init(hostip, port); +} + + +NetAddress NetAddress::broadcastAddress(uint16 port) { + return NetAddress(NetworkDevice::instance()->broadcastAddressArray()[0], port); +} + + +NetAddress::NetAddress(const std::string& hostnameAndPort) { + + Array<std::string> part = stringSplit(hostnameAndPort, ':'); + + debugAssert(part.length() == 2); + init(part[0], atoi(part[1].c_str())); +} + + +NetAddress::NetAddress(const SOCKADDR_IN& a) { + addr = a; +} + + +NetAddress::NetAddress(const struct in_addr& addr, uint16 port) { + #ifdef G3D_WIN32 + init(ntohl(addr.S_un.S_addr), port); + #else + init(htonl(addr.s_addr), port); + #endif +} + + +void NetAddress::serialize(class BinaryOutput& b) const { + b.writeUInt32(ip()); + b.writeUInt16(port()); +} + + +void NetAddress::deserialize(class BinaryInput& b) { + uint32 i; + uint16 p; + + i = b.readUInt32(); + p = b.readUInt16(); + + init(i, p); +} + + +bool NetAddress::ok() const { + return addr.sin_family != 0; +} + + +std::string NetAddress::ipString() const { + return format("%s", inet_ntoa(*(in_addr*)&(addr.sin_addr))); +} + + +std::string NetAddress::toString() const { + return ipString() + format(":%d", ntohs(addr.sin_port)); +} + +} diff --git a/dep/src/g3dlite/NetworkDevice.cpp b/dep/src/g3dlite/NetworkDevice.cpp new file mode 100644 index 00000000000..246c97d4dbf --- /dev/null +++ b/dep/src/g3dlite/NetworkDevice.cpp @@ -0,0 +1,1362 @@ +/** + @file NetworkDevice.cpp + + @maintainer Morgan McGuire, morgan@cs.brown.edu + @created 2002-11-22 + @edited 2006-02-24 + */ + +#include <stdlib.h> +#include <time.h> +#include "G3D/platform.h" +#include "G3D/TextOutput.h" +#include "G3D/NetworkDevice.h" +#include "G3D/NetAddress.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Log.h" +#include "G3D/G3DGameUnits.h" +#include "G3D/stringutils.h" +#include "G3D/debug.h" + +#include <cstring> + +#if defined(G3D_LINUX) || defined(G3D_OSX) || defined(G3D_FREEBSD) +# include <sys/types.h> +# include <sys/socket.h> +# include <ifaddrs.h> +# include <netinet/in.h> +# include <net/if.h> +# ifdef __linux__ +# include <sys/ioctl.h> +# include <netinet/in.h> +# include <unistd.h> +# include <string.h> +// Match Linux to FreeBSD +# define AF_LINK AF_PACKET +# else +# include <net/if_dl.h> +# include <sys/sockio.h> +# endif + + #include <unistd.h> + #include <errno.h> + #include <sys/socket.h> + #include <netinet/in.h> + #include <arpa/inet.h> + #include <netdb.h> + #include <netinet/tcp.h> + #include <sys/ioctl.h> + #include <netinet/if_ether.h> + #include <net/ethernet.h> + #include <net/if.h> + + #include <sys/types.h> + + #define _alloca alloca + + /** Define an error code for non-windows platforms. */ + int WSAGetLastError() { + return -1; + } + + #define SOCKET_ERROR -1 + + static std::string socketErrorCode(int code) { + return G3D::format("CODE %d: %s\n", code, strerror(code)); + } + + static std::string socketErrorCode() { + return socketErrorCode(errno); + } + + static const int WSAEWOULDBLOCK = -100; + + typedef int SOCKET; + typedef struct sockaddr_in SOCKADDR_IN; + +#else + + // Windows + static std::string socketErrorCode(int code) { + LPTSTR formatMsg = NULL; + + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_IGNORE_INSERTS | + FORMAT_MESSAGE_FROM_SYSTEM, + NULL, + code, + 0, + (LPTSTR)&formatMsg, + 0, + NULL); + + return G3D::format("CODE %d: %s\n", code, formatMsg); + } + + static std::string socketErrorCode() { + return socketErrorCode(GetLastError()); + } + +#endif + + +#ifndef _SOCKLEN_T +# if defined(G3D_WIN32) || defined(G3D_OSX) + typedef int socklen_t; +# endif +#endif + +namespace G3D { + +NetworkDevice* NetworkDevice::s_instance = NULL; + +std::ostream& operator<<(std::ostream& os, const NetAddress& a) { + return os << a.toString(); +} + + +static void logSocketInfo(const SOCKET& sock) { + uint32 val; + socklen_t sz = 4; + int ret; + + ret = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&val, (socklen_t*)&sz); + logPrintf("SOL_SOCKET/SO_RCVBUF = %d\n", val); + + ret = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&val, (socklen_t*)&sz); + logPrintf("SOL_SOCKET/SO_SNDBUF = %d\n", val); + + // Note: timeout = 0 means no timeout + ret = getsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&val, (socklen_t*)&sz); + logPrintf("SOL_SOCKET/SO_RCVTIMEO = %d\n", val); + + ret = getsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&val, (socklen_t*)&sz); + logPrintf("SOL_SOCKET/SO_SNDTIMEO = %d\n", val); +} + + +///////////////////////////////////////////////////////////////////////////// + +/** Invokes select on one socket. Returns SOCKET_ERROR on error, 0 if + there is no read pending, sock if there a read pending. */ +static int selectOneReadSocket(const SOCKET& sock) { + // 0 time timeout is specified to poll and return immediately + struct timeval timeout; + timeout.tv_sec = 0; + timeout.tv_usec = 0; + + // Create a set that contains just this one socket + fd_set socketSet; + FD_ZERO(&socketSet); + FD_SET(sock, &socketSet); + + int ret = select(sock + 1, &socketSet, NULL, NULL, &timeout); + + return ret; +} + + +/** Returns true if the socket has a read pending */ +static bool readWaiting(const SOCKET& sock) { + int ret = selectOneReadSocket(sock); + + switch (ret) { + case SOCKET_ERROR: + logPrintf("ERROR: selectOneReadSocket returned " + "SOCKET_ERROR in readWaiting(). %s", socketErrorCode().c_str()); + // Return true so that we'll force an error on read and close + // the socket. + return true; + + case 0: + return false; + + default: + return true; + } +} + + +/** Invokes select on one socket. */ +static int selectOneWriteSocket(const SOCKET& sock) { + // 0 time timeout is specified to poll and return immediately + struct timeval timeout; + timeout.tv_sec = 0; + timeout.tv_usec = 0; + + // Create a set that contains just this one socket + fd_set socketSet; + FD_ZERO(&socketSet); + FD_SET(sock, &socketSet); + + return select(sock + 1, NULL, &socketSet, NULL, &timeout); +} + +/////////////////////////////////////////////////////////////////////////////// + +NetworkDevice* NetworkDevice::instance() { + if (s_instance == NULL) { + s_instance = new NetworkDevice(); + if (! s_instance->init()) { + delete s_instance; + s_instance = NULL; + } + } + return s_instance; +} + + +void NetworkDevice::cleanup() { + if (s_instance) { + s_instance->_cleanup(); + delete s_instance; + s_instance = NULL; + } +} + + +NetworkDevice::NetworkDevice() { + initialized = false; +} + + +NetworkDevice::~NetworkDevice() { +} + + +std::string NetworkDevice::localHostName() const { + char ac[128]; + if (gethostname(ac, sizeof(ac)) == -1) { + Log::common()->printf("Error while getting local host name\n"); + return "localhost"; + } + return gethostbyname(ac)->h_name; +} + +#ifndef G3D_WIN32 +const char* errnoToString() { + switch (errno) { + case EBADF: + return "file descriptor is invalid."; + + case EINVAL: + return "Request or argp is not valid."; + + case ENOTTY: + return + "file descriptor is not associated with a character special device OR " + "The specified request does not apply to the " + "kind of object that the descriptor fildes references."; + + case EADDRNOTAVAIL: + return "Address not available."; + + default: + { + static char buffer[20]; + sprintf(buffer, "Error %d", errno); + return buffer; + } + } +} +#endif + + +NetworkDevice::EthernetAdapter::EthernetAdapter() { + name = ""; + ip = 0; + hostname = ""; + subnet = 0; + broadcast = 0; + for (int i = 0; i < 6; ++i) { + mac[i] = 0; + } +} + +void NetworkDevice::EthernetAdapter::describe(TextOutput& t) const { + t.writeSymbol("{"); + t.pushIndent(); + t.writeNewline(); + + t.writeSymbols("hostname", "="); + t.writeString(hostname); + t.writeNewline(); + + t.writeSymbols("name", "="); + t.writeString(name); + t.writeNewline(); + + t.writeSymbols("ip", "="); + t.writeSymbol(formatIP(ip)); + t.writeNewline(); + + t.writeSymbols("subnet", "="); + t.writeSymbol(formatIP(subnet)); + t.writeNewline(); + + t.writeSymbols("broadcast", "="); + t.writeSymbol(formatIP(broadcast)); + t.writeNewline(); + + t.writeSymbols("mac", "="); + t.writeSymbol(formatMAC(mac)); + t.writeNewline(); + + t.popIndent(); + t.writeSymbol("}"); + t.writeNewline(); +} + + +void NetworkDevice::addAdapter(const EthernetAdapter& a) { + m_adapterArray.append(a); + if (a.broadcast != 0) { + int i = m_broadcastAddresses.findIndex(a.broadcast); + if (i == -1) { + m_broadcastAddresses.append(a.broadcast); + } + } +} + + +std::string NetworkDevice::formatIP(uint32 addr) { + return format("%3d.%3d.%3d.%3d", (addr >> 24) & 0xFF, (addr >> 16) & 0xFF, + (addr >> 8) & 0xFF, addr & 0xFF); +} + + +std::string NetworkDevice::formatMAC(const uint8 MAC[6]) { + return format("%02x:%02x:%02x:%02x:%02x:%02x", MAC[0], MAC[1], MAC[2], MAC[3], MAC[4], MAC[5]); +} + + +#ifdef G3D_WIN32 + +bool NetworkDevice::init() { + debugAssert(! initialized); + + logPrintf("Network Startup"); + logPrintf("Starting WinSock networking.\n"); + WSADATA wsda; + WSAStartup(MAKEWORD(G3D_WINSOCK_MAJOR_VERSION, G3D_WINSOCK_MINOR_VERSION), &wsda); + + std::string hostname = "localhost"; + { + char ac[128]; + if (gethostname(ac, sizeof(ac)) == -1) { + logPrintf("Warning: Error while getting local host name\n"); + } else { + hostname = gethostbyname(ac)->h_name; + } + } + + EthernetAdapter a; + a.hostname = hostname; + a.name = ""; + a.ip = NetAddress(hostname, 0).ip(); + + // TODO: Find subnet on Win32 + a.subnet = 0x0000FFFF; + + // TODO: Find broadcast on Win32 + a.broadcast = 0xFFFFFFFF; + + // TODO: find MAC on Win32 + + addAdapter(a); + + std::string machine = localHostName(); + std::string addr = NetAddress(machine, 0).ipString(); + logPrintf( + "Network:\n" + " Status: %s\n" + " Loaded winsock specification version %d (%d is " + "the highest available)\n" + " %d sockets available\n" + " Largest UDP datagram packet size is %d bytes\n\n", + wsda.szDescription, + wsda.szSystemStatus, + wsda.wVersion, + wsda.wHighVersion, + wsda.iMaxSockets, + wsda.iMaxUdpDg); + + // TODO: WSAIoctl for subnet and broadcast addresses + // http://msdn.microsoft.com/en-us/library/ms741621(VS.85).aspx + // + // TODO: SIO_GET_INTERFACE_LIST + + initialized = true; + + return true; +} +#endif + + +#if defined(G3D_LINUX) || defined(G3D_OSX) || defined(G3D_FREEBSD) + +const sockaddr_in* castToIP4(const sockaddr* addr) { + if (addr == NULL) { + return NULL; + } else if (addr->sa_family == AF_INET) { + // An IPv4 address + return reinterpret_cast<const sockaddr_in*>(addr); + } else { + // Not an IPv4 address + return NULL; + } +} + +uint32 getIP(const sockaddr_in* addr) { + if (addr != NULL) { + return ntohl(addr->sin_addr.s_addr); + } else { + return 0; + } +} + + +bool NetworkDevice::init() { + debugAssert(! initialized); + + // Used for combining the MAC and ip information + typedef Table<std::string, EthernetAdapter> AdapterTable; + + AdapterTable table; + + // Head of a linked list of network interfaces on this machine + ifaddrs* ifap = NULL; + + int r = getifaddrs(&ifap); + + if (r != 0) { + logPrintf("ERROR: getifaddrs returned %d\n", r); + return false; + } + + ifaddrs* current = ifap; + + if (current == NULL) { + logPrintf("WARNING: No network interfaces found\n"); + EthernetAdapter a; + a.name = "fallback"; + a.hostname = "localhost"; + a.ip = (127 << 24) | 1; + a.broadcast = 0xFFFFFFFF; + a.subnet = 0x000000FF; + addAdapter(a); + + } else { + + while (current != NULL) { + + bool up = (current->ifa_flags & IFF_UP); + bool loopback = (current->ifa_flags & IFF_LOOPBACK); + + if (! up || loopback) { + // Skip this adapter; it is offline or is a loopback + current = current->ifa_next; + continue; + } + + if (! table.containsKey(current->ifa_name)) { + EthernetAdapter a; + a.name = current->ifa_name; + table.set(a.name, a); + } + + // This adapter must exist because it was created above + EthernetAdapter& adapter = table[current->ifa_name]; + + const sockaddr_in* interfaceAddress = castToIP4(current->ifa_addr); + const sockaddr_in* broadcastAddress = castToIP4(current->ifa_dstaddr); + const sockaddr_in* subnetMask = castToIP4(current->ifa_netmask); + + uint32 ip = getIP(interfaceAddress); + uint32 ba = getIP(broadcastAddress); + uint32 sn = getIP(subnetMask); + + if (ip != 0) { + adapter.ip = ip; + } + + if (ba != 0) { + adapter.broadcast = ba; + } + + if (sn != 0) { + adapter.subnet = sn; + } + + uint8_t* MAC = NULL; + // Extract MAC address + if ((current->ifa_addr != NULL) && (current->ifa_addr->sa_family == AF_LINK)) { +# ifdef __linux__ + { + // Linux + struct ifreq ifr; + + int fd = socket(AF_INET, SOCK_DGRAM, 0); + + ifr.ifr_addr.sa_family = AF_INET; + strcpy(ifr.ifr_name, current->ifa_name); + ioctl(fd, SIOCGIFHWADDR, &ifr); + close(fd); + + MAC = reinterpret_cast<uint8_t*>(ifr.ifr_hwaddr.sa_data); + } +# else + { + // The MAC address and the interfaceAddress come in as + // different interfaces with the same name. + + // Posix/FreeBSD/Mac OS + sockaddr_dl* sdl = (struct sockaddr_dl *)current->ifa_addr; + MAC = reinterpret_cast<uint8_t*>(LLADDR(sdl)); + } +# endif + + // See if there was a MAC address + if (MAC != NULL) { + bool anyNonZero = false; + for (int i = 0; i < 6; ++i) { + anyNonZero = anyNonZero || (MAC[i] != 0); + } + if (anyNonZero) { + System::memcpy(adapter.mac, MAC, 6); + } + } + } + + current = current->ifa_next; + } + + freeifaddrs(ifap); + ifap = NULL; + } + + // Extract all interesting adapters from the table + for (AdapterTable::Iterator it = table.begin(); it.hasMore(); ++it) { + const EthernetAdapter& adapter = it->value; + + // Only add adapters that have IP addresses + if (adapter.ip != 0) { + addAdapter(adapter); + } else { + logPrintf("NetworkDevice: Ignored adapter %s because ip = 0\n", adapter.name.c_str()); + } + } + + initialized = true; + + return true; +} + +#endif + + +void NetworkDevice::_cleanup() { + debugAssert(initialized); + + logPrintf("Network Cleanup"); +# ifdef G3D_WIN32 + WSACleanup(); +# endif + logPrintf("Network cleaned up."); +} + +bool NetworkDevice::bind(SOCKET sock, const NetAddress& addr) const { + Log::common()->printf("Binding socket %d on port %d ", + sock, htons(addr.addr.sin_port)); + if (::bind(sock, (struct sockaddr*)&(addr.addr), sizeof(addr.addr)) == + SOCKET_ERROR) { + + Log::common()->println("FAIL"); + Log::common()->println(socketErrorCode()); + closesocket(sock); + return false; + } + + Log::common()->println("Ok"); + return true; +} + + +void NetworkDevice::closesocket(SOCKET& sock) const { + if (sock != 0) { + #ifdef G3D_WIN32 + ::closesocket(sock); + #else + close(sock); + #endif + + Log::common()->printf("Closed socket %d\n", sock); + sock = 0; + } +} + + +void NetworkDevice::localHostAddresses(Array<NetAddress>& array) const { + array.resize(0); + + char ac[128]; + + if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR) { + Log::common()->printf("Error while getting local host name\n"); + return; + } + + struct hostent* phe = gethostbyname(ac); + if (phe == 0) { + Log::common()->printf("Error while getting local host address\n"); + return; + } + + for (int i = 0; (phe->h_addr_list[i] != 0); ++i) { + struct in_addr addr; + memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr)); + array.append(NetAddress(addr)); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +Conduit::Conduit() : binaryOutput("<memory>", G3D_LITTLE_ENDIAN) { + sock = 0; + mSent = 0; + mReceived = 0; + bSent = 0; + bReceived = 0; +} + + +Conduit::~Conduit() { + NetworkDevice::instance()->closesocket(sock); +} + + +uint64 Conduit::bytesSent() const { + return bSent; +} + + +uint64 Conduit::bytesReceived() const { + return bReceived; +} + + +uint64 Conduit::messagesSent() const { + return mSent; +} + + +uint64 Conduit::messagesReceived() const { + return mReceived; +} + + +bool Conduit::ok() const { + return (sock != 0) && (sock != SOCKET_ERROR); +} + + +bool Conduit::messageWaiting() { + return readWaiting(sock); +} + + +/** + Increases the send and receive sizes of a socket to 2 MB from 8k + */ +static void increaseBufferSize(SOCKET sock) { + + // Increase the buffer size; the default (8192) is too easy to + // overflow when the network latency is high. + { + uint32 val = 1024 * 1024 * 2; + if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, + (char*)&val, sizeof(val)) == SOCKET_ERROR) { + Log::common()->printf("WARNING: Increasing socket " + "receive buffer to %d failed.\n", val); + Log::common()->println(socketErrorCode()); + } + + if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, + (char*)&val, sizeof(val)) == SOCKET_ERROR) { + Log::common()->printf("WARNING: Increasing socket " + "send buffer to %d failed.\n", val); + Log::common()->println(socketErrorCode()); + } + } +} + +////////////////////////////////////////////////////////////////////////////// + +ReliableConduitRef ReliableConduit::create(const NetAddress& address) { + return new ReliableConduit(address); +} + + +ReliableConduit::ReliableConduit( + const NetAddress& _addr) : state(NO_MESSAGE), receiveBuffer(NULL), + receiveBufferTotalSize(0), receiveBufferUsedSize(0) { + + NetworkDevice* nd = NetworkDevice::instance(); + + messageType = 0; + + addr = _addr; + Log::common()->print("Creating a TCP socket "); + sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); + + if (sock == SOCKET_ERROR) { + Log::common()->println("FAIL"); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + return; + } + + Log::common()->println("Ok"); + + // Setup socket options (both constructors should set the same options) + + // Disable Nagle's algorithm (we send lots of small packets) + const int T = true; + if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, + (const char*)&T, sizeof(T)) == SOCKET_ERROR) { + + Log::common()->println("WARNING: Disabling Nagel's " + "algorithm failed."); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->println("Disabled Nagel's algorithm."); + } + + // Set the NO LINGER option so the socket doesn't hang around if + // there is unsent data in the queue when it closes. + struct linger ling; + ling.l_onoff = 0; + ling.l_linger = 0; + if (setsockopt(sock, SOL_SOCKET, SO_LINGER, + (const char*)&ling, sizeof(ling)) == SOCKET_ERROR) { + + Log::common()->println("WARNING: Setting socket no linger failed."); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->println("Set socket option no_linger."); + } + + // Set reuse address so that a new server can start up soon after + // an old one has closed. + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + (const char*)&T, sizeof(T)) == SOCKET_ERROR) { + + Log::common()->println("WARNING: Setting socket reuseaddr failed."); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->println("Set socket option reuseaddr."); + } + + // Ideally, we'd like to specify IPTOS_LOWDELAY as well. + + logSocketInfo(sock); + + increaseBufferSize(sock); + + Log::common()->printf("Created TCP socket %d\n", sock); + + std::string x = addr.toString(); + Log::common()->printf("Connecting to %s on TCP socket %d ", x.c_str(), sock); + + int ret = connect(sock, (struct sockaddr *) &(addr.addr), sizeof(addr.addr)); + + if (ret == WSAEWOULDBLOCK) { + RealTime t = System::time() + 5.0; + // Non-blocking; we must wait until select returns non-zero + while ((selectOneWriteSocket(sock) == 0) && (System::time() < t)) { + System::sleep(0.02); + } + + // TODO: check for failure on the select call + + } else if (ret != 0) { + sock = (SOCKET)SOCKET_ERROR; + Log::common()->println("FAIL"); + Log::common()->println(socketErrorCode()); + return; + } + + Log::common()->println("Ok"); +} + + +ReliableConduit::ReliableConduit( + const SOCKET& _sock, + const NetAddress& _addr) : + state(NO_MESSAGE), + receiveBuffer(NULL), + receiveBufferTotalSize(0), + receiveBufferUsedSize(0) { + sock = _sock; + addr = _addr; + + messageType = 0; + + // Setup socket options (both constructors should set the same options) + + // Disable Nagle's algorithm (we send lots of small packets) + const int T = true; + if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, + (const char*)&T, sizeof(T)) == SOCKET_ERROR) { + + Log::common()->println("WARNING: Disabling Nagel's algorithm failed."); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->println("Disabled Nagel's algorithm."); + } + + // Set the NO LINGER option so the socket doesn't hang around if + // there is unsent data in the queue when it closes. + struct linger ling; + ling.l_onoff = 0; + ling.l_linger = 0; + if (setsockopt(sock, SOL_SOCKET, SO_LINGER, + (const char*)&ling, sizeof(ling)) == SOCKET_ERROR) { + + Log::common()->println("WARNING: Setting socket no linger failed."); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->println("Set socket option no_linger."); + } + + // Set reuse address so that a new server can start up soon after + // an old one has closed. + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + (const char*)&T, sizeof(T)) == SOCKET_ERROR) { + + Log::common()->println("WARNING: Setting socket reuseaddr failed."); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->println("Set socket option reuseaddr."); + } + + // Ideally, we'd like to specify IPTOS_LOWDELAY as well. + + logSocketInfo(sock); +} + + +ReliableConduit::~ReliableConduit() { + free(receiveBuffer); + receiveBuffer = NULL; + receiveBufferTotalSize = 0; + receiveBufferUsedSize = 0; +} + + +bool ReliableConduit::messageWaiting() { + switch (state) { + case HOLDING: + // We've already read the message and are waiting + // for a receive call. + return true; + + case RECEIVING: + + if (! ok()) { + return false; + } + // We're currently receiving the message. Read a little more. + receiveIntoBuffer(); + + if (messageSize == receiveBufferUsedSize) { + // We've read the whole mesage. Switch to holding state + // and return true. + state = HOLDING; + return true; + } else { + // There are more bytes left to read. We'll read them on + // the next call. Because the *entire* message is not ready, + // return false. + return false; + } + break; + + case NO_MESSAGE: + if (Conduit::messageWaiting()) { + // Message incoming. Read the header. + + state = RECEIVING; + receiveHeader(); + + // Loop back around now that we're in the receive state; we + // may be able to read the whole message before returning + // to the caller. + return messageWaiting(); + } else { + // No message incoming. + return false; + } + } + + debugAssertM(false, "Should not reach this point"); + return false; +} + + +uint32 ReliableConduit::waitingMessageType() { + // The messageWaiting call is what actually receives the message. + if (messageWaiting()) { + return messageType; + } else { + return 0; + } +} + + +void ReliableConduit::sendBuffer(const BinaryOutput& b) { + NetworkDevice* nd = NetworkDevice::instance(); + int ret = ::send(sock, (const char*)b.getCArray(), b.size(), 0); + + if (ret == SOCKET_ERROR) { + Log::common()->println("Error occured while sending message."); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + return; + } + + ++mSent; + bSent += b.size(); + + // Verify the packet was actually sent + // Conversion to unsigned is safe because -1 is caught earlier + debugAssert(ret == b.size()); +} + + +/** Null serializer. Used by reliable conduit::send(type) */ +class Dummy { +public: + void serialize(BinaryOutput& b) const { (void)b; } +}; + + +void ReliableConduit::send(uint32 type) { + static Dummy dummy; + send(type, dummy); +} + + + +NetAddress ReliableConduit::address() const { + return addr; +} + + +void ReliableConduit::receiveHeader() { + NetworkDevice* nd = NetworkDevice::instance(); + debugAssert(state == RECEIVING); + + // Read the type + uint32 tmp; + int ret = recv(sock, (char*)&tmp, sizeof(tmp), 0); + + // The type is the first four bytes. It is little endian. + if (System::machineEndian() == G3D_LITTLE_ENDIAN) { + messageType = tmp; + } else { + // Swap the byte order + for (int i = 0; i < 4; ++i) { + ((char*)&messageType)[i] = ((char*)&tmp)[3 - i]; + } + } + + if ((ret == SOCKET_ERROR) || (ret != sizeof(messageType))) { + Log::common()->printf("Call to recv failed. ret = %d," + " sizeof(messageType) = %d\n", + (int)ret, (int)sizeof(messageType)); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + messageType = 0; + return; + } + + // Read the size + ret = recv(sock, (char*)&messageSize, sizeof(messageSize), 0); + + if ((ret == SOCKET_ERROR) || (ret != sizeof(messageSize))) { + Log::common()->printf("Call to recv failed. ret = %d," + " sizeof(len) = %d\n", (int)ret, + (int)sizeof(messageSize)); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + messageType = 0; + return; + } + + messageSize = ntohl(messageSize); + debugAssert(messageSize < 6e7); + + debugAssert(receiveBufferUsedSize == 0); + + // Extend the size of the buffer. + if (messageSize > receiveBufferTotalSize) { + receiveBuffer = realloc(receiveBuffer, messageSize); + receiveBufferTotalSize = messageSize; + } + + if (receiveBuffer == NULL) { + Log::common()->println("Could not allocate a memory buffer " + "during receivePacket."); + nd->closesocket(sock); + } + + bReceived += 4; +} + + +void ReliableConduit::receiveIntoBuffer() { + NetworkDevice* nd = NetworkDevice::instance(); + + debugAssert(state == RECEIVING); + debugAssert(messageType != 0); + debugAssertM(receiveBufferUsedSize < messageSize, "Message already received."); + debugAssertM(messageSize >= receiveBufferUsedSize, "Message size overflow."); + + // Read the data itself + int ret = 0; + uint32 left = messageSize - receiveBufferUsedSize; + int count = 0; + while ((ret != SOCKET_ERROR) && (left > 0) && (count < 100)) { + + ret = recv(sock, ((char*)receiveBuffer) + receiveBufferUsedSize, left, 0); + + if (ret > 0) { + left -= ret; + receiveBufferUsedSize += ret; + bReceived += ret; + + if (left > 0) { + // There's still more. Give the machine a chance to read + // more data, but don't wait forever. + + ++count; + System::sleep(0.001); + } + } else { + // Something went wrong; our blocking read returned nothing. + break; + } + } + + if ((ret == 0) || (ret == SOCKET_ERROR)) { + + if (ret == SOCKET_ERROR) { + Log::common()->printf("Call to recv failed. ret = %d," + " sizeof(messageSize) = %d\n", ret, messageSize); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->printf("recv returned 0\n"); + } + nd->closesocket(sock); + return; + } + + ++mReceived; +} + + +/////////////////////////////////////////////////////////////////////////////// +LightweightConduitRef LightweightConduit::create( + uint16 receivePort, + bool enableReceive, + bool enableBroadcast) { + + return new LightweightConduit(receivePort, enableReceive, enableBroadcast); +} + +LightweightConduit::LightweightConduit( + uint16 port, + bool enableReceive, + bool enableBroadcast) { + NetworkDevice* nd = NetworkDevice::instance(); + + Log::common()->print("Creating a UDP socket "); + sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + + if (sock == SOCKET_ERROR) { + sock = 0; + Log::common()->println("FAIL"); + Log::common()->println(socketErrorCode()); + return; + } + Log::common()->println("Ok"); + + if (enableReceive) { + debugAssert(port != 0); + if (! nd->bind(sock, NetAddress(0, port))) { + nd->closesocket(sock); + sock = (SOCKET)SOCKET_ERROR; + } + } + + // Figuring out the MTU seems very complicated, so we just set it to 1000, + // which is likely to be safe. See IP_MTU for more information. + MTU = 1000; + + increaseBufferSize(sock); + + if (enableBroadcast) { + int TR = true; + if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, + (const char*)&TR, sizeof(TR)) != 0) { + Log::common()->println("Call to setsockopt failed"); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + sock = 0; + return; + } + } + + Log::common()->printf("Done creating UDP socket %d\n", sock); + + alreadyReadMessage = false; +} + + +LightweightConduit::~LightweightConduit() { +} + + +bool LightweightConduit::receive(NetAddress& sender) { + // This both checks to ensure that a message was waiting and + // actively consumes the message from the network stream if + // it has not been read yet. + uint32 t = waitingMessageType(); + if (t == 0) { + return false; + } + + sender = messageSender; + alreadyReadMessage = false; + + if (messageBuffer.size() < 4) { + // Something went wrong + return false; + } + + return true; +} + + +void LightweightConduit::sendBuffer(const NetAddress& a, BinaryOutput& b) { + NetworkDevice* nd = NetworkDevice::instance(); + if (sendto(sock, (const char*)b.getCArray(), b.size(), 0, + (struct sockaddr *) &(a.addr), sizeof(a.addr)) == SOCKET_ERROR) { + Log::common()->printf("Error occured while sending packet " + "to %s\n", inet_ntoa(a.addr.sin_addr)); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + } else { + ++mSent; + bSent += b.size(); + } +} + + +bool LightweightConduit::messageWaiting() { + // We may have already pulled the message off the network stream + return alreadyReadMessage || Conduit::messageWaiting(); +} + + +uint32 LightweightConduit::waitingMessageType() { + NetworkDevice* nd = NetworkDevice::instance(); + if (! messageWaiting()) { + return 0; + } + + if (! alreadyReadMessage) { + messageBuffer.resize(8192); + + SOCKADDR_IN remote_addr; + int iRemoteAddrLen = sizeof(sockaddr); + + int ret = recvfrom(sock, (char*)messageBuffer.getCArray(), + messageBuffer.size(), 0, (struct sockaddr *) &remote_addr, + (socklen_t*)&iRemoteAddrLen); + + if (ret == SOCKET_ERROR) { + Log::common()->println("Error: recvfrom failed in " + "LightweightConduit::waitingMessageType()."); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + messageBuffer.resize(0); + messageSender = NetAddress(); + messageType = 0; + return 0; + } + + messageSender = NetAddress(remote_addr); + + ++mReceived; + bReceived += ret; + + messageBuffer.resize(ret, DONT_SHRINK_UNDERLYING_ARRAY); + + // The type is the first four bytes. It is little endian. + if (System::machineEndian() == G3D_LITTLE_ENDIAN) { + messageType = *((uint32*)messageBuffer.getCArray()); + } else { + // Swap the byte order + for (int i = 0; i < 4; ++i) { + ((char*)&messageType)[i] = messageBuffer[3 - i]; + } + } + + alreadyReadMessage = true; + } + + return messageType; +} + + +/////////////////////////////////////////////////////////////////////////////// + +NetListenerRef NetListener::create(const uint16 port) { + return new NetListener(port); +} + + +NetListener::NetListener(uint16 port) { + NetworkDevice* nd = NetworkDevice::instance(); + + // Start the listener socket + Log::common()->print("Creating a listener "); + sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); + + if (sock == SOCKET_ERROR) { + Log::common()->printf("FAIL"); + Log::common()->println(socketErrorCode()); + return; + } + Log::common()->println("Ok"); + + const int T = true; + + // Set reuse address so that a new server can start up soon after + // an old one has closed. + if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + (const char*)&T, sizeof(T)) == SOCKET_ERROR) { + + Log::common()->println("WARNING: Setting socket reuseaddr failed."); + Log::common()->println(socketErrorCode()); + } else { + Log::common()->println("Set socket option reuseaddr."); + } + + + if (! nd->bind(sock, NetAddress(0, port))) { + Log::common()->printf("Unable to bind!\n"); + nd->closesocket(sock); + sock = (SOCKET)SOCKET_ERROR; + return; + } + + Log::common()->printf("Listening on port %5d ", port); + + // listen is supposed to return 0 when there is no error. + // The 2nd argument is the number of connections to allow pending + // at any time. + int L = listen(sock, 100); + if (L == SOCKET_ERROR) { + Log::common()->println("FAIL"); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + sock = (SOCKET)SOCKET_ERROR; + return; + } + Log::common()->println("Ok"); + Log::common()->printf("Now listening on socket %d.\n\n", sock); +} + + +NetListener::~NetListener() { + NetworkDevice* nd = NetworkDevice::instance(); + nd->closesocket(sock); +} + + +ReliableConduitRef NetListener::waitForConnection() { + NetworkDevice* nd = NetworkDevice::instance(); + // The address of the connecting host + SOCKADDR_IN remote_addr; + int iAddrLen = sizeof(remote_addr); + + Log::common()->println("Blocking in NetListener::waitForConnection()."); + + SOCKET sClient = accept(sock, (struct sockaddr*) &remote_addr, + (socklen_t*)&iAddrLen); + + if (sClient == SOCKET_ERROR) { + Log::common()->println("Error in NetListener::acceptConnection."); + Log::common()->println(socketErrorCode()); + nd->closesocket(sock); + return NULL; + } + + Log::common()->printf("%s connected, transferred to socket %d.\n", + inet_ntoa(remote_addr.sin_addr), sClient); + + #ifndef G3D_WIN32 + return new ReliableConduit(sClient, + NetAddress(htonl(remote_addr.sin_addr.s_addr), + ntohs(remote_addr.sin_port))); + #else + return new ReliableConduit(sClient, + NetAddress(ntohl(remote_addr.sin_addr.S_un.S_addr), + ntohs(remote_addr.sin_port))); + #endif +} + + +bool NetListener::ok() const { + return (sock != 0) && (sock != SOCKET_ERROR); +} + + +bool NetListener::clientWaiting() const { + return readWaiting(sock); +} + +//////////////////////////////////////////////////////////////////////////////////////////////// + +void NetworkDevice::describeSystem( + TextOutput& t) { + + t.writeSymbols("Network", "{"); + t.writeNewline(); + t.pushIndent(); + + for (int i = 0; i < m_adapterArray.size(); ++i) { + m_adapterArray[i].describe(t); + } + + + t.popIndent(); + t.writeSymbols("}"); + t.writeNewline(); + t.writeNewline(); +} + + +void NetworkDevice::describeSystem( + std::string& s) { + + TextOutput t; + describeSystem(t); + t.commitString(s); +} + +} // namespace diff --git a/dep/src/g3dlite/PhysicsFrame.cpp b/dep/src/g3dlite/PhysicsFrame.cpp new file mode 100644 index 00000000000..28ba8f8d477 --- /dev/null +++ b/dep/src/g3dlite/PhysicsFrame.cpp @@ -0,0 +1,77 @@ +/** + @file PhysicsFrame.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2002-07-09 + @edited 2006-01-25 +*/ + +#include "G3D/platform.h" +#include "G3D/PhysicsFrame.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +PhysicsFrame::PhysicsFrame() { + translation = Vector3::zero(); + rotation = Quat(); +} + + +PhysicsFrame::PhysicsFrame( + const CoordinateFrame& coordinateFrame) { + + translation = coordinateFrame.translation; + rotation = Quat(coordinateFrame.rotation); +} + + +PhysicsFrame PhysicsFrame::operator*(const PhysicsFrame& other) const { + PhysicsFrame result; + + result.rotation = rotation * other.rotation; + result.translation = translation + rotation.toRotationMatrix() * other.translation; + + return result; +} + + +CoordinateFrame PhysicsFrame::toCoordinateFrame() const { + CoordinateFrame f; + + f.translation = translation; + f.rotation = rotation.toRotationMatrix(); + + return f; +} + + +PhysicsFrame PhysicsFrame::lerp( + const PhysicsFrame& other, + float alpha) const { + + PhysicsFrame result; + + result.translation = translation.lerp(other.translation, alpha); + result.rotation = rotation.slerp(other.rotation, alpha); + + return result; +} + + +void PhysicsFrame::deserialize(class BinaryInput& b) { + translation.deserialize(b); + rotation.deserialize(b); +} + + +void PhysicsFrame::serialize(class BinaryOutput& b) const { + translation.serialize(b); + rotation.serialize(b); +} + + +}; // namespace + diff --git a/dep/src/g3dlite/Plane.cpp b/dep/src/g3dlite/Plane.cpp index 5ae60b0f762..9b7991c0333 100644 --- a/dep/src/g3dlite/Plane.cpp +++ b/dep/src/g3dlite/Plane.cpp @@ -1,33 +1,51 @@ /** @file Plane.cpp - - @maintainer Morgan McGuire, matrix@graphics3d.com - + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2003-02-06 @edited 2006-01-29 */ #include "G3D/platform.h" -#include "G3D/format.h" #include "G3D/Plane.h" +#include "G3D/BinaryOutput.h" +#include "G3D/BinaryInput.h" #include "G3D/stringutils.h" namespace G3D { +Plane::Plane(class BinaryInput& b) { + deserialize(b); +} + + +void Plane::serialize(class BinaryOutput& b) const { + _normal.serialize(b); + b.writeFloat64(_distance); +} + + +void Plane::deserialize(class BinaryInput& b) { + _normal.deserialize(b); + _distance = (float)b.readFloat64(); +} + + Plane::Plane( Vector4 point0, Vector4 point1, Vector4 point2) { debugAssertM( - point0.w != 0 || - point1.w != 0 || + point0.w != 0 || + point1.w != 0 || point2.w != 0, "At least one point must be finite."); // Rotate the points around so that the finite points come first. - while ((point0.w == 0) && + while ((point0.w == 0) && ((point1.w == 0) || (point2.w != 0))) { Vector4 temp = point0; point0 = point1; @@ -60,6 +78,7 @@ Plane::Plane( _distance = _normal.dot(point0.xyz()); } + Plane::Plane( const Vector3& point0, const Vector3& point1, @@ -69,14 +88,16 @@ Plane::Plane( _distance = _normal.dot(point0); } + Plane::Plane( const Vector3& __normal, const Vector3& point) { - _normal = __normal.direction(); + _normal = __normal.direction(); _distance = _normal.dot(point); } + Plane Plane::fromEquation(float a, float b, float c, float d) { Vector3 n(a, b, c); float magnitude = n.magnitude(); @@ -85,11 +106,13 @@ Plane Plane::fromEquation(float a, float b, float c, float d) { return Plane(n, -d); } + void Plane::flip() { _normal = -_normal; _distance = -_distance; } + void Plane::getEquation(Vector3& n, float& d) const { double _d; getEquation(n, _d); @@ -101,6 +124,7 @@ void Plane::getEquation(Vector3& n, double& d) const { d = -_distance; } + void Plane::getEquation(float& a, float& b, float& c, float& d) const { double _a, _b, _c, _d; getEquation(_a, _b, _c, _d); @@ -117,9 +141,9 @@ void Plane::getEquation(double& a, double& b, double& c, double& d) const { d = -_distance; } + std::string Plane::toString() const { return format("Plane(%g, %g, %g, %g)", _normal.x, _normal.y, _normal.z, _distance); } } - diff --git a/dep/src/g3dlite/PrecomputedRandom.cpp b/dep/src/g3dlite/PrecomputedRandom.cpp new file mode 100644 index 00000000000..387ded35195 --- /dev/null +++ b/dep/src/g3dlite/PrecomputedRandom.cpp @@ -0,0 +1,125 @@ +/** + @file PrecomputedRandom.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2009-03-31 + @edited 2009-07-01 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/PrecomputedRandom.h" +#include "G3D/System.h" + +namespace G3D { + +PrecomputedRandom::PrecomputedRandom(int dataSize, uint32 seed) : + Random((void*)NULL), + m_hemiUniform(NULL), + m_sphereBits(NULL), + m_modMask(dataSize - 1), + m_freeData(true) { + + alwaysAssertM(isPow2(dataSize), "dataSize must be a power of 2"); + m_index = seed & m_modMask; + + HemiUniformData* h; + SphereBitsData* s; + m_hemiUniform = h = (HemiUniformData*) System::malloc(sizeof(HemiUniformData) * dataSize); + m_sphereBits = s = (SphereBitsData*) System::malloc(sizeof(SphereBitsData) * dataSize); + + Random r; + + for (int i = 0; i < dataSize; ++i) { + h[i].uniform = r.uniform(); + r.cosHemi(h[i].cosHemiX, h[i].cosHemiY, h[i].cosHemiZ); + + s[i].bits = r.bits(); + r.sphere(s[i].sphereX, s[i].sphereY, s[i].sphereZ); + } + +} + + +PrecomputedRandom::PrecomputedRandom(const HemiUniformData* data1, const SphereBitsData* data2, int dataSize, uint32 seed) : + Random((void*)NULL), + m_hemiUniform(data1), + m_sphereBits(data2), + m_modMask(dataSize - 1), + m_freeData(false) { + + m_index = seed & m_modMask; + alwaysAssertM(isPow2(dataSize), "dataSize must be a power of 2"); +} + + +PrecomputedRandom::~PrecomputedRandom() { + if (m_freeData) { + System::free(const_cast<HemiUniformData*>(m_hemiUniform)); + System::free(const_cast<SphereBitsData*>(m_sphereBits)); + } +} + +float PrecomputedRandom::uniform(float low, float high) { + m_index = (m_index + 1) & m_modMask; + return low + m_hemiUniform[m_index].uniform * (high - low); +} + + +float PrecomputedRandom::uniform() { + m_index = (m_index + 1) & m_modMask; + return m_hemiUniform[m_index].uniform; +} + + +void PrecomputedRandom::cosHemi(float& x, float& y, float& z) { + m_index = (m_index + 1) & m_modMask; + x = m_hemiUniform[m_index].cosHemiX; + y = m_hemiUniform[m_index].cosHemiY; + z = m_hemiUniform[m_index].cosHemiZ; +} + +void PrecomputedRandom::cosPowHemi(const float k, float& x, float& y, float& z) { + // Computing a cosPowHemi costs 4 slow functions (pow, sqrt, sin, + // cos). We can do it with two, given a cosHemi sample, basically + // saving the cost of sin and cos and making a single 128-byte + // memory read (for a vector) instead of two (for adjacent uniform + // floats). + + // cos^1 distribution sample + float cos1; + cosHemi(x, y, cos1); + + // Fix the distribution by adjusting the cosine: + // rnd(cos^k t) = (rnd(cos(t))^2)^(1/k) + + // produces cos^k distribution sample + z = pow(cos1, 2.0f / (1.0f + k)); + + // Rescale x and y by sqrt(1.0f - square(z)) / sqrt(x*x + y*y). + // Add a very tiny offset to handle the (almost impossibly unlikely) case where + // z = 1 and x^2+y^2 = 0. + static const float eps = 0.000001f; + const float s = sqrt((1.0f + eps - square(z)) / (square(x) + square(y) + eps)); + + x *= s; + y *= s; +} + + +uint32 PrecomputedRandom::bits() { + m_index = (m_index + 1) & m_modMask; + return m_sphereBits[m_index].bits; +} + + +void PrecomputedRandom::sphere(float& x, float& y, float& z) { + m_index = (m_index + 1) & m_modMask; + x = m_sphereBits[m_index].sphereX; + y = m_sphereBits[m_index].sphereY; + z = m_sphereBits[m_index].sphereZ; +} + +} diff --git a/dep/src/g3dlite/Quat.cpp b/dep/src/g3dlite/Quat.cpp new file mode 100644 index 00000000000..225c5b51acc --- /dev/null +++ b/dep/src/g3dlite/Quat.cpp @@ -0,0 +1,583 @@ +/** + @file Quat.cpp + + Quaternion implementation based on Watt & Watt page 363 + + @author Morgan McGuire, graphics3d.com + + @created 2002-01-23 + @edited 2006-01-31 + */ + +#include "G3D/Quat.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +Quat Quat::fromAxisAngleRotation( + const Vector3& axis, + float angle) { + + Quat q; + + q.w = cos(angle / 2.0f); + q.imag() = axis.direction() * sin(angle / 2.0f); + + return q; +} + + +Quat::Quat( + const Matrix3& rot) { + + static const int plus1mod3[] = {1, 2, 0}; + + // Find the index of the largest diagonal component + // These ? operations hopefully compile to conditional + // move instructions instead of branches. + int i = (rot[1][1] > rot[0][0]) ? 1 : 0; + i = (rot[2][2] > rot[i][i]) ? 2 : i; + + // Find the indices of the other elements + int j = plus1mod3[i]; + int k = plus1mod3[j]; + + // Index the elements of the vector part of the quaternion as a float* + float* v = (float*)(this); + + // If we attempted to pre-normalize and trusted the matrix to be + // perfectly orthonormal, the result would be: + // + // double c = sqrt((rot[i][i] - (rot[j][j] + rot[k][k])) + 1.0) + // v[i] = -c * 0.5 + // v[j] = -(rot[i][j] + rot[j][i]) * 0.5 / c + // v[k] = -(rot[i][k] + rot[k][i]) * 0.5 / c + // w = (rot[j][k] - rot[k][j]) * 0.5 / c + // + // Since we're going to pay the sqrt anyway, we perform a post normalization, which also + // fixes any poorly normalized input. Multiply all elements by 2*c in the above, giving: + + // nc2 = -c^2 + double nc2 = ((rot[j][j] + rot[k][k]) - rot[i][i]) - 1.0; + v[i] = nc2; + w = (rot[j][k] - rot[k][j]); + v[j] = -(rot[i][j] + rot[j][i]); + v[k] = -(rot[i][k] + rot[k][i]); + + // We now have the correct result with the wrong magnitude, so normalize it: + float s = sqrt(x*x + y*y + z*z + w*w); + if (s > 0.00001f) { + s = 1.0f / s; + x *= s; + y *= s; + z *= s; + w *= s; + } else { + // The quaternion is nearly zero. Make it 0 0 0 1 + x = 0.0f; + y = 0.0f; + z = 0.0f; + w = 1.0f; + } +} + + +void Quat::toAxisAngleRotation( + Vector3& axis, + double& angle) const { + + // Decompose the quaternion into an angle and an axis. + + axis = Vector3(x, y, z); + angle = 2 * acos(w); + + float len = sqrt(1.0f - w * w); + + if (fuzzyGt(abs(len), 0.0f)) { + axis /= len; + } + + // Reduce the range of the angle. + + if (angle < 0) { + angle = -angle; + axis = -axis; + } + + while (angle > twoPi()) { + angle -= twoPi(); + } + + if (abs(angle) > pi()) { + angle -= twoPi(); + } + + // Make the angle positive. + + if (angle < 0.0f) { + angle = -angle; + axis = -axis; + } +} + + +Matrix3 Quat::toRotationMatrix() const { + Matrix3 out = Matrix3::zero(); + + toRotationMatrix(out); + + return out; +} + + +void Quat::toRotationMatrix( + Matrix3& rot) const { + + rot = Matrix3(*this); +} + + +Quat Quat::slerp( + const Quat& _quat1, + float alpha, + float threshold) const { + + // From: Game Physics -- David Eberly pg 538-540 + // Modified to include lerp for small angles, which + // is a common practice. + + // See also: + // http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/index.html + + const Quat& quat0 = *this; + Quat quat1 = _quat1; + + // angle between quaternion rotations + float phi; + float cosphi = quat0.dot(quat1); + + + if (cosphi < 0) { + // Change the sign and fix the dot product; we need to + // loop the other way to get the shortest path + quat1 = -quat1; + cosphi = -cosphi; + } + + // Using G3D::aCos will clamp the angle to 0 and pi + phi = static_cast<float>(G3D::aCos(cosphi)); + + if (phi >= threshold) { + // For large angles, slerp + float scale0, scale1; + + scale0 = sin((1.0f - alpha) * phi); + scale1 = sin(alpha * phi); + + return ( (quat0 * scale0) + (quat1 * scale1) ) / sin(phi); + } else { + // For small angles, linear interpolate + return quat0.nlerp(quat1, alpha); + } +} + + +Quat Quat::nlerp( + const Quat& quat1, + float alpha) const { + + Quat result = (*this) * (1.0f - alpha) + quat1 * alpha; + return result / result.magnitude(); +} + + +Quat Quat::operator*(const Quat& other) const { + + // Following Watt & Watt, page 360 + const Vector3& v1 = imag(); + const Vector3& v2 = other.imag(); + float s1 = w; + float s2 = other.w; + + return Quat(s1*v2 + s2*v1 + v1.cross(v2), s1*s2 - v1.dot(v2)); +} + + +// From "Uniform Random Rotations", Ken Shoemake, Graphics Gems III. +Quat Quat::unitRandom() { + float x0 = uniformRandom(); + float r1 = sqrtf(1 - x0), + r2 = sqrtf(x0); + float t1 = (float)G3D::twoPi() * uniformRandom(); + float t2 = (float)G3D::twoPi() * uniformRandom(); + float c1 = cosf(t1), + s1 = sinf(t1); + float c2 = cosf(t2), + s2 = sinf(t2); + return Quat(s1 * r1, c1 * r1, s2 * r2, c2 * r2); +} + + +void Quat::deserialize(class BinaryInput& b) { + x = b.readFloat32(); + y = b.readFloat32(); + z = b.readFloat32(); + w = b.readFloat32(); +} + + +void Quat::serialize(class BinaryOutput& b) const { + b.writeFloat32(x); + b.writeFloat32(y); + b.writeFloat32(z); + b.writeFloat32(w); +} + + +// 2-char swizzles + +Vector2 Quat::xx() const { return Vector2 (x, x); } +Vector2 Quat::yx() const { return Vector2 (y, x); } +Vector2 Quat::zx() const { return Vector2 (z, x); } +Vector2 Quat::wx() const { return Vector2 (w, x); } +Vector2 Quat::xy() const { return Vector2 (x, y); } +Vector2 Quat::yy() const { return Vector2 (y, y); } +Vector2 Quat::zy() const { return Vector2 (z, y); } +Vector2 Quat::wy() const { return Vector2 (w, y); } +Vector2 Quat::xz() const { return Vector2 (x, z); } +Vector2 Quat::yz() const { return Vector2 (y, z); } +Vector2 Quat::zz() const { return Vector2 (z, z); } +Vector2 Quat::wz() const { return Vector2 (w, z); } +Vector2 Quat::xw() const { return Vector2 (x, w); } +Vector2 Quat::yw() const { return Vector2 (y, w); } +Vector2 Quat::zw() const { return Vector2 (z, w); } +Vector2 Quat::ww() const { return Vector2 (w, w); } + +// 3-char swizzles + +Vector3 Quat::xxx() const { return Vector3 (x, x, x); } +Vector3 Quat::yxx() const { return Vector3 (y, x, x); } +Vector3 Quat::zxx() const { return Vector3 (z, x, x); } +Vector3 Quat::wxx() const { return Vector3 (w, x, x); } +Vector3 Quat::xyx() const { return Vector3 (x, y, x); } +Vector3 Quat::yyx() const { return Vector3 (y, y, x); } +Vector3 Quat::zyx() const { return Vector3 (z, y, x); } +Vector3 Quat::wyx() const { return Vector3 (w, y, x); } +Vector3 Quat::xzx() const { return Vector3 (x, z, x); } +Vector3 Quat::yzx() const { return Vector3 (y, z, x); } +Vector3 Quat::zzx() const { return Vector3 (z, z, x); } +Vector3 Quat::wzx() const { return Vector3 (w, z, x); } +Vector3 Quat::xwx() const { return Vector3 (x, w, x); } +Vector3 Quat::ywx() const { return Vector3 (y, w, x); } +Vector3 Quat::zwx() const { return Vector3 (z, w, x); } +Vector3 Quat::wwx() const { return Vector3 (w, w, x); } +Vector3 Quat::xxy() const { return Vector3 (x, x, y); } +Vector3 Quat::yxy() const { return Vector3 (y, x, y); } +Vector3 Quat::zxy() const { return Vector3 (z, x, y); } +Vector3 Quat::wxy() const { return Vector3 (w, x, y); } +Vector3 Quat::xyy() const { return Vector3 (x, y, y); } +Vector3 Quat::yyy() const { return Vector3 (y, y, y); } +Vector3 Quat::zyy() const { return Vector3 (z, y, y); } +Vector3 Quat::wyy() const { return Vector3 (w, y, y); } +Vector3 Quat::xzy() const { return Vector3 (x, z, y); } +Vector3 Quat::yzy() const { return Vector3 (y, z, y); } +Vector3 Quat::zzy() const { return Vector3 (z, z, y); } +Vector3 Quat::wzy() const { return Vector3 (w, z, y); } +Vector3 Quat::xwy() const { return Vector3 (x, w, y); } +Vector3 Quat::ywy() const { return Vector3 (y, w, y); } +Vector3 Quat::zwy() const { return Vector3 (z, w, y); } +Vector3 Quat::wwy() const { return Vector3 (w, w, y); } +Vector3 Quat::xxz() const { return Vector3 (x, x, z); } +Vector3 Quat::yxz() const { return Vector3 (y, x, z); } +Vector3 Quat::zxz() const { return Vector3 (z, x, z); } +Vector3 Quat::wxz() const { return Vector3 (w, x, z); } +Vector3 Quat::xyz() const { return Vector3 (x, y, z); } +Vector3 Quat::yyz() const { return Vector3 (y, y, z); } +Vector3 Quat::zyz() const { return Vector3 (z, y, z); } +Vector3 Quat::wyz() const { return Vector3 (w, y, z); } +Vector3 Quat::xzz() const { return Vector3 (x, z, z); } +Vector3 Quat::yzz() const { return Vector3 (y, z, z); } +Vector3 Quat::zzz() const { return Vector3 (z, z, z); } +Vector3 Quat::wzz() const { return Vector3 (w, z, z); } +Vector3 Quat::xwz() const { return Vector3 (x, w, z); } +Vector3 Quat::ywz() const { return Vector3 (y, w, z); } +Vector3 Quat::zwz() const { return Vector3 (z, w, z); } +Vector3 Quat::wwz() const { return Vector3 (w, w, z); } +Vector3 Quat::xxw() const { return Vector3 (x, x, w); } +Vector3 Quat::yxw() const { return Vector3 (y, x, w); } +Vector3 Quat::zxw() const { return Vector3 (z, x, w); } +Vector3 Quat::wxw() const { return Vector3 (w, x, w); } +Vector3 Quat::xyw() const { return Vector3 (x, y, w); } +Vector3 Quat::yyw() const { return Vector3 (y, y, w); } +Vector3 Quat::zyw() const { return Vector3 (z, y, w); } +Vector3 Quat::wyw() const { return Vector3 (w, y, w); } +Vector3 Quat::xzw() const { return Vector3 (x, z, w); } +Vector3 Quat::yzw() const { return Vector3 (y, z, w); } +Vector3 Quat::zzw() const { return Vector3 (z, z, w); } +Vector3 Quat::wzw() const { return Vector3 (w, z, w); } +Vector3 Quat::xww() const { return Vector3 (x, w, w); } +Vector3 Quat::yww() const { return Vector3 (y, w, w); } +Vector3 Quat::zww() const { return Vector3 (z, w, w); } +Vector3 Quat::www() const { return Vector3 (w, w, w); } + +// 4-char swizzles + +Vector4 Quat::xxxx() const { return Vector4 (x, x, x, x); } +Vector4 Quat::yxxx() const { return Vector4 (y, x, x, x); } +Vector4 Quat::zxxx() const { return Vector4 (z, x, x, x); } +Vector4 Quat::wxxx() const { return Vector4 (w, x, x, x); } +Vector4 Quat::xyxx() const { return Vector4 (x, y, x, x); } +Vector4 Quat::yyxx() const { return Vector4 (y, y, x, x); } +Vector4 Quat::zyxx() const { return Vector4 (z, y, x, x); } +Vector4 Quat::wyxx() const { return Vector4 (w, y, x, x); } +Vector4 Quat::xzxx() const { return Vector4 (x, z, x, x); } +Vector4 Quat::yzxx() const { return Vector4 (y, z, x, x); } +Vector4 Quat::zzxx() const { return Vector4 (z, z, x, x); } +Vector4 Quat::wzxx() const { return Vector4 (w, z, x, x); } +Vector4 Quat::xwxx() const { return Vector4 (x, w, x, x); } +Vector4 Quat::ywxx() const { return Vector4 (y, w, x, x); } +Vector4 Quat::zwxx() const { return Vector4 (z, w, x, x); } +Vector4 Quat::wwxx() const { return Vector4 (w, w, x, x); } +Vector4 Quat::xxyx() const { return Vector4 (x, x, y, x); } +Vector4 Quat::yxyx() const { return Vector4 (y, x, y, x); } +Vector4 Quat::zxyx() const { return Vector4 (z, x, y, x); } +Vector4 Quat::wxyx() const { return Vector4 (w, x, y, x); } +Vector4 Quat::xyyx() const { return Vector4 (x, y, y, x); } +Vector4 Quat::yyyx() const { return Vector4 (y, y, y, x); } +Vector4 Quat::zyyx() const { return Vector4 (z, y, y, x); } +Vector4 Quat::wyyx() const { return Vector4 (w, y, y, x); } +Vector4 Quat::xzyx() const { return Vector4 (x, z, y, x); } +Vector4 Quat::yzyx() const { return Vector4 (y, z, y, x); } +Vector4 Quat::zzyx() const { return Vector4 (z, z, y, x); } +Vector4 Quat::wzyx() const { return Vector4 (w, z, y, x); } +Vector4 Quat::xwyx() const { return Vector4 (x, w, y, x); } +Vector4 Quat::ywyx() const { return Vector4 (y, w, y, x); } +Vector4 Quat::zwyx() const { return Vector4 (z, w, y, x); } +Vector4 Quat::wwyx() const { return Vector4 (w, w, y, x); } +Vector4 Quat::xxzx() const { return Vector4 (x, x, z, x); } +Vector4 Quat::yxzx() const { return Vector4 (y, x, z, x); } +Vector4 Quat::zxzx() const { return Vector4 (z, x, z, x); } +Vector4 Quat::wxzx() const { return Vector4 (w, x, z, x); } +Vector4 Quat::xyzx() const { return Vector4 (x, y, z, x); } +Vector4 Quat::yyzx() const { return Vector4 (y, y, z, x); } +Vector4 Quat::zyzx() const { return Vector4 (z, y, z, x); } +Vector4 Quat::wyzx() const { return Vector4 (w, y, z, x); } +Vector4 Quat::xzzx() const { return Vector4 (x, z, z, x); } +Vector4 Quat::yzzx() const { return Vector4 (y, z, z, x); } +Vector4 Quat::zzzx() const { return Vector4 (z, z, z, x); } +Vector4 Quat::wzzx() const { return Vector4 (w, z, z, x); } +Vector4 Quat::xwzx() const { return Vector4 (x, w, z, x); } +Vector4 Quat::ywzx() const { return Vector4 (y, w, z, x); } +Vector4 Quat::zwzx() const { return Vector4 (z, w, z, x); } +Vector4 Quat::wwzx() const { return Vector4 (w, w, z, x); } +Vector4 Quat::xxwx() const { return Vector4 (x, x, w, x); } +Vector4 Quat::yxwx() const { return Vector4 (y, x, w, x); } +Vector4 Quat::zxwx() const { return Vector4 (z, x, w, x); } +Vector4 Quat::wxwx() const { return Vector4 (w, x, w, x); } +Vector4 Quat::xywx() const { return Vector4 (x, y, w, x); } +Vector4 Quat::yywx() const { return Vector4 (y, y, w, x); } +Vector4 Quat::zywx() const { return Vector4 (z, y, w, x); } +Vector4 Quat::wywx() const { return Vector4 (w, y, w, x); } +Vector4 Quat::xzwx() const { return Vector4 (x, z, w, x); } +Vector4 Quat::yzwx() const { return Vector4 (y, z, w, x); } +Vector4 Quat::zzwx() const { return Vector4 (z, z, w, x); } +Vector4 Quat::wzwx() const { return Vector4 (w, z, w, x); } +Vector4 Quat::xwwx() const { return Vector4 (x, w, w, x); } +Vector4 Quat::ywwx() const { return Vector4 (y, w, w, x); } +Vector4 Quat::zwwx() const { return Vector4 (z, w, w, x); } +Vector4 Quat::wwwx() const { return Vector4 (w, w, w, x); } +Vector4 Quat::xxxy() const { return Vector4 (x, x, x, y); } +Vector4 Quat::yxxy() const { return Vector4 (y, x, x, y); } +Vector4 Quat::zxxy() const { return Vector4 (z, x, x, y); } +Vector4 Quat::wxxy() const { return Vector4 (w, x, x, y); } +Vector4 Quat::xyxy() const { return Vector4 (x, y, x, y); } +Vector4 Quat::yyxy() const { return Vector4 (y, y, x, y); } +Vector4 Quat::zyxy() const { return Vector4 (z, y, x, y); } +Vector4 Quat::wyxy() const { return Vector4 (w, y, x, y); } +Vector4 Quat::xzxy() const { return Vector4 (x, z, x, y); } +Vector4 Quat::yzxy() const { return Vector4 (y, z, x, y); } +Vector4 Quat::zzxy() const { return Vector4 (z, z, x, y); } +Vector4 Quat::wzxy() const { return Vector4 (w, z, x, y); } +Vector4 Quat::xwxy() const { return Vector4 (x, w, x, y); } +Vector4 Quat::ywxy() const { return Vector4 (y, w, x, y); } +Vector4 Quat::zwxy() const { return Vector4 (z, w, x, y); } +Vector4 Quat::wwxy() const { return Vector4 (w, w, x, y); } +Vector4 Quat::xxyy() const { return Vector4 (x, x, y, y); } +Vector4 Quat::yxyy() const { return Vector4 (y, x, y, y); } +Vector4 Quat::zxyy() const { return Vector4 (z, x, y, y); } +Vector4 Quat::wxyy() const { return Vector4 (w, x, y, y); } +Vector4 Quat::xyyy() const { return Vector4 (x, y, y, y); } +Vector4 Quat::yyyy() const { return Vector4 (y, y, y, y); } +Vector4 Quat::zyyy() const { return Vector4 (z, y, y, y); } +Vector4 Quat::wyyy() const { return Vector4 (w, y, y, y); } +Vector4 Quat::xzyy() const { return Vector4 (x, z, y, y); } +Vector4 Quat::yzyy() const { return Vector4 (y, z, y, y); } +Vector4 Quat::zzyy() const { return Vector4 (z, z, y, y); } +Vector4 Quat::wzyy() const { return Vector4 (w, z, y, y); } +Vector4 Quat::xwyy() const { return Vector4 (x, w, y, y); } +Vector4 Quat::ywyy() const { return Vector4 (y, w, y, y); } +Vector4 Quat::zwyy() const { return Vector4 (z, w, y, y); } +Vector4 Quat::wwyy() const { return Vector4 (w, w, y, y); } +Vector4 Quat::xxzy() const { return Vector4 (x, x, z, y); } +Vector4 Quat::yxzy() const { return Vector4 (y, x, z, y); } +Vector4 Quat::zxzy() const { return Vector4 (z, x, z, y); } +Vector4 Quat::wxzy() const { return Vector4 (w, x, z, y); } +Vector4 Quat::xyzy() const { return Vector4 (x, y, z, y); } +Vector4 Quat::yyzy() const { return Vector4 (y, y, z, y); } +Vector4 Quat::zyzy() const { return Vector4 (z, y, z, y); } +Vector4 Quat::wyzy() const { return Vector4 (w, y, z, y); } +Vector4 Quat::xzzy() const { return Vector4 (x, z, z, y); } +Vector4 Quat::yzzy() const { return Vector4 (y, z, z, y); } +Vector4 Quat::zzzy() const { return Vector4 (z, z, z, y); } +Vector4 Quat::wzzy() const { return Vector4 (w, z, z, y); } +Vector4 Quat::xwzy() const { return Vector4 (x, w, z, y); } +Vector4 Quat::ywzy() const { return Vector4 (y, w, z, y); } +Vector4 Quat::zwzy() const { return Vector4 (z, w, z, y); } +Vector4 Quat::wwzy() const { return Vector4 (w, w, z, y); } +Vector4 Quat::xxwy() const { return Vector4 (x, x, w, y); } +Vector4 Quat::yxwy() const { return Vector4 (y, x, w, y); } +Vector4 Quat::zxwy() const { return Vector4 (z, x, w, y); } +Vector4 Quat::wxwy() const { return Vector4 (w, x, w, y); } +Vector4 Quat::xywy() const { return Vector4 (x, y, w, y); } +Vector4 Quat::yywy() const { return Vector4 (y, y, w, y); } +Vector4 Quat::zywy() const { return Vector4 (z, y, w, y); } +Vector4 Quat::wywy() const { return Vector4 (w, y, w, y); } +Vector4 Quat::xzwy() const { return Vector4 (x, z, w, y); } +Vector4 Quat::yzwy() const { return Vector4 (y, z, w, y); } +Vector4 Quat::zzwy() const { return Vector4 (z, z, w, y); } +Vector4 Quat::wzwy() const { return Vector4 (w, z, w, y); } +Vector4 Quat::xwwy() const { return Vector4 (x, w, w, y); } +Vector4 Quat::ywwy() const { return Vector4 (y, w, w, y); } +Vector4 Quat::zwwy() const { return Vector4 (z, w, w, y); } +Vector4 Quat::wwwy() const { return Vector4 (w, w, w, y); } +Vector4 Quat::xxxz() const { return Vector4 (x, x, x, z); } +Vector4 Quat::yxxz() const { return Vector4 (y, x, x, z); } +Vector4 Quat::zxxz() const { return Vector4 (z, x, x, z); } +Vector4 Quat::wxxz() const { return Vector4 (w, x, x, z); } +Vector4 Quat::xyxz() const { return Vector4 (x, y, x, z); } +Vector4 Quat::yyxz() const { return Vector4 (y, y, x, z); } +Vector4 Quat::zyxz() const { return Vector4 (z, y, x, z); } +Vector4 Quat::wyxz() const { return Vector4 (w, y, x, z); } +Vector4 Quat::xzxz() const { return Vector4 (x, z, x, z); } +Vector4 Quat::yzxz() const { return Vector4 (y, z, x, z); } +Vector4 Quat::zzxz() const { return Vector4 (z, z, x, z); } +Vector4 Quat::wzxz() const { return Vector4 (w, z, x, z); } +Vector4 Quat::xwxz() const { return Vector4 (x, w, x, z); } +Vector4 Quat::ywxz() const { return Vector4 (y, w, x, z); } +Vector4 Quat::zwxz() const { return Vector4 (z, w, x, z); } +Vector4 Quat::wwxz() const { return Vector4 (w, w, x, z); } +Vector4 Quat::xxyz() const { return Vector4 (x, x, y, z); } +Vector4 Quat::yxyz() const { return Vector4 (y, x, y, z); } +Vector4 Quat::zxyz() const { return Vector4 (z, x, y, z); } +Vector4 Quat::wxyz() const { return Vector4 (w, x, y, z); } +Vector4 Quat::xyyz() const { return Vector4 (x, y, y, z); } +Vector4 Quat::yyyz() const { return Vector4 (y, y, y, z); } +Vector4 Quat::zyyz() const { return Vector4 (z, y, y, z); } +Vector4 Quat::wyyz() const { return Vector4 (w, y, y, z); } +Vector4 Quat::xzyz() const { return Vector4 (x, z, y, z); } +Vector4 Quat::yzyz() const { return Vector4 (y, z, y, z); } +Vector4 Quat::zzyz() const { return Vector4 (z, z, y, z); } +Vector4 Quat::wzyz() const { return Vector4 (w, z, y, z); } +Vector4 Quat::xwyz() const { return Vector4 (x, w, y, z); } +Vector4 Quat::ywyz() const { return Vector4 (y, w, y, z); } +Vector4 Quat::zwyz() const { return Vector4 (z, w, y, z); } +Vector4 Quat::wwyz() const { return Vector4 (w, w, y, z); } +Vector4 Quat::xxzz() const { return Vector4 (x, x, z, z); } +Vector4 Quat::yxzz() const { return Vector4 (y, x, z, z); } +Vector4 Quat::zxzz() const { return Vector4 (z, x, z, z); } +Vector4 Quat::wxzz() const { return Vector4 (w, x, z, z); } +Vector4 Quat::xyzz() const { return Vector4 (x, y, z, z); } +Vector4 Quat::yyzz() const { return Vector4 (y, y, z, z); } +Vector4 Quat::zyzz() const { return Vector4 (z, y, z, z); } +Vector4 Quat::wyzz() const { return Vector4 (w, y, z, z); } +Vector4 Quat::xzzz() const { return Vector4 (x, z, z, z); } +Vector4 Quat::yzzz() const { return Vector4 (y, z, z, z); } +Vector4 Quat::zzzz() const { return Vector4 (z, z, z, z); } +Vector4 Quat::wzzz() const { return Vector4 (w, z, z, z); } +Vector4 Quat::xwzz() const { return Vector4 (x, w, z, z); } +Vector4 Quat::ywzz() const { return Vector4 (y, w, z, z); } +Vector4 Quat::zwzz() const { return Vector4 (z, w, z, z); } +Vector4 Quat::wwzz() const { return Vector4 (w, w, z, z); } +Vector4 Quat::xxwz() const { return Vector4 (x, x, w, z); } +Vector4 Quat::yxwz() const { return Vector4 (y, x, w, z); } +Vector4 Quat::zxwz() const { return Vector4 (z, x, w, z); } +Vector4 Quat::wxwz() const { return Vector4 (w, x, w, z); } +Vector4 Quat::xywz() const { return Vector4 (x, y, w, z); } +Vector4 Quat::yywz() const { return Vector4 (y, y, w, z); } +Vector4 Quat::zywz() const { return Vector4 (z, y, w, z); } +Vector4 Quat::wywz() const { return Vector4 (w, y, w, z); } +Vector4 Quat::xzwz() const { return Vector4 (x, z, w, z); } +Vector4 Quat::yzwz() const { return Vector4 (y, z, w, z); } +Vector4 Quat::zzwz() const { return Vector4 (z, z, w, z); } +Vector4 Quat::wzwz() const { return Vector4 (w, z, w, z); } +Vector4 Quat::xwwz() const { return Vector4 (x, w, w, z); } +Vector4 Quat::ywwz() const { return Vector4 (y, w, w, z); } +Vector4 Quat::zwwz() const { return Vector4 (z, w, w, z); } +Vector4 Quat::wwwz() const { return Vector4 (w, w, w, z); } +Vector4 Quat::xxxw() const { return Vector4 (x, x, x, w); } +Vector4 Quat::yxxw() const { return Vector4 (y, x, x, w); } +Vector4 Quat::zxxw() const { return Vector4 (z, x, x, w); } +Vector4 Quat::wxxw() const { return Vector4 (w, x, x, w); } +Vector4 Quat::xyxw() const { return Vector4 (x, y, x, w); } +Vector4 Quat::yyxw() const { return Vector4 (y, y, x, w); } +Vector4 Quat::zyxw() const { return Vector4 (z, y, x, w); } +Vector4 Quat::wyxw() const { return Vector4 (w, y, x, w); } +Vector4 Quat::xzxw() const { return Vector4 (x, z, x, w); } +Vector4 Quat::yzxw() const { return Vector4 (y, z, x, w); } +Vector4 Quat::zzxw() const { return Vector4 (z, z, x, w); } +Vector4 Quat::wzxw() const { return Vector4 (w, z, x, w); } +Vector4 Quat::xwxw() const { return Vector4 (x, w, x, w); } +Vector4 Quat::ywxw() const { return Vector4 (y, w, x, w); } +Vector4 Quat::zwxw() const { return Vector4 (z, w, x, w); } +Vector4 Quat::wwxw() const { return Vector4 (w, w, x, w); } +Vector4 Quat::xxyw() const { return Vector4 (x, x, y, w); } +Vector4 Quat::yxyw() const { return Vector4 (y, x, y, w); } +Vector4 Quat::zxyw() const { return Vector4 (z, x, y, w); } +Vector4 Quat::wxyw() const { return Vector4 (w, x, y, w); } +Vector4 Quat::xyyw() const { return Vector4 (x, y, y, w); } +Vector4 Quat::yyyw() const { return Vector4 (y, y, y, w); } +Vector4 Quat::zyyw() const { return Vector4 (z, y, y, w); } +Vector4 Quat::wyyw() const { return Vector4 (w, y, y, w); } +Vector4 Quat::xzyw() const { return Vector4 (x, z, y, w); } +Vector4 Quat::yzyw() const { return Vector4 (y, z, y, w); } +Vector4 Quat::zzyw() const { return Vector4 (z, z, y, w); } +Vector4 Quat::wzyw() const { return Vector4 (w, z, y, w); } +Vector4 Quat::xwyw() const { return Vector4 (x, w, y, w); } +Vector4 Quat::ywyw() const { return Vector4 (y, w, y, w); } +Vector4 Quat::zwyw() const { return Vector4 (z, w, y, w); } +Vector4 Quat::wwyw() const { return Vector4 (w, w, y, w); } +Vector4 Quat::xxzw() const { return Vector4 (x, x, z, w); } +Vector4 Quat::yxzw() const { return Vector4 (y, x, z, w); } +Vector4 Quat::zxzw() const { return Vector4 (z, x, z, w); } +Vector4 Quat::wxzw() const { return Vector4 (w, x, z, w); } +Vector4 Quat::xyzw() const { return Vector4 (x, y, z, w); } +Vector4 Quat::yyzw() const { return Vector4 (y, y, z, w); } +Vector4 Quat::zyzw() const { return Vector4 (z, y, z, w); } +Vector4 Quat::wyzw() const { return Vector4 (w, y, z, w); } +Vector4 Quat::xzzw() const { return Vector4 (x, z, z, w); } +Vector4 Quat::yzzw() const { return Vector4 (y, z, z, w); } +Vector4 Quat::zzzw() const { return Vector4 (z, z, z, w); } +Vector4 Quat::wzzw() const { return Vector4 (w, z, z, w); } +Vector4 Quat::xwzw() const { return Vector4 (x, w, z, w); } +Vector4 Quat::ywzw() const { return Vector4 (y, w, z, w); } +Vector4 Quat::zwzw() const { return Vector4 (z, w, z, w); } +Vector4 Quat::wwzw() const { return Vector4 (w, w, z, w); } +Vector4 Quat::xxww() const { return Vector4 (x, x, w, w); } +Vector4 Quat::yxww() const { return Vector4 (y, x, w, w); } +Vector4 Quat::zxww() const { return Vector4 (z, x, w, w); } +Vector4 Quat::wxww() const { return Vector4 (w, x, w, w); } +Vector4 Quat::xyww() const { return Vector4 (x, y, w, w); } +Vector4 Quat::yyww() const { return Vector4 (y, y, w, w); } +Vector4 Quat::zyww() const { return Vector4 (z, y, w, w); } +Vector4 Quat::wyww() const { return Vector4 (w, y, w, w); } +Vector4 Quat::xzww() const { return Vector4 (x, z, w, w); } +Vector4 Quat::yzww() const { return Vector4 (y, z, w, w); } +Vector4 Quat::zzww() const { return Vector4 (z, z, w, w); } +Vector4 Quat::wzww() const { return Vector4 (w, z, w, w); } +Vector4 Quat::xwww() const { return Vector4 (x, w, w, w); } +Vector4 Quat::ywww() const { return Vector4 (y, w, w, w); } +Vector4 Quat::zwww() const { return Vector4 (z, w, w, w); } +Vector4 Quat::wwww() const { return Vector4 (w, w, w, w); } +} + diff --git a/dep/src/g3dlite/Random.cpp b/dep/src/g3dlite/Random.cpp new file mode 100644 index 00000000000..2dda744a1ac --- /dev/null +++ b/dep/src/g3dlite/Random.cpp @@ -0,0 +1,212 @@ +/** + @file Random.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2009-01-02 + @edited 2009-03-29 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ +#include "G3D/Random.h" + +namespace G3D { + +Random& Random::common() { + static Random r; + return r; +} + +Random::Random(void* x) : state(NULL), m_threadsafe(false) { + (void)x; +} + + +Random::Random(uint32 seed, bool threadsafe) : m_threadsafe(threadsafe) { + const uint32 X = 1812433253UL; + + state = new uint32[N]; + state[0] = seed; + for (index = 1; index < (int)N; ++index) { + state[index] = X * (state[index - 1] ^ (state[index - 1] >> 30)) + index; + } +} + + +Random::~Random() { + delete[] state; + state = NULL; +} + + +uint32 Random::bits() { + // See http://en.wikipedia.org/wiki/Mersenne_twister + + // Make a local copy of the index variable to ensure that it + // is not out of bounds + int localIndex = index; + + // Automatically checks for index < 0 if corrupted + // by unsynchronized threads. + if ((unsigned int)localIndex >= (unsigned int)N) { + generate(); + localIndex = 0; + } + // Increment the global index. It may go out of bounds on + // multiple threads, but the above check ensures that the + // array index actually used never goes out of bounds. + // It doesn't matter if we grab the same array index twice + // on two threads, since the distribution of random numbers + // will still be uniform. + ++index; + // Return the next random in the sequence + uint32 r = state[localIndex]; + + // Temper the result + r ^= r >> U; + r ^= (r << S) & B; + r ^= (r << T) & C; + r ^= r >> L; + + return r; +} + + +/** Generate the next N ints, and store them for readback later */ +void Random::generate() { + // Lower R bits + static const uint32 LOWER_MASK = (1LU << R) - 1; + + // Upper (32 - R) bits + static const uint32 UPPER_MASK = 0xFFFFFFFF << R; + static const uint32 mag01[2] = {0UL, (uint32)A}; + + if (m_threadsafe) { + bool contention = ! lock.lock(); + if (contention) { + // Another thread just generated a set of numbers; no need for + // this thread to do it too + lock.unlock(); + return; + } + } + + // First N - M + for (unsigned int i = 0; i < N - M; ++i) { + uint32 x = (state[i] & UPPER_MASK) | (state[i + 1] & LOWER_MASK); + state[i] = state[i + M] ^ (x >> 1) ^ mag01[x & 1]; + } + + // Rest + for (unsigned int i = N - M + 1; i < N - 1; ++i) { + uint32 x = (state[i] & UPPER_MASK) | (state[i + 1] & LOWER_MASK); + state[i] = state[i + (M - N)] ^ (x >> 1) ^ mag01[x & 1]; + } + + uint32 y = (state[N - 1] & UPPER_MASK) | (state[0] & LOWER_MASK); + state[N - 1] = state[M - 1] ^ (y >> 1) ^ mag01[y & 1]; + index = 0; + + if (m_threadsafe) { + lock.unlock(); + } +} + + +int Random::integer(int low, int high) { + int r = iFloor(low + (high - low + 1) * (double)bits() / 0xFFFFFFFFUL); + + // There is a *very small* chance of generating + // a number larger than high. + if (r > high) { + return high; + } else { + return r; + } +} + + +float Random::gaussian(float mean, float stdev) { + + // Using Box-Mueller method from http://www.taygeta.com/random/gaussian.html + // Modified to specify standard deviation and mean of distribution + float w, x1, x2; + + // Loop until w is less than 1 so that log(w) is negative + do { + x1 = uniform(-1.0, 1.0); + x2 = uniform(-1.0, 1.0); + + w = float(square(x1) + square(x2)); + } while (w > 1.0f); + + // Transform to gassian distribution + // Multiply by sigma (stdev ^ 2) and add mean. + return x2 * (float)square(stdev) * sqrtf((-2.0f * logf(w) ) / w) + mean; +} + + +void Random::cosHemi(float& x, float& y, float& z) { + const float e1 = uniform(); + const float e2 = uniform(); + + // Jensen's method + const float sin_theta = sqrtf(1.0f - e1); + const float cos_theta = sqrtf(e1); + const float phi = 6.28318531f * e2; + + x = cos(phi) * sin_theta; + y = sin(phi) * sin_theta; + z = cos_theta; + + // We could also use Malley's method (pbrt p.657), since they are the same cost: + // + // r = sqrt(e1); + // t = 2*pi*e2; + // x = cos(t)*r; + // y = sin(t)*r; + // z = sqrt(1.0 - x*x + y*y); +} + + +void Random::cosPowHemi(const float k, float& x, float& y, float& z) { + const float e1 = uniform(); + const float e2 = uniform(); + + const float cos_theta = pow(e1, 1.0f / (k + 1.0f)); + const float sin_theta = sqrtf(1.0f - square(cos_theta)); + const float phi = 6.28318531f * e2; + + x = cos(phi) * sin_theta; + y = sin(phi) * sin_theta; + z = cos_theta; +} + + +void Random::hemi(float& x, float& y, float& z) { + sphere(x, y, z); + z = fabsf(z); +} + + +void Random::sphere(float& x, float& y, float& z) { + // Squared magnitude + float m2; + + // Rejection sample + do { + x = uniform() * 2.0f - 1.0f, + y = uniform() * 2.0f - 1.0f, + z = uniform() * 2.0f - 1.0f; + m2 = x*x + y*y + z*z; + } while (m2 >= 1.0f); + + // Divide by magnitude to produce a unit vector + float s = rsqrt(m2); + x *= s; + y *= s; + z *= s; +} + +} // G3D diff --git a/dep/src/g3dlite/Ray.cpp b/dep/src/g3dlite/Ray.cpp new file mode 100644 index 00000000000..0436ef0b323 --- /dev/null +++ b/dep/src/g3dlite/Ray.cpp @@ -0,0 +1,218 @@ +/** + @file Ray.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2002-07-12 + @edited 2004-03-19 + */ + +#include "G3D/platform.h" +#include "G3D/Ray.h" +#include "G3D/Plane.h" +#include "G3D/Sphere.h" +#include "G3D/CollisionDetection.h" + +namespace G3D { + +void Ray::set(const Vector3& origin, const Vector3& direction) { + m_origin = origin; + m_direction = direction; + debugAssert(direction.isUnit()); + + m_invDirection = Vector3::one() / direction; + + // ray slope + ibyj = m_direction.x * m_invDirection.y; + jbyi = m_direction.y * m_invDirection.x; + jbyk = m_direction.y * m_invDirection.z; + kbyj = m_direction.z * m_invDirection.y; + ibyk = m_direction.x * m_invDirection.z; + kbyi = m_direction.z * m_invDirection.x; + + // precomputed terms + c_xy = m_origin.y - jbyi * m_origin.x; + c_xz = m_origin.z - kbyi * m_origin.x; + c_yx = m_origin.x - ibyj * m_origin.y; + c_yz = m_origin.z - kbyj * m_origin.y; + c_zx = m_origin.x - ibyk * m_origin.z; + c_zy = m_origin.y - jbyk * m_origin.z; + + //ray slope classification + if (m_direction.x < 0) { + if (m_direction.y < 0) { + if (m_direction.z < 0) { + classification = MMM; + } else if (m_direction.z > 0) { + classification = MMP; + } else { //(m_direction.z >= 0) + classification = MMO; + } + } else { //(m_direction.y >= 0) + if (m_direction.z < 0) { + if (m_direction.y == 0) { + classification = MOM; + } else { + classification = MPM; + } + } else { //(m_direction.z >= 0) + if ((m_direction.y == 0) && (m_direction.z == 0)) { + classification = MOO; + } else if (m_direction.z == 0) { + classification = MPO; + } else if (m_direction.y == 0) { + classification = MOP; + } else { + classification = MPP; + } + } + } + } else { //(m_direction.x >= 0) + if (m_direction.y < 0) { + if (m_direction.z < 0) { + if (m_direction.x == 0) { + classification = OMM; + } else { + classification = PMM; + } + } else { //(m_direction.z >= 0) + if ((m_direction.x == 0) && (m_direction.z == 0)) { + classification = OMO; + } else if (m_direction.z == 0) { + classification = PMO; + } else if (m_direction.x == 0) { + classification = OMP; + } else { + classification = PMP; + } + } + } else { //(m_direction.y >= 0) + if (m_direction.z < 0) { + if ((m_direction.x == 0) && (m_direction.y == 0)) { + classification = OOM; + } else if (m_direction.x == 0) { + classification = OPM; + } else if (m_direction.y == 0) { + classification = POM; + } else { + classification = PPM; + } + } else { //(m_direction.z > 0) + if (m_direction.x == 0) { + if (m_direction.y == 0) { + classification = OOP; + } else if (m_direction.z == 0) { + classification = OPO; + } else { + classification = OPP; + } + } else { + if ((m_direction.y == 0) && (m_direction.z == 0)) { + classification = POO; + } else if (m_direction.y == 0) { + classification = POP; + } else if (m_direction.z == 0) { + classification = PPO; + } else { + classification = PPP; + } + } + } + } + } +} + +Ray::Ray(class BinaryInput& b) { + deserialize(b); +} + + +void Ray::serialize(class BinaryOutput& b) const { + m_origin.serialize(b); + m_direction.serialize(b); +} + + +void Ray::deserialize(class BinaryInput& b) { + m_origin.deserialize(b); + m_direction.deserialize(b); + set(m_origin, m_direction); +} + + +Ray Ray::refract( + const Vector3& newOrigin, + const Vector3& normal, + float iInside, + float iOutside) const { + + Vector3 D = m_direction.refractionDirection(normal, iInside, iOutside); + return Ray(newOrigin + (m_direction + normal * (float)sign(m_direction.dot(normal))) * 0.001f, D); +} + + +Ray Ray::reflect( + const Vector3& newOrigin, + const Vector3& normal) const { + + Vector3 D = m_direction.reflectionDirection(normal); + return Ray(newOrigin + (D + normal) * 0.001f, D); +} + + +Vector3 Ray::intersection(const Plane& plane) const { + float d; + Vector3 normal = plane.normal(); + plane.getEquation(normal, d); + float rate = m_direction.dot(normal); + + if (rate >= 0.0f) { + return Vector3::inf(); + } else { + float t = -(d + m_origin.dot(normal)) / rate; + return m_origin + m_direction * t; + } +} + + +float Ray::intersectionTime(const class Sphere& sphere, bool solid) const { + Vector3 dummy; + return CollisionDetection::collisionTimeForMovingPointFixedSphere( + m_origin, m_direction, sphere, dummy, dummy, solid); +} + + +float Ray::intersectionTime(const class Plane& plane) const { + Vector3 dummy; + return CollisionDetection::collisionTimeForMovingPointFixedPlane( + m_origin, m_direction, plane, dummy); +} + + +float Ray::intersectionTime(const class Box& box) const { + Vector3 dummy; + float time = CollisionDetection::collisionTimeForMovingPointFixedBox( + m_origin, m_direction, box, dummy); + + if ((time == finf()) && (box.contains(m_origin))) { + return 0.0f; + } else { + return time; + } +} + + +float Ray::intersectionTime(const class AABox& box) const { + Vector3 dummy; + bool inside; + float time = CollisionDetection::collisionTimeForMovingPointFixedAABox( + m_origin, m_direction, box, dummy, inside); + + if ((time == finf()) && inside) { + return 0.0f; + } else { + return time; + } +} + +} diff --git a/dep/src/g3dlite/Rect2D.cpp b/dep/src/g3dlite/Rect2D.cpp new file mode 100644 index 00000000000..e4148315a58 --- /dev/null +++ b/dep/src/g3dlite/Rect2D.cpp @@ -0,0 +1,41 @@ +/** + @file Rect2D.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-11-13 + @created 2009-11-16 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/platform.h" +#include "G3D/Rect2D.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +/** \param any Must either Rect2D::xywh(#, #, #, #) or Rect2D::xyxy(#, #, #, #)*/ +Rect2D::Rect2D(const Any& any) { + any.verifyName("Rect2D"); + any.verifyType(Any::ARRAY); + any.verifySize(4); + if (toUpper(any.name()) == "RECT2D::XYWH") { + *this = Rect2D::xywh(any[0], any[1], any[2], any[3]); + } else { + any.verifyName("Rect2D::xyxy"); + *this = Rect2D::xyxy(any[0], any[1], any[2], any[3]); + } +} + + +/** Converts the Rect2D to an Any. */ +Rect2D::operator Any() const { + Any any(Any::ARRAY, "Rect2D::xywh"); + any.append(x0(), y0(), width(), height()); + return any; +} + +} diff --git a/dep/src/g3dlite/ReferenceCount.cpp b/dep/src/g3dlite/ReferenceCount.cpp new file mode 100644 index 00000000000..2e1f117e0d9 --- /dev/null +++ b/dep/src/g3dlite/ReferenceCount.cpp @@ -0,0 +1,61 @@ +/** + @file ReferenceCount.cpp + + Reference Counting Garbage Collector for C++ + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @cite Adapted and extended from Justin Miller's "RGC" class that appeared in BYTE magazine. + @cite See also http://www.jelovic.com/articles/cpp_without_memory_errors_slides.htm + + @created 2001-10-23 + @edited 2009-04-25 +*/ +#include "G3D/platform.h" +#include "G3D/ReferenceCount.h" + +namespace G3D { + +ReferenceCountedObject::ReferenceCountedObject() : + ReferenceCountedObject_refCount(0), + ReferenceCountedObject_weakPointer(0) { + + debugAssertM(isValidHeapPointer(this), + "Reference counted objects must be allocated on the heap."); +} + +void ReferenceCountedObject::ReferenceCountedObject_zeroWeakPointers() { + // Tell all of my weak pointers that I'm gone. + + _WeakPtrLinkedList* node = ReferenceCountedObject_weakPointer; + + while (node != NULL) { + // Notify the weak pointer that it is going away + node->weakPtr->objectCollected(); + + // Free the node and advance + _WeakPtrLinkedList* tmp = node; + node = node->next; + delete tmp; + } +} + +ReferenceCountedObject::~ReferenceCountedObject() {} + + +ReferenceCountedObject::ReferenceCountedObject(const ReferenceCountedObject& notUsed) : + ReferenceCountedObject_refCount(0), + ReferenceCountedObject_weakPointer(0) { + (void)notUsed; + debugAssertM(G3D::isValidHeapPointer(this), + "Reference counted objects must be allocated on the heap."); +} + +ReferenceCountedObject& ReferenceCountedObject::operator=(const ReferenceCountedObject& other) { + (void)other; + // Nothing changes when I am assigned; the reference count on + // both objects is the same (although my super-class probably + // changes). + return *this; +} + +} // G3D diff --git a/dep/src/g3dlite/RegistryUtil.cpp b/dep/src/g3dlite/RegistryUtil.cpp new file mode 100644 index 00000000000..fc4cebc2ee5 --- /dev/null +++ b/dep/src/g3dlite/RegistryUtil.cpp @@ -0,0 +1,290 @@ +/** + @file RegistryUtil.cpp + + @created 2006-04-06 + @edited 2006-04-24 + + Copyright 2000-2006, Morgan McGuire. + All rights reserved. +*/ + +#include "G3D/platform.h" + +// This file is only used on Windows +#ifdef G3D_WIN32 + +#include "G3D/RegistryUtil.h" +#include "G3D/System.h" + +namespace G3D { + +// static helpers +static HKEY getRootKeyFromString(const char* str, size_t length); + + +bool RegistryUtil::keyExists(const std::string& key) { + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if (hkey == NULL) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_READ, &openKey); + + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + RegCloseKey(openKey); + return true; + } else { + return false; + } +} + +bool RegistryUtil::valueExists(const std::string& key, const std::string& value) { + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if ( hkey == NULL ) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_READ, &openKey); + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + uint32 dataSize = 0; + result = RegQueryValueExA(openKey, value.c_str(), NULL, NULL, NULL, reinterpret_cast<LPDWORD>(&dataSize)); + + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + RegCloseKey(openKey); + } + return (result == ERROR_SUCCESS); +} + + +bool RegistryUtil::readInt32(const std::string& key, const std::string& value, int32& data) { + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if ( hkey == NULL ) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_READ, &openKey); + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + uint32 dataSize = sizeof(int32); + result = RegQueryValueExA(openKey, value.c_str(), NULL, NULL, reinterpret_cast<LPBYTE>(&data), reinterpret_cast<LPDWORD>(&dataSize)); + + debugAssertM(result == ERROR_SUCCESS, "Could not read registry key value."); + + RegCloseKey(openKey); + } + return (result == ERROR_SUCCESS); +} + +bool RegistryUtil::readBytes(const std::string& key, const std::string& value, uint8* data, uint32& dataSize) { + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if (hkey == NULL) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_READ, &openKey); + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + if (data == NULL) { + result = RegQueryValueExA(openKey, value.c_str(), NULL, NULL, NULL, reinterpret_cast<LPDWORD>(&dataSize)); + } else { + result = RegQueryValueExA(openKey, value.c_str(), NULL, NULL, reinterpret_cast<LPBYTE>(&data), reinterpret_cast<LPDWORD>(&dataSize)); + } + + debugAssertM(result == ERROR_SUCCESS, "Could not read registry key value."); + + RegCloseKey(openKey); + } + return (result == ERROR_SUCCESS); +} + +bool RegistryUtil::readString(const std::string& key, const std::string& value, std::string& data) { + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if (hkey == NULL) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_READ, &openKey); + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + uint32 dataSize = 0; + + result = RegQueryValueExA(openKey, value.c_str(), NULL, NULL, NULL, reinterpret_cast<LPDWORD>(&dataSize)); + debugAssertM(result == ERROR_SUCCESS, "Could not read registry key value."); + + // increment datasize to allow for non null-terminated strings in registry + dataSize += 1; + + if (result == ERROR_SUCCESS) { + char* tmpStr = static_cast<char*>(System::malloc(dataSize)); + System::memset(tmpStr, 0, dataSize); + + result = RegQueryValueExA(openKey, value.c_str(), NULL, NULL, reinterpret_cast<LPBYTE>(tmpStr), reinterpret_cast<LPDWORD>(&dataSize)); + debugAssertM(result == ERROR_SUCCESS, "Could not read registry key value."); + + if (result == ERROR_SUCCESS) { + data = tmpStr; + } + + RegCloseKey(openKey); + System::free(tmpStr); + } + } + return (result == ERROR_SUCCESS); +} + +bool RegistryUtil::writeInt32(const std::string& key, const std::string& value, int32 data) { + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if (hkey == NULL) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_WRITE, &openKey); + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + result = RegSetValueExA(openKey, value.c_str(), 0, REG_DWORD, reinterpret_cast<const BYTE*>(&data), sizeof(int32)); + + debugAssertM(result == ERROR_SUCCESS, "Could not write registry key value."); + + RegCloseKey(openKey); + } + return (result == ERROR_SUCCESS); +} + +bool RegistryUtil::writeBytes(const std::string& key, const std::string& value, const uint8* data, uint32 dataSize) { + debugAssert(data); + + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if (hkey == NULL) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_WRITE, &openKey); + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + if (data) { + result = RegSetValueExA(openKey, value.c_str(), 0, REG_BINARY, reinterpret_cast<const BYTE*>(data), dataSize); + } + + debugAssertM(result == ERROR_SUCCESS, "Could not write registry key value."); + + RegCloseKey(openKey); + } + return (result == ERROR_SUCCESS); +} + +bool RegistryUtil::writeString(const std::string& key, const std::string& value, const std::string& data) { + size_t pos = key.find('\\', 0); + if (pos == std::string::npos) { + return false; + } + + HKEY hkey = getRootKeyFromString(key.c_str(), pos); + + if (hkey == NULL) { + return false; + } + + HKEY openKey; + int32 result = RegOpenKeyExA(hkey, (key.c_str() + pos + 1), 0, KEY_WRITE, &openKey); + debugAssert(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND); + + if (result == ERROR_SUCCESS) { + result = RegSetValueExA(openKey, value.c_str(), 0, REG_SZ, reinterpret_cast<const BYTE*>(data.c_str()), (data.size() + 1)); + debugAssertM(result == ERROR_SUCCESS, "Could not write registry key value."); + + RegCloseKey(openKey); + } + return (result == ERROR_SUCCESS); +} + + +// static helpers +static HKEY getRootKeyFromString(const char* str, size_t length) { + debugAssert(str); + + if (str) { + if ( strncmp(str, "HKEY_CLASSES_ROOT", length) == 0 ) { + return HKEY_CLASSES_ROOT; + } else if ( strncmp(str, "HKEY_CURRENT_CONFIG", length) == 0 ) { + return HKEY_CURRENT_CONFIG; + } else if ( strncmp(str, "HKEY_CURRENT_USER", length) == 0 ) { + return HKEY_CURRENT_USER; + } else if ( strncmp(str, "HKEY_LOCAL_MACHINE", length) == 0 ) { + return HKEY_LOCAL_MACHINE; + } else if ( strncmp(str, "HKEY_PERFORMANCE_DATA", length) == 0 ) { + return HKEY_PERFORMANCE_DATA; + } else if ( strncmp(str, "HKEY_PERFORMANCE_NLSTEXT", length) == 0 ) { + return HKEY_PERFORMANCE_NLSTEXT; + } else if ( strncmp(str, "HKEY_PERFORMANCE_TEXT", length) == 0 ) { + return HKEY_PERFORMANCE_TEXT; + } else if ( strncmp(str, "HKEY_CLASSES_ROOT", length) == 0 ) { + return HKEY_CLASSES_ROOT; + } else { + return NULL; + } + } else { + return NULL; + } +} + +} // namespace G3D + +#endif // G3D_WIN32 diff --git a/dep/src/g3dlite/Sphere.cpp b/dep/src/g3dlite/Sphere.cpp new file mode 100644 index 00000000000..4ed0811cb29 --- /dev/null +++ b/dep/src/g3dlite/Sphere.cpp @@ -0,0 +1,223 @@ +/** + @file Sphere.cpp + + Sphere class + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2001-04-17 + @edited 2009-01-20 + */ + +#include "G3D/platform.h" +#include "G3D/Sphere.h" +#include "G3D/stringutils.h" +#include "G3D/BinaryOutput.h" +#include "G3D/BinaryInput.h" +#include "G3D/AABox.h" +#include "G3D/Plane.h" + +namespace G3D { + +int32 Sphere::dummy; + +Sphere::Sphere(class BinaryInput& b) { + deserialize(b); +} + + +void Sphere::serialize(class BinaryOutput& b) const { + center.serialize(b); + b.writeFloat64(radius); +} + + +void Sphere::deserialize(class BinaryInput& b) { + center.deserialize(b); + radius = (float)b.readFloat64(); +} + + +std::string Sphere::toString() const { + return format("Sphere(<%g, %g, %g>, %g)", + center.x, center.y, center.z, radius); +} + + +bool Sphere::contains(const Vector3& point) const { + float distance = (center - point).squaredMagnitude(); + return distance <= square(radius); +} + + +bool Sphere::contains(const Sphere& other) const { + float distance = (center - other.center).squaredMagnitude(); + return (radius >= other.radius) && (distance <= square(radius - other.radius)); +} + + +bool Sphere::intersects(const Sphere& other) const { + return (other.center - center).length() <= (radius + other.radius); +} + + +void Sphere::merge(const Sphere& other) { + if (other.contains(*this)) { + *this = other; + } else if (! contains(other)) { + // The farthest distance is along the axis between the centers, which + // must not be colocated since neither contains the other. + Vector3 toMe = center - other.center; + // Get a point on the axis from each + toMe = toMe.direction(); + const Vector3& A = center + toMe * radius; + const Vector3& B = other.center - toMe * other.radius; + + // Now just bound the A->B segment + center = (A + B) * 0.5f; + radius = (A - B).length(); + } + // (if this contains other, we're done) +} + + +bool Sphere::culledBy( + const Array<Plane>& plane, + int& cullingPlaneIndex, + const uint32 inMask, + uint32& outMask) const { + + return culledBy(plane.getCArray(), plane.size(), cullingPlaneIndex, inMask, outMask); +} + + +bool Sphere::culledBy( + const Array<Plane>& plane, + int& cullingPlaneIndex, + const uint32 inMask) const { + + return culledBy(plane.getCArray(), plane.size(), cullingPlaneIndex, inMask); +} + + +bool Sphere::culledBy( + const class Plane* plane, + int numPlanes, + int& cullingPlane, + const uint32 _inMask, + uint32& childMask) const { + + if (radius == finf()) { + // No plane can cull the infinite box + return false; + } + + uint32 inMask = _inMask; + assert(numPlanes < 31); + + childMask = 0; + + // See if there is one plane for which all of the + // vertices are in the negative half space. + for (int p = 0; p < numPlanes; p++) { + + // Only test planes that are not masked + if ((inMask & 1) != 0) { + + bool culledLow = ! plane[p].halfSpaceContainsFinite(center + plane[p].normal() * radius); + bool culledHigh = ! plane[p].halfSpaceContainsFinite(center - plane[p].normal() * radius); + + if (culledLow) { + // Plane p culled the sphere + cullingPlane = p; + + // The caller should not recurse into the children, + // since the parent is culled. If they do recurse, + // make them only test against this one plane, which + // will immediately cull the volume. + childMask = 1 << p; + return true; + + } else if (culledHigh) { + // The bounding volume straddled the plane; we have + // to keep testing against this plane + childMask |= (1 << p); + } + } + + // Move on to the next bit. + inMask = inMask >> 1; + } + + // None of the planes could cull this box + cullingPlane = -1; + return false; +} + + +bool Sphere::culledBy( + const class Plane* plane, + int numPlanes, + int& cullingPlane, + const uint32 _inMask) const { + + uint32 inMask = _inMask; + assert(numPlanes < 31); + + // See if there is one plane for which all of the + // vertices are in the negative half space. + for (int p = 0; p < numPlanes; p++) { + + // Only test planes that are not masked + if ((inMask & 1) != 0) { + bool culled = ! plane[p].halfSpaceContains(center + plane[p].normal() * radius); + if (culled) { + // Plane p culled the sphere + cullingPlane = p; + return true; + } + } + + // Move on to the next bit. + inMask = inMask >> 1; + } + + // None of the planes could cull this box + cullingPlane = -1; + return false; +} + + +Vector3 Sphere::randomSurfacePoint() const { + return Vector3::random() * radius + center; +} + + +Vector3 Sphere::randomInteriorPoint() const { + Vector3 result; + do { + result = Vector3(uniformRandom(-1, 1), + uniformRandom(-1, 1), + uniformRandom(-1, 1)); + } while (result.squaredMagnitude() >= 1.0f); + + return result * radius + center; +} + + +float Sphere::volume() const { + return (float)pi() * (4.0f / 3.0f) * powf((float)radius, 3.0f); +} + + +float Sphere::area() const { + return (float)pi() * 4.0f * powf((float)radius, 2.0f); +} + + +void Sphere::getBounds(AABox& out) const { + Vector3 extent(radius, radius, radius); + out = AABox(center - extent, center + extent); +} + +} // namespace diff --git a/dep/src/g3dlite/SplineBase.cpp b/dep/src/g3dlite/SplineBase.cpp new file mode 100644 index 00000000000..41221624b06 --- /dev/null +++ b/dep/src/g3dlite/SplineBase.cpp @@ -0,0 +1,162 @@ +#include "G3D/platform.h" +#include "G3D/Spline.h" + +namespace G3D { + +float SplineBase::getFinalInterval() const { + if (! cyclic) { + return 0; + } else if (finalInterval <= 0) { + int N = time.size(); + if (N >= 2) { + return (time[1] - time[0] + time[N - 1] - time[N - 2]) * 0.5f; + } else { + return 1.0f; + } + } else { + return finalInterval; + } +} + + +Matrix4 SplineBase::computeBasis() { + // The standard Catmull-Rom spline basis (e.g., Watt & Watt p108) + // is for [u^3 u^2 u^1 u^0] * B * [p[0] p[1] p[2] p[3]]^T. + // We need a basis formed for: + // + // U * C * [2*p'[1] p[1] p[2] 2*p'[2]]^T + // + // U * C * [p2-p0 p1 p2 p3-p1]^T + // + // To make this transformation, compute the differences of columns in C: + // For [p0 p1 p2 p3] + Matrix4 basis = + Matrix4( -1, 3, -3, 1, + 2, -5, 4, -1, + -1, 0, 1, 0, + 0, 2, 0, 0) * 0.5f; + + // For [-p0 p1 p2 p3]^T + basis.setColumn(0, -basis.column(0)); + + // For [-p0 p1 p2 p3-p1]^T + basis.setColumn(1, basis.column(1) + basis.column(3)); + + // For [p2-p0 p1 p2 p3-p1]^T + basis.setColumn(2, basis.column(2) - basis.column(0)); + + return basis; +} + + +float SplineBase::duration() const { + if (time.size() == 0) { + return 0; + } else { + return time.last() - time[0] + getFinalInterval(); + } +} + + +void SplineBase::computeIndexInBounds(float s, int& i, float& u) const { + int N = time.size(); + float t0 = time[0]; + float tn = time[N - 1]; + + i = iFloor((N - 1) * (s - t0) / (tn - t0)); + + // Inclusive bounds for binary search + int hi = N - 1; + int lo = 0; + + while ((time[i] > s) || (time[i + 1] <= s)) { + + if (time[i] > s) { + // too big + hi = i - 1; + } else if (time[i + 1] <= s) { + // too small + lo = i + 1; + } + + i = (hi + lo) / 2; + } + + // Having exited the above loop, i must be correct, so compute u. + u = (s - time[i]) / (time[i + 1] - time[i]); +} + + +void SplineBase::computeIndex(float s, int& i, float& u) const { + int N = time.size(); + debugAssertM(N > 0, "No control points"); + float t0 = time[0]; + float tn = time[N - 1]; + + if (N < 2) { + // No control points to work with + i = 0; + u = 0.0; + } else if (cyclic) { + float fi = getFinalInterval(); + + // Cyclic spline + if ((s < t0) || (s >= tn + fi)) { + // Cyclic, off the bottom or top + + // Compute offset and reduce to the in-bounds case + + float d = duration(); + // Number of times we wrapped around the cyclic array + int wraps = iFloor((s - t0) / d); + + debugAssert(s - d * wraps >= t0); + debugAssert(s - d * wraps < tn + getFinalInterval()); + + computeIndex(s - d * wraps, i, u); + i += wraps * N; + + } else if (s >= tn) { + debugAssert(s < tn + fi); + // Cyclic, off the top but before the end of the last interval + i = N - 1; + u = (s - tn) / fi; + + } else { + // Cyclic, in bounds + computeIndexInBounds(s, i, u); + } + + } else { + // Non-cyclic + + if (s < t0) { + // Non-cyclic, off the bottom. Assume points are spaced + // following the first time interval. + + float dt = time[1] - t0; + float x = (s - t0) / dt; + i = iFloor(x); + u = x - i; + + } else if (s >= tn) { + // Non-cyclic, off the top. Assume points are spaced following + // the last time interval. + + float dt = tn - time[N - 2]; + float x = N - 1 + (s - tn) / dt; + i = iFloor(x); + u = x - i; + + } else { + // In bounds, non-cyclic. Assume a regular + // distribution (which gives O(1) for uniform spacing) + // and then binary search to handle the general case + // efficiently. + computeIndexInBounds(s, i, u); + + } // if in bounds + } // if cyclic +} + +} diff --git a/dep/src/g3dlite/Stopwatch.cpp b/dep/src/g3dlite/Stopwatch.cpp new file mode 100644 index 00000000000..9b785d50295 --- /dev/null +++ b/dep/src/g3dlite/Stopwatch.cpp @@ -0,0 +1,119 @@ +/** + @file Stopwatch.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2005-10-05 + @edited 2009-03-14 + + Copyright 2000-2009, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/Stopwatch.h" +#include "G3D/System.h" + +namespace G3D { + +Stopwatch::Stopwatch(const std::string& myName) : + myName(myName), + inBetween(false), lastTockTime(-1), + lastDuration(0), lastCycleCount(0), m_fps(0), emwaFPS(0), + m_smoothFPS(0), emwaDuration(0) { + computeOverhead(); + reset(); +} + + +void Stopwatch::computeOverhead() { + cycleOverhead = 0; + tick(); + tock(); + cycleOverhead = elapsedCycles(); +} + + +void Stopwatch::tick() { + // This is 'alwaysAssert' instead of 'debugAssert' + // since people rarely profile in debug mode. + alwaysAssertM(! inBetween, "Stopwatch::tick() called twice in a row."); + inBetween = true; + + // We read RDTSC twice here, but it is more abstract to implement this + // way and at least we're reading the cycle count last. + timeStart = System::time(); + System::beginCycleCount(cycleStart); +} + + +void Stopwatch::tock() { + System::endCycleCount(cycleStart); + RealTime now = System::time(); + lastDuration = now - timeStart; + if (abs(emwaDuration - lastDuration) > max(emwaDuration, lastDuration) * 0.50) { + // Off by more than 50% + emwaDuration = lastDuration; + } else { + emwaDuration = lastDuration * 0.05 + emwaDuration * 0.95; + } + + lastCycleCount = cycleStart - cycleOverhead; + if (lastCycleCount < 0) { + lastCycleCount = 0; + } + + if (lastTockTime != -1.0) { + m_fps = 1.0 / (now - lastTockTime); + + const double blend = 0.01; + emwaFPS = m_fps * blend + emwaFPS * (1.0 - blend); + + double maxDiscrepancyPercentage = 0.25; + if (abs(emwaFPS - m_fps) > max(emwaFPS, m_fps) * maxDiscrepancyPercentage) { + // The difference between emwa and m_fps is way off, so + // update emwa directly. + emwaFPS = m_fps * 0.20 + emwaFPS * 0.80; + } + + // Update m_smoothFPS only when the value varies significantly. + // We round so as to not mislead the user as to the accuracy of + // the number. + if (m_smoothFPS == 0) { + m_smoothFPS = m_fps; + } else if (emwaFPS <= 20) { + if (::fabs(m_smoothFPS - emwaFPS) > 0.75) { + // Small number and display is off by more than 0.75; round to the nearest 0.1 + m_smoothFPS = floor(emwaFPS * 10.0 + 0.5) / 10.0; + } + } else if (::fabs(m_smoothFPS - emwaFPS) > 1.25) { + // Large number and display is off by more than 1.25; round to the nearest 1.0 + m_smoothFPS = floor(emwaFPS + 0.5); + } + } + lastTockTime = now; + + alwaysAssertM(inBetween, "Stopwatch::tock() called without matching tick."); + inBetween = false; +} + + +void Stopwatch::reset() { + prevTime = startTime = System::time(); + prevMark = "start"; +} + + +void Stopwatch::after(const std::string& s) { + RealTime now = System::time(); + debugPrintf("%s: %10s - %8fs since %s (%fs since start)\n", + myName.c_str(), + s.c_str(), + now - prevTime, + prevMark.c_str(), + now - startTime); + prevTime = now; + prevMark = s; +} + +} + diff --git a/dep/src/g3dlite/System.cpp b/dep/src/g3dlite/System.cpp index e55be13adc5..e03c4e8c6fa 100644 --- a/dep/src/g3dlite/System.cpp +++ b/dep/src/g3dlite/System.cpp @@ -1,7 +1,7 @@ -/** +/** @file System.cpp - - @maintainer Morgan McGuire, matrix@graphics3d.com + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu Note: every routine must call init() first. @@ -10,44 +10,56 @@ can be used at all. At runtime, processor detection is used to determine if we can safely call the routines that use that assembly. - @cite Rob Wyatt http://www.gamasutra.com/features/wyatts_world/19990709/processor_detection_01.htm - @cite Benjamin Jurke http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-ProcessorDetectionClass&forum=cotd&id=-1 - @cite Michael Herf http://www.stereopsis.com/memcpy.html - @created 2003-01-25 - @edited 2006-05-17 + @edited 2010-01-03 */ #include "G3D/platform.h" #include "G3D/System.h" #include "G3D/debug.h" -#include "G3D/format.h" - -#if defined(__OpenBSD__) - #include <stdint.h> +#include "G3D/fileutils.h" +#include "G3D/TextOutput.h" +#include "G3D/G3DGameUnits.h" +#include "G3D/Crypto.h" +#include "G3D/prompt.h" +#include "G3D/stringutils.h" +#include "G3D/Log.h" +#include "G3D/Table.h" +#include "G3D/GMutex.h" +#include "G3D/units.h" +#include <time.h> + +#include <cstring> +#include <cstdio> + +// Uncomment the following line to turn off G3D::System memory +// allocation and use the operating system's malloc. +//#define NO_BUFFERPOOL + +#if defined(__i386__) || defined(__x86_64__) || defined(G3D_WIN32) +# define G3D_NOT_OSX_PPC #endif -#ifdef G3D_WIN32 +#include <cstdlib> - #include <conio.h> - #include <sys/timeb.h> - #include "G3D/RegistryUtil.h" +#ifdef G3D_WIN32 -#elif defined(G3D_LINUX) +# include <conio.h> +# include <sys/timeb.h> +# include "G3D/RegistryUtil.h" - #include <stdlib.h> - #include <stdio.h> - #include <string.h> - #include <errno.h> - #include <sys/types.h> - #include <sys/select.h> - #include <termios.h> - #include <unistd.h> - #include <sys/ioctl.h> - #include <sys/time.h> - #include <pthread.h> +#elif defined(G3D_LINUX) - // #include <assert.h> +# include <stdlib.h> +# include <stdio.h> +# include <errno.h> +# include <sys/types.h> +# include <sys/select.h> +# include <termios.h> +# include <unistd.h> +# include <sys/ioctl.h> +# include <sys/time.h> +# include <pthread.h> #elif defined(G3D_OSX) @@ -67,50 +79,847 @@ #include <CoreServices/CoreServices.h> #endif -#if defined(SSE) - #include <xmmintrin.h> +// SIMM include +#ifdef __SSE__ +#include <xmmintrin.h> #endif namespace G3D { -static char versionCstr[1024]; -System::OutOfMemoryCallback System::outOfMemoryCallback = NULL; -void System::init() { - // Cannot use most G3D data structures or utility functions in here because - // they are not initialized. +/** Checks if the CPUID command is available on the processor (called from init) */ +static bool checkForCPUID(); - static bool initialized = false; +/** Called from init */ +static void getG3DVersion(std::string& s); + +/** Called from init */ +static G3DEndian checkEndian(); - if (initialized) { + +System& System::instance() { + static System thesystem; + return thesystem; +} + + +System::System() : + m_initialized(false), + m_cpuSpeed(0), + m_hasCPUID(false), + m_hasRDTSC(false), + m_hasMMX(false), + m_hasSSE(false), + m_hasSSE2(false), + m_hasSSE3(false), + m_has3DNOW(false), + m_has3DNOW2(false), + m_hasAMDMMX(false), + m_cpuVendor("Uninitialized"), + m_numCores(1), + m_machineEndian(G3D_LITTLE_ENDIAN), + m_cpuArch("Uninitialized"), + m_operatingSystem("Uninitialized"), + m_version("Uninitialized"), + m_outOfMemoryCallback(NULL), + m_realWorldGetTickTime0(0), + m_highestCPUIDFunction(0) { + + init(); +} + + +void System::init() { + // NOTE: Cannot use most G3D data structures or utility functions + // in here because they are not initialized. + + if (m_initialized) { return; + } else { + m_initialized = true; } - initialized = true; + getG3DVersion(m_version); + + m_machineEndian = checkEndian(); + + m_hasCPUID = checkForCPUID(); + // Process the CPUID information + if (m_hasCPUID) { + // We read the standard CPUID level 0x00000000 which should + // be available on every x86 processor. This fills out + // a string with the processor vendor tag. + unsigned int eaxreg = 0, ebxreg = 0, ecxreg = 0, edxreg = 0; + + cpuid(CPUID_VENDOR_ID, eaxreg, ebxreg, ecxreg, edxreg); + + { + char c[100]; + // Then we connect the single register values to the vendor string + *((unsigned int*) c) = ebxreg; + *((unsigned int*) (c + 4)) = edxreg; + *((unsigned int*) (c + 8)) = ecxreg; + c[12] = '\0'; + m_cpuVendor = c; + } + + switch (ebxreg) { + case 0x756E6547: // GenuineIntel + m_cpuArch = "Intel Processor"; + break; + + case 0x68747541: // AuthenticAMD + m_cpuArch = "AMD Processor"; + break; + + case 0x69727943: // CyrixInstead + m_cpuArch = "Cyrix Processor"; + break; + + default: + m_cpuArch = "Unknown Processor Vendor"; + break; + } + + + unsigned int highestFunction = eaxreg; + if (highestFunction >= CPUID_NUM_CORES) { + cpuid(CPUID_NUM_CORES, eaxreg, ebxreg, ecxreg, edxreg); + // Number of cores is in (eax>>26) + 1 + m_numCores = (eaxreg >> 26) + 1; + } + cpuid(CPUID_GET_HIGHEST_FUNCTION, m_highestCPUIDFunction, ebxreg, ecxreg, edxreg); + } + + + // Get the operating system name (also happens to read some other information) +# ifdef G3D_WIN32 + // Note that this overrides some of the values computed above + bool success = RegistryUtil::readInt32 + ("HKEY_LOCAL_MACHINE\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", + "~MHz", m_cpuSpeed); + + SYSTEM_INFO systemInfo; + GetSystemInfo(&systemInfo); + const char* arch = NULL; + switch (systemInfo.wProcessorArchitecture) { + case PROCESSOR_ARCHITECTURE_INTEL: + arch = "Intel"; + break; + + case PROCESSOR_ARCHITECTURE_MIPS: + arch = "MIPS"; + break; + + case PROCESSOR_ARCHITECTURE_ALPHA: + arch = "Alpha"; + break; + + case PROCESSOR_ARCHITECTURE_PPC: + arch = "Power PC"; + break; + + default: + arch = "Unknown"; + } + + m_numCores = systemInfo.dwNumberOfProcessors; + uint32 maxAddr = (uint32)systemInfo.lpMaximumApplicationAddress; + { + char c[1024]; + sprintf(c, "%d x %d-bit %s processor", + systemInfo.dwNumberOfProcessors, + (int)(::log((double)maxAddr) / ::log(2.0) + 2.0), + arch); + m_cpuArch = c; + } + + OSVERSIONINFO osVersionInfo; + osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + success = GetVersionEx(&osVersionInfo) != 0; + + if (success) { + char c[1000]; + sprintf(c, "Windows %d.%d build %d Platform %d %s", + osVersionInfo.dwMajorVersion, + osVersionInfo.dwMinorVersion, + osVersionInfo.dwBuildNumber, + osVersionInfo.dwPlatformId, + osVersionInfo.szCSDVersion); + m_operatingSystem = c; + } else { + m_operatingSystem = "Windows"; + } + +# elif defined(G3D_LINUX) || defined(G3D_FREEBSD) + + { + // Find the operating system using the 'uname' command + FILE* f = popen("uname -a", "r"); + + int len = 100; + char* r = (char*)::malloc(len * sizeof(char)); + fgets(r, len, f); + // Remove trailing newline + if (r[strlen(r) - 1] == '\n') { + r[strlen(r) - 1] = '\0'; + } + fclose(f); + + m_operatingSystem = r; + ::free(r); + } + +# elif defined(G3D_OSX) + + // Operating System: + SInt32 macVersion; + Gestalt(gestaltSystemVersion, &macVersion); + + int major = (macVersion >> 8) & 0xFF; + int minor = (macVersion >> 4) & 0xF; + int revision = macVersion & 0xF; + + { + char c[1000]; + sprintf(c, "OS X %x.%x.%x", major, minor, revision); + m_operatingSystem = c; + } + + // Clock Cycle Timing Information: + Gestalt('pclk', &m_OSXCPUSpeed); + m_cpuSpeed = iRound((double)m_OSXCPUSpeed / (1024 * 1024)); + m_secondsPerNS = 1.0 / 1.0e9; + + // System Architecture: + const NXArchInfo* pInfo = NXGetLocalArchInfo(); + + if (pInfo) { + m_cpuArch = pInfo->description; + + switch (pInfo->cputype) { + case CPU_TYPE_POWERPC: + switch(pInfo->cpusubtype){ + case CPU_SUBTYPE_POWERPC_750: + case CPU_SUBTYPE_POWERPC_7400: + case CPU_SUBTYPE_POWERPC_7450: + m_cpuVendor = "Motorola"; + break; + case CPU_SUBTYPE_POWERPC_970: + m_cpuVendor = "IBM"; + break; + } + break; + + case CPU_TYPE_I386: + m_cpuVendor = "Intel"; + break; + } + } +# endif + + initTime(); + + getStandardProcessorExtensions(); +} + + +void getG3DVersion(std::string& s) { + char cstr[100]; if ((G3D_VER % 100) != 0) { - sprintf(versionCstr, "G3D %d.%02d beta %d", - G3D_VER / 10000, - (G3D_VER / 100) % 100, - G3D_VER % 100); + sprintf(cstr, "G3D %d.%02d beta %d", + G3D_VER / 10000, + (G3D_VER / 100) % 100, + G3D_VER % 100); } else { - sprintf(versionCstr, "G3D %d.%02d", - G3D_VER / 10000, - (G3D_VER / 100) % 100); + sprintf(cstr, "G3D %d.%02d", + G3D_VER / 10000, + (G3D_VER / 100) % 100); } + s = cstr; +} + +#if 0 // TODO: delete +struct Directory { + std::string path; + Array<std::string> contents; +}; +static bool maybeAddDirectory(const std::string& newPath, Array<Directory>& directoryArray, bool recurse = true) { + if (fileExists(newPath)) { + Directory& d = directoryArray.next(); + d.path = newPath; + getFiles(pathConcat(newPath, "*"), d.contents); + Array<std::string> dirs; + getDirs(pathConcat(newPath, "*"), dirs); + d.contents.append(dirs); + + if (recurse) { + // Look for subdirectories + static const std::string subdirs[] = + {"font", "gui", "SuperShader", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", ""}; + + for (int j = 0; j < dirs.size(); ++j) { + for (int i = 0; ! subdirs[i].empty(); ++i) { + if (dirs[j] == subdirs[i]) { + maybeAddDirectory(pathConcat(newPath, dirs[j]), directoryArray, false); + } + } + } + } + return true; + } else { + return false; + } } +#endif + +std::string System::findDataFile +(const std::string& full, + bool errorIfNotFound) { + + // Places where specific files were most recently found. This is + // used to cache seeking of common files. + static Table<std::string, std::string> lastFound; + + // First check if the file exists as requested. This will go + // through the FileSystemCache, so most calls do not touch disk. + if (fileExists(full)) { + return full; + } + + // Now check where we previously found this file. + std::string* last = lastFound.getPointer(full); + if (last != NULL) { + if (fileExists(*last)) { + // Even if cwd has changed the file is still present. + // We won't notice if it has been deleted, however. + return *last; + } else { + // Remove this from the cache it is invalid + lastFound.remove(full); + } + } + + // Places to look + static Array<std::string> directoryArray; + + if (directoryArray.size() == 0) { + // Initialize the directory array + RealTime t0 = System::time(); + + Array<std::string> baseDirArray; + + std::string initialAppDataDir(instance().m_appDataDir); + + baseDirArray.append(""); + if (! initialAppDataDir.empty()) { + baseDirArray.append(initialAppDataDir); + } + + const char* g3dPath = getenv("G3DDATA"); + + if (g3dPath && (initialAppDataDir != g3dPath)) { + baseDirArray.append(g3dPath); + } + + static const std::string subdirs[] = + {"font", "gui", "SuperShader", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", ""}; + for (int j = 0; j < baseDirArray.size(); ++j) { + std::string d = baseDirArray[j]; + if (fileExists(d)) { + directoryArray.append(d); + for (int i = 0; ! subdirs[i].empty(); ++i) { + const std::string& p = pathConcat(d, subdirs[i]); + if (fileExists(p)) { + directoryArray.append(p); + } + } + } + } + + logLazyPrintf("Initializing System::findDataFile took %fs\n", System::time() - t0); + } + + for (int i = 0; i < directoryArray.size(); ++i) { + const std::string& p = pathConcat(directoryArray[i], full); + if (fileExists(p)) { + lastFound.set(full, p); + return p; + } + } + + if (errorIfNotFound) { + // Generate an error message + std::string locations; + for (int i = 0; i < directoryArray.size(); ++i) { + locations += pathConcat(directoryArray[i], full) + "\n"; + } + alwaysAssertM(false, "Could not find '" + full + "' in:\n" + locations); + } + + // Not found + return ""; +} + + +void System::setAppDataDir(const std::string& path) { + instance().m_appDataDir = path; +} + + +std::string demoFindData(bool errorIfNotFound) { + static const char* g3dPath = getenv("G3DDATA"); + if (g3dPath) { + return g3dPath; +# ifdef G3D_WIN32 + } else if (fileExists("../data")) { + // G3D install on Windows + return "../data"; + } else if (fileExists("../data-files")) { + // G3D source on Windows + return "../data-files"; +# else + } else if (fileExists("../../../../data")) { + // G3D install on Unix + return "../../../../data"; + } else if (fileExists("../../../../data-files")) { + // G3D source on Unix + return "../../../../data-files"; +# endif + } else { + return ""; + } +} + + +const std::string& System::build() { + const static std::string b = +# ifdef _DEBUG + "Debug"; +# else + "Release"; +# endif + + return b; +} + + +static G3DEndian checkEndian() { + int32 a = 1; + if (*(uint8*)&a == 1) { + return G3D_LITTLE_ENDIAN; + } else { + return G3D_BIG_ENDIAN; + } +} + + +static bool checkForCPUID() { + // all known supported architectures have cpuid + // add cases for incompatible architectures if they are added + // e.g., if we ever support __powerpc__ being defined again + + return true; +} + + +void System::getStandardProcessorExtensions() { +#if ! defined(G3D_OSX) || defined(G3D_OSX_INTEL) + if (! m_hasCPUID) { + return; + } + + uint32 eaxreg = 0, ebxreg = 0, ecxreg = 0, features = 0; + + cpuid(CPUID_PROCESSOR_FEATURES, eaxreg, ebxreg, ecxreg, features); + +# define checkBit(var, bit) ((var & (1 << bit)) ? true : false) + + m_hasRDTSC = checkBit(features, 4); + m_hasMMX = checkBit(features, 23); + m_hasSSE = checkBit(features, 25); + m_hasSSE2 = checkBit(features, 26); + // Bit 28 is HTT; not checked by G3D + + m_hasSSE3 = checkBit(ecxreg, 0); + + if (m_highestCPUIDFunction >= CPUID_EXTENDED_FEATURES) { + cpuid(CPUID_EXTENDED_FEATURES, eaxreg, ebxreg, ecxreg, features); + m_hasAMDMMX = checkBit(features, 22); // Only on AMD + m_has3DNOW = checkBit(features, 31); // Only on AMD + m_has3DNOW2 = checkBit(features, 30); // Only on AMD + } else { + m_hasAMDMMX = false; + m_has3DNOW = false; + m_has3DNOW2 = false; + } + +# undef checkBit +#endif +} + +#if defined(G3D_WIN32) && !defined(G3D_64BIT) + #pragma message("Port System::memcpy SIMD to all platforms") +/** Michael Herf's fast memcpy */ +void memcpyMMX(void* dst, const void* src, int nbytes) { + int remainingBytes = nbytes; + + if (nbytes > 64) { + _asm { + mov esi, src + mov edi, dst + mov ecx, nbytes + shr ecx, 6 // 64 bytes per iteration + + loop1: + movq mm1, 0[ESI] // Read in source data + movq mm2, 8[ESI] + movq mm3, 16[ESI] + movq mm4, 24[ESI] + movq mm5, 32[ESI] + movq mm6, 40[ESI] + movq mm7, 48[ESI] + movq mm0, 56[ESI] + + movntq 0[EDI], mm1 // Non-temporal stores + movntq 8[EDI], mm2 + movntq 16[EDI], mm3 + movntq 24[EDI], mm4 + movntq 32[EDI], mm5 + movntq 40[EDI], mm6 + movntq 48[EDI], mm7 + movntq 56[EDI], mm0 + + add esi, 64 + add edi, 64 + dec ecx + jnz loop1 + + emms + } + remainingBytes -= ((nbytes >> 6) << 6); + } + + if (remainingBytes > 0) { + // Memcpy the rest + memcpy((uint8*)dst + (nbytes - remainingBytes), + (const uint8*)src + (nbytes - remainingBytes), remainingBytes); + } +} +#endif void System::memcpy(void* dst, const void* src, size_t numBytes) { - ::memcpy(dst, src, numBytes); +#if defined(G3D_WIN32) && !defined(G3D_64BIT) + memcpyMMX(dst, src, numBytes); +#else + ::memcpy(dst, src, numBytes); +#endif +} + + +/** Michael Herf's fastest memset. n32 must be filled with the same + character repeated. */ +#if defined(G3D_WIN32) && !defined(G3D_64BIT) + #pragma message("Port System::memfill SIMD to all platforms") + +// On x86 processors, use MMX +void memfill(void *dst, int n32, unsigned long i) { + + int originalSize = i; + int bytesRemaining = i; + + if (i > 16) { + + bytesRemaining = i % 16; + i -= bytesRemaining; + __asm { + movq mm0, n32 + punpckldq mm0, mm0 + mov edi, dst + + loopwrite: + + movntq 0[edi], mm0 + movntq 8[edi], mm0 + + add edi, 16 + sub i, 16 + jg loopwrite + + emms + } + } + + if (bytesRemaining > 0) { + ::memset((uint8*)dst + (originalSize - bytesRemaining), n32, bytesRemaining); + } } +#endif + void System::memset(void* dst, uint8 value, size_t numBytes) { - ::memset(dst, value, numBytes); +#if defined(G3D_WIN32) && !defined(G3D_64BIT) + uint32 v = value; + v = v + (v << 8) + (v << 16) + (v << 24); + G3D::memfill(dst, v, numBytes); +#else + ::memset(dst, value, numBytes); +#endif +} + + +/** Removes the 'd' that icompile / Morgan's VC convention appends. */ +static std::string computeAppName(const std::string& start) { + if (start.size() < 2) { + return start; + } + + if (start[start.size() - 1] == 'd') { + // Maybe remove the 'd'; see if ../ or ../../ has the same name + char tmp[1024]; + getcwd(tmp, sizeof(tmp)); + std::string drive, base, ext; + Array<std::string> path; + parseFilename(tmp, drive, path, base, ext); + + std::string shortName = start.substr(0, start.size() - 1); + + if ((path.size() > 1) && (toLower(path.last()) == toLower(shortName))) { + return shortName; + } + + if ((path.size() > 2) && (toLower(path[path.size() - 2]) == toLower(shortName))) { + return shortName; + } + } + + return start; +} + + +std::string& System::appName() { + static std::string n = computeAppName(filenameBase(currentProgramFilename())); + return n; +} + + +std::string System::currentProgramFilename() { + char filename[2048]; + +# ifdef G3D_WIN32 + { + GetModuleFileNameA(NULL, filename, sizeof(filename)); + } +# elif defined(G3D_OSX) + { + // Run the 'ps' program to extract the program name + // from the process ID. + int pid; + FILE* fd; + char cmd[80]; + pid = getpid(); + sprintf(cmd, "ps -p %d -o comm=\"\"", pid); + + fd = popen(cmd, "r"); + int s = fread(filename, 1, sizeof(filename), fd); + // filename will contain a newline. Overwrite it: + filename[s - 1] = '\0'; + } +# else + { + int ret = readlink("/proc/self/exe", filename, sizeof(filename)); + + // In case of an error, leave the handling up to the caller + if (ret == -1) { + return ""; + } + + debugAssert((int)sizeof(filename) > ret); + + // Ensure proper NULL termination + filename[ret] = 0; + } + #endif + + return filename; +} + + +void System::sleep(RealTime t) { + + // Overhead of calling this function, measured from a previous run. + static const RealTime OVERHEAD = 0.00006f; + + RealTime now = time(); + RealTime wakeupTime = now + t - OVERHEAD; + + RealTime remainingTime = wakeupTime - now; + RealTime sleepTime = 0; + + // On Windows, a "time slice" is measured in quanta of 3-5 ms (http://support.microsoft.com/kb/259025) + // Sleep(0) yields the remainder of the time slice, which could be a long time. + // A 1 ms minimum time experimentally kept the "Empty GApp" at nearly no CPU load at 100 fps, + // yet nailed the frame timing perfectly. + static RealTime minRealSleepTime = 3 * units::milliseconds(); + + while (remainingTime > 0) { + + if (remainingTime > minRealSleepTime * 2.5) { + // Safe to use Sleep with a time... sleep for half the remaining time + sleepTime = max(remainingTime * 0.5, 0.0005); + } else if (remainingTime > minRealSleepTime) { + // Safe to use Sleep with a zero time; + // causes the program to yield only + // the current time slice, and then return. + sleepTime = 0; + } else { + // Not safe to use Sleep; busy wait + sleepTime = -1; + } + + if (sleepTime >= 0) { + #ifdef G3D_WIN32 + // Translate to milliseconds + Sleep((int)(sleepTime * 1e3)); + #else + // Translate to microseconds + usleep((int)(sleepTime * 1e6)); + #endif + } + + now = time(); + remainingTime = wakeupTime - now; + } +} + + +void System::consoleClearScreen() { +# ifdef G3D_WIN32 + system("cls"); +# else + system("clear"); +# endif +} + + +bool System::consoleKeyPressed() { + #ifdef G3D_WIN32 + + return _kbhit() != 0; + + #else + + static const int STDIN = 0; + static bool initialized = false; + + if (! initialized) { + // Use termios to turn off line buffering + termios term; + tcgetattr(STDIN, &term); + term.c_lflag &= ~ICANON; + tcsetattr(STDIN, TCSANOW, &term); + setbuf(stdin, NULL); + initialized = true; + } + + #ifdef G3D_LINUX + + int bytesWaiting; + ioctl(STDIN, FIONREAD, &bytesWaiting); + return bytesWaiting; + + #else + + timeval timeout; + fd_set rdset; + + FD_ZERO(&rdset); + FD_SET(STDIN, &rdset); + timeout.tv_sec = 0; + timeout.tv_usec = 0; + + return select(STDIN + 1, &rdset, NULL, NULL, &timeout); + #endif + #endif +} + + +int System::consoleReadKey() { +# ifdef G3D_WIN32 + return _getch(); +# else + char c; + read(0, &c, 1); + return c; +# endif +} + + +void System::initTime() { + #ifdef G3D_WIN32 + if (QueryPerformanceFrequency(&m_counterFrequency)) { + QueryPerformanceCounter(&m_start); + } + + struct _timeb t; + _ftime(&t); + + m_realWorldGetTickTime0 = (RealTime)t.time - t.timezone * G3D::MINUTE + (t.dstflag ? G3D::HOUR : 0); + + #else + gettimeofday(&m_start, NULL); + // "sse" = "seconds since epoch". The time + // function returns the seconds since the epoch + // GMT (perhaps more correctly called UTC). + time_t gmt = ::time(NULL); + + // No call to free or delete is needed, but subsequent + // calls to asctime, ctime, mktime, etc. might overwrite + // local_time_vals. + tm* localTimeVals = localtime(&gmt); + + time_t local = gmt; + + if (localTimeVals) { + // tm_gmtoff is already corrected for daylight savings. + local = local + localTimeVals->tm_gmtoff; + } + + m_realWorldGetTickTime0 = local; + #endif +} + + +RealTime System::time() { +# ifdef G3D_WIN32 + LARGE_INTEGER now; + QueryPerformanceCounter(&now); + + return ((RealTime)(now.QuadPart - instance().m_start.QuadPart) / + instance().m_counterFrequency.QuadPart) + instance().m_realWorldGetTickTime0; +# else + // Linux resolution defaults to 100Hz. + // There is no need to do a separate RDTSC call as gettimeofday + // actually uses RDTSC when on systems that support it, otherwise + // it uses the system clock. + struct timeval now; + gettimeofday(&now, NULL); + + return (now.tv_sec - instance().m_start.tv_sec) + + (now.tv_usec - instance().m_start.tv_usec) / 1e6 + + instance().m_realWorldGetTickTime0; +# endif } //////////////////////////////////////////////////////////////// + +#define REALPTR_TO_USERPTR(x) ((uint8*)(x) + sizeof (void *)) +#define USERPTR_TO_REALPTR(x) ((uint8*)(x) - sizeof (void *)) +#define REALBLOCK_SIZE(x) ((x) + sizeof (void *)) + class BufferPool { public: @@ -119,16 +928,18 @@ public: A large block is preallocated for tiny buffers; they are used with tremendous frequency. Other buffers are allocated as demanded. + Tiny buffers are 128 bytes long because that seems to align well with + cache sizes on many machines. */ enum {tinyBufferSize = 128, smallBufferSize = 1024, medBufferSize = 4096}; - /** + /** Most buffers we're allowed to store. - 64000 * 128 = 8 MB (preallocated) - 1024 * 1024 = 1 MB (allocated on demand) - 1024 * 4096 = 4 MB (allocated on demand) + 250000 * 128 = 32 MB (preallocated) + 10000 * 1024 = 10 MB (allocated on demand) + 1024 * 4096 = 4 MB (allocated on demand) */ - enum {maxTinyBuffers = 64000, maxSmallBuffers = 1024, maxMedBuffers = 1024}; + enum {maxTinyBuffers = 250000, maxSmallBuffers = 10000, maxMedBuffers = 1024}; private: @@ -157,6 +968,17 @@ private: /** Pointer to the data in the tiny pool */ void* tinyHeap; + Spinlock m_lock; + + void lock() { + m_lock.lock(); + } + + void unlock() { + m_lock.unlock(); + } + +#if 0 //-----------------------------------------------old mutex # ifdef G3D_WIN32 CRITICAL_SECTION mutex; # else @@ -179,22 +1001,35 @@ private: pthread_mutex_unlock(&mutex); # endif } +#endif //-------------------------------------------old mutex - /** - Malloc out of the tiny heap. + /** + Malloc out of the tiny heap. Returns NULL if allocation failed. */ inline void* tinyMalloc(size_t bytes) { // Note that we ignore the actual byte size // and create a constant size block. (void)bytes; - debugAssert(tinyBufferSize >= bytes); + assert(tinyBufferSize >= bytes); void* ptr = NULL; if (tinyPoolSize > 0) { --tinyPoolSize; - // Return the last one + + // Return the old last pointer from the freelist ptr = tinyPool[tinyPoolSize]; + +# ifdef G3D_DEBUG + if (tinyPoolSize > 0) { + assert(tinyPool[tinyPoolSize - 1] != ptr); + // "System::malloc heap corruption detected: " + // "the last two pointers on the freelist are identical (during tinyMalloc)."); + } +# endif + + // NULL out the entry to help detect corruption + tinyPool[tinyPoolSize] = NULL; } return ptr; @@ -202,12 +1037,26 @@ private: /** Returns true if this is a pointer into the tiny heap. */ bool inTinyHeap(void* ptr) { - return (ptr >= tinyHeap) && - (ptr < (uint8*)tinyHeap + maxTinyBuffers * tinyBufferSize); + return + (ptr >= tinyHeap) && + (ptr < (uint8*)tinyHeap + maxTinyBuffers * tinyBufferSize); } void tinyFree(void* ptr) { - debugAssert(tinyPoolSize < maxTinyBuffers); + assert(ptr); + assert(tinyPoolSize < maxTinyBuffers); + // "Tried to free a tiny pool buffer when the tiny pool freelist is full."); + +# ifdef G3D_DEBUG + if (tinyPoolSize > 0) { + void* prevOnHeap = tinyPool[tinyPoolSize - 1]; + assert(prevOnHeap != ptr); +// "System::malloc heap corruption detected: " +// "the last two pointers on the freelist are identical (during tinyFree)."); + } +# endif + + assert(tinyPool[tinyPoolSize] == NULL); // Put the pointer back into the free list tinyPool[tinyPoolSize] = ptr; @@ -217,16 +1066,17 @@ private: void flushPool(MemBlock* pool, int& poolSize) { for (int i = 0; i < poolSize; ++i) { - ::free(pool->ptr); - pool->ptr = NULL; - pool->bytes = 0; + ::free(pool[i].ptr); + pool[i].ptr = NULL; + pool[i].bytes = 0; } poolSize = 0; } - /** Allocate out of a specific pool-> Return NULL if no suitable - memory was found. + /** Allocate out of a specific pool-> Return NULL if no suitable + memory was found. + */ void* malloc(MemBlock* pool, int& poolSize, size_t bytes) { @@ -260,13 +1110,13 @@ public: int mallocsFromSmallPool; int mallocsFromMedPool; - /** Amount of memory currently allocated (according to the application). + /** Amount of memory currently allocated (according to the application). This does not count the memory still remaining in the buffer pool, but does count extra memory required for rounding off to the size of a buffer. Primarily useful for detecting leaks.*/ // TODO: make me an atomic int! - int bytesAllocated; + volatile int bytesAllocated; BufferPool() { totalMallocs = 0; @@ -284,6 +1134,7 @@ public: medPoolSize = 0; + // Initialize the tiny heap as a bunch of pointers into one // pre-allocated buffer. tinyHeap = ::malloc(maxTinyBuffers * tinyBufferSize); @@ -292,22 +1143,28 @@ public: } tinyPoolSize = maxTinyBuffers; +#if 0 ///---------------------------------- old mutex # ifdef G3D_WIN32 InitializeCriticalSection(&mutex); # else pthread_mutex_init(&mutex, NULL); # endif +#endif ///---------------------------------- old mutex } + ~BufferPool() { ::free(tinyHeap); +#if 0 //-------------------------------- old mutex # ifdef G3D_WIN32 DeleteCriticalSection(&mutex); # else // No destruction on pthreads # endif +#endif //--------------------------------old mutex } + void* realloc(void* ptr, size_t bytes) { if (ptr == NULL) { return malloc(bytes); @@ -319,7 +1176,7 @@ public: return ptr; } else { // Free the old pointer and malloc - + void* newPtr = malloc(bytes); System::memcpy(newPtr, ptr, tinyBufferSize); tinyFree(ptr); @@ -330,7 +1187,7 @@ public: // In one of our heaps. // See how big the block really was - size_t realSize = ((uint32*)ptr)[-1]; + size_t realSize = *(uint32*)USERPTR_TO_REALPTR(ptr); if (bytes <= realSize) { // The old block was big enough. return ptr; @@ -344,6 +1201,7 @@ public: } } + void* malloc(size_t bytes) { lock(); ++totalMallocs; @@ -358,12 +1216,12 @@ public: return ptr; } - } - + } + // Failure to allocate a tiny buffer is allowed to flow // through to a small buffer if (bytes <= smallBufferSize) { - + void* ptr = malloc(smallPool, smallPoolSize, bytes); if (ptr) { @@ -372,7 +1230,7 @@ public: return ptr; } - } else if (bytes <= medBufferSize) { + } else if (bytes <= medBufferSize) { // Note that a small allocation failure does *not* fall // through into a medium allocation because that would // waste the medium buffer's resources. @@ -382,54 +1240,63 @@ public: if (ptr) { ++mallocsFromMedPool; unlock(); + debugAssertM(ptr != NULL, "BufferPool::malloc returned NULL"); return ptr; } } - bytesAllocated += 4 + (int) bytes; + bytesAllocated += REALBLOCK_SIZE(bytes); unlock(); // Heap allocate // Allocate 4 extra bytes for our size header (unfortunate, // since malloc already added its own header). - void* ptr = ::malloc(bytes + 4); + void* ptr = ::malloc(REALBLOCK_SIZE(bytes)); if (ptr == NULL) { // Flush memory pools to try and recover space flushPool(smallPool, smallPoolSize); flushPool(medPool, medPoolSize); - ptr = ::malloc(bytes + 4); + ptr = ::malloc(REALBLOCK_SIZE(bytes)); } if (ptr == NULL) { - if ((System::outOfMemoryCallback != NULL) && - (System::outOfMemoryCallback(bytes + 4, true) == true)) { + if ((System::outOfMemoryCallback() != NULL) && + (System::outOfMemoryCallback()(REALBLOCK_SIZE(bytes), true) == true)) { // Re-attempt the malloc - ptr = ::malloc(bytes + 4); + ptr = ::malloc(REALBLOCK_SIZE(bytes)); } } if (ptr == NULL) { - if (System::outOfMemoryCallback != NULL) { + if (System::outOfMemoryCallback() != NULL) { // Notify the application - System::outOfMemoryCallback(bytes + 4, false); + System::outOfMemoryCallback()(REALBLOCK_SIZE(bytes), false); } +# ifdef G3D_DEBUG + debugPrintf("::malloc(%d) returned NULL\n", (int)REALBLOCK_SIZE(bytes)); +# endif + debugAssertM(ptr != NULL, + "::malloc returned NULL. Either the " + "operating system is out of memory or the " + "heap is corrupt."); return NULL; } - *(uint32*)ptr = (uint32)bytes; + *(uint32*)ptr = bytes; - return (uint8*)ptr + 4; + return REALPTR_TO_USERPTR(ptr); } + void free(void* ptr) { if (ptr == NULL) { // Free does nothing on null pointers return; } - debugAssert(isValidPointer(ptr)); + assert(isValidPointer(ptr)); if (inTinyHeap(ptr)) { lock(); @@ -438,7 +1305,7 @@ public: return; } - uint32 bytes = ((uint32*)ptr)[-1]; + uint32 bytes = *(uint32*)USERPTR_TO_REALPTR(ptr); lock(); if (bytes <= smallBufferSize) { @@ -456,17 +1323,17 @@ public: return; } } - bytesAllocated -= bytes + 4; + bytesAllocated -= REALBLOCK_SIZE(bytes); unlock(); // Free; the buffer pools are full or this is too big to store. - ::free((uint8*)ptr - 4); + ::free(USERPTR_TO_REALPTR(ptr)); } std::string performance() const { if (totalMallocs > 0) { int pooled = mallocsFromTinyPool + - mallocsFromSmallPool + + mallocsFromSmallPool + mallocsFromMedPool; int total = totalMallocs; @@ -493,11 +1360,11 @@ public: }; // Dynamically allocated because we need to ensure that -// the buffer pool is still around when the last global variable +// the buffer pool is still around when the last global variable // is deallocated. static BufferPool* bufferpool = NULL; -std::string System::mallocPerformance() { +std::string System::mallocPerformance() { #ifndef NO_BUFFERPOOL return bufferpool->performance(); #else @@ -505,7 +1372,7 @@ std::string System::mallocPerformance() { #endif } -std::string System::mallocStatus() { +std::string System::mallocStatus() { #ifndef NO_BUFFERPOOL return bufferpool->status(); #else @@ -513,6 +1380,7 @@ std::string System::mallocStatus() { #endif } + void System::resetMallocPerformanceCounters() { #ifndef NO_BUFFERPOOL bufferpool->totalMallocs = 0; @@ -522,6 +1390,7 @@ void System::resetMallocPerformanceCounters() { #endif } + #ifndef NO_BUFFERPOOL inline void initMem() { // Putting the test here ensures that the system is always @@ -534,6 +1403,7 @@ inline void initMem() { } #endif + void* System::malloc(size_t bytes) { #ifndef NO_BUFFERPOOL initMem(); @@ -546,6 +1416,8 @@ void* System::malloc(size_t bytes) { void* System::calloc(size_t n, size_t x) { #ifndef NO_BUFFERPOOL void* b = System::malloc(n * x); + debugAssertM(b != NULL, "System::malloc returned NULL"); + debugAssertM(isValidHeapPointer(b), "System::malloc returned an invalid pointer"); System::memset(b, 0, n * x); return b; #else @@ -553,6 +1425,7 @@ void* System::calloc(size_t n, size_t x) { #endif } + void* System::realloc(void* block, size_t bytes) { #ifndef NO_BUFFERPOOL initMem(); @@ -562,6 +1435,7 @@ void* System::realloc(void* block, size_t bytes) { #endif } + void System::free(void* p) { #ifndef NO_BUFFERPOOL bufferpool->free(p); @@ -570,80 +1444,303 @@ void System::free(void* p) { #endif } + void* System::alignedMalloc(size_t bytes, size_t alignment) { + alwaysAssertM(isPow2(alignment), "alignment must be a power of 2"); // We must align to at least a word boundary. - alignment = iMax((int)alignment, sizeof(void *)); + alignment = iMax(alignment, sizeof(void *)); // Pad the allocation size with the alignment size and the // size of the redirect pointer. - size_t totalBytes = bytes + alignment + sizeof(intptr_t); + size_t totalBytes = bytes + alignment + sizeof(void*); - void* truePtr = System::malloc(totalBytes); + size_t truePtr = (size_t)System::malloc(totalBytes); - if (!truePtr) { + if (truePtr == 0) { // malloc returned NULL return NULL; } - debugAssert(isValidHeapPointer(truePtr)); + debugAssert(isValidHeapPointer((void*)truePtr)); #ifdef G3D_WIN32 // The blocks we return will not be valid Win32 debug heap - // pointers because they are offset - // debugAssert(_CrtIsValidPointer(truePtr, totalBytes, TRUE) ); + // pointers because they are offset + // debugAssert(_CrtIsValidPointer((void*)truePtr, totalBytes, TRUE) ); #endif // The return pointer will be the next aligned location (we must at least // leave space for the redirect pointer, however). - char* alignedPtr = ((char*)truePtr)+ sizeof(intptr_t); + size_t alignedPtr = truePtr + sizeof(void*); -#if 0 // 2^n - 1 has the form 1111... in binary. uint32 bitMask = (alignment - 1); // Advance forward until we reach an aligned location. - while ((((intptr_t)alignedPtr) & bitMask) != 0) { + while ((alignedPtr & bitMask) != 0) { alignedPtr += sizeof(void*); } -#else - alignedPtr += alignment - (((intptr_t)alignedPtr) & (alignment - 1)); - // assert((alignedPtr - truePtr) + bytes <= totalBytes); -#endif - debugAssert((alignedPtr - truePtr) + bytes <= totalBytes); + debugAssert(alignedPtr - truePtr + bytes <= totalBytes); // Immediately before the aligned location, write the true array location // so that we can free it correctly. - intptr_t* redirectPtr = (intptr_t*)(alignedPtr - sizeof(intptr_t)); - redirectPtr[0] = (intptr_t)truePtr; + size_t* redirectPtr = (size_t *)(alignedPtr - sizeof(void *)); + redirectPtr[0] = truePtr; - debugAssert(isValidHeapPointer(truePtr)); + debugAssert(isValidHeapPointer((void*)truePtr)); #ifdef G3D_WIN32 - debugAssert( _CrtIsValidPointer(alignedPtr, bytes, TRUE) ); + debugAssert( _CrtIsValidPointer((void*)alignedPtr, bytes, TRUE) ); #endif - return (void*)alignedPtr; + return (void *)alignedPtr; } + void System::alignedFree(void* _ptr) { if (_ptr == NULL) { return; } - char* alignedPtr = (char*)_ptr; + size_t alignedPtr = (size_t)_ptr; // Back up one word from the pointer the user passed in. // We now have a pointer to a pointer to the true start // of the memory block. - intptr_t* redirectPtr = (intptr_t*)(alignedPtr - sizeof(intptr_t)); + size_t* redirectPtr = (size_t*)(alignedPtr - sizeof(void *)); // Dereference that pointer so that ptr = true start - void* truePtr = (void*)(redirectPtr[0]); + void* truePtr = (void*)redirectPtr[0]; - debugAssert(isValidHeapPointer(truePtr)); + debugAssert(isValidHeapPointer((void*)truePtr)); System::free(truePtr); } -} // namespace +void System::setEnv(const std::string& name, const std::string& value) { + std::string cmd = name + "=" + value; +# ifdef G3D_WIN32 + _putenv(cmd.c_str()); +# else + // Many linux implementations of putenv expect char* + putenv(const_cast<char*>(cmd.c_str())); +# endif +} + + +const char* System::getEnv(const std::string& name) { + return getenv(name.c_str()); +} + + +static void var(TextOutput& t, const std::string& name, const std::string& val) { + t.writeSymbols(name,"="); + t.writeString(val); + t.writeNewline(); +} + + +static void var(TextOutput& t, const std::string& name, const bool val) { + t.writeSymbols(name, "=", val ? "Yes" : "No"); + t.writeNewline(); +} + + +static void var(TextOutput& t, const std::string& name, const int val) { + t.writeSymbols(name,"="); + t.writeNumber(val); + t.writeNewline(); +} + + +void System::describeSystem( + std::string& s) { + + TextOutput t; + describeSystem(t); + t.commitString(s); +} + +void System::describeSystem( + TextOutput& t) { + + t.writeSymbols("App", "{"); + t.writeNewline(); + t.pushIndent(); + { + var(t, "Name", System::currentProgramFilename()); + char cwd[1024]; + getcwd(cwd, 1024); + var(t, "cwd", std::string(cwd)); + } + t.popIndent(); + t.writeSymbols("}"); + t.writeNewline(); + t.writeNewline(); + + t.writeSymbols("OS", "{"); + t.writeNewline(); + t.pushIndent(); + { + var(t, "Name", System::operatingSystem()); + } + t.popIndent(); + t.writeSymbols("}"); + t.writeNewline(); + t.writeNewline(); + + t.writeSymbols("CPU", "{"); + t.writeNewline(); + t.pushIndent(); + { + var(t, "Vendor", System::cpuVendor()); + var(t, "Architecture", System::cpuArchitecture()); + var(t, "hasCPUID", System::hasCPUID()); + var(t, "hasMMX", System::hasMMX()); + var(t, "hasSSE", System::hasSSE()); + var(t, "hasSSE2", System::hasSSE2()); + var(t, "hasSSE3", System::hasSSE3()); + var(t, "has3DNow", System::has3DNow()); + var(t, "hasRDTSC", System::hasRDTSC()); + var(t, "numCores", System::numCores()); + } + t.popIndent(); + t.writeSymbols("}"); + t.writeNewline(); + t.writeNewline(); + + t.writeSymbols("G3D", "{"); + t.writeNewline(); + t.pushIndent(); + { + var(t, "Link version", G3D_VER); + var(t, "Compile version", System::version()); + } + t.popIndent(); + t.writeSymbols("}"); + t.writeNewline(); + t.writeNewline(); +} + + +void System::setClipboardText(const std::string& s) { +# ifdef G3D_WIN32 + if (OpenClipboard(NULL)) { + HGLOBAL hMem = GlobalAlloc(GHND | GMEM_DDESHARE, s.size() + 1); + if (hMem) { + char *pMem = (char*)GlobalLock(hMem); + strcpy(pMem, s.c_str()); + GlobalUnlock(hMem); + + EmptyClipboard(); + SetClipboardData(CF_TEXT, hMem); + } + + CloseClipboard(); + GlobalFree(hMem); + } +# endif +} + + +std::string System::getClipboardText() { + std::string s; + +# ifdef G3D_WIN32 + if (OpenClipboard(NULL)) { + HANDLE h = GetClipboardData(CF_TEXT); + + if (h) { + char* temp = (char*)GlobalLock(h); + if (temp) { + s = temp; + } + temp = NULL; + GlobalUnlock(h); + } + CloseClipboard(); + } +# endif + return s; +} + + +std::string System::currentDateString() { + time_t t1; + ::time(&t1); + tm* t = localtime(&t1); + return format("%d-%02d-%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday); +} + +#ifdef _MSC_VER + +// VC on Intel +void System::cpuid(CPUIDFunction func, uint32& areg, uint32& breg, uint32& creg, uint32& dreg) { +#if !defined(G3D_64BIT) + // Can't copy from assembler direct to a function argument (which is on the stack) in VC. + uint32 a,b,c,d; + + // Intel assembler syntax + __asm { + mov eax, func // eax <- func + mov ecx, 0 + cpuid + mov a, eax + mov b, ebx + mov c, ecx + mov d, edx + } + areg = a; + breg = b; + creg = c; + dreg = d; +#else + int CPUInfo[4]; + __cpuid(CPUInfo, func); + memcpy(&areg, &CPUInfo[0], 4); + memcpy(&breg, &CPUInfo[1], 4); + memcpy(&creg, &CPUInfo[2], 4); + memcpy(&dreg, &CPUInfo[3], 4); +#endif +} + +#elif defined(G3D_OSX) && ! defined(G3D_OSX_INTEL) + +// non-intel OS X; no CPUID +void System::cpuid(CPUIDFunction func, uint32& eax, uint32& ebx, uint32& ecx, uint32& edx) { + eax = 0; + ebx = 0; + ecx = 0; + edx = 0; +} + +#else + +// See http://sam.zoy.org/blog/2007-04-13-shlib-with-non-pic-code-have-inline-assembly-and-pic-mix-well +// for a discussion of why the second version saves ebx; it allows 32-bit code to compile with the -fPIC option. +// On 64-bit x86, PIC code has a dedicated rip register for PIC so there is no ebx conflict. +void System::cpuid(CPUIDFunction func, uint32& eax, uint32& ebx, uint32& ecx, uint32& edx) { +#if ! defined(__PIC__) || defined(__x86_64__) + // AT&T assembler syntax + asm volatile( + "movl $0, %%ecx \n\n" /* Wipe ecx */ + "cpuid \n\t" + : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx) + : "a"(func)); +#else + // AT&T assembler syntax + asm volatile( + "pushl %%ebx \n\t" /* save ebx */ + "movl $0, %%ecx \n\n" /* Wipe ecx */ + "cpuid \n\t" + "movl %%ebx, %1 \n\t" /* save what cpuid just put in %ebx */ + "popl %%ebx \n\t" /* restore the old ebx */ + : "=a"(eax), "=r"(ebx), "=c"(ecx), "=d"(edx) + : "a"(func)); +#endif +} + +#endif + +} // namespace diff --git a/dep/src/g3dlite/TextInput.cpp b/dep/src/g3dlite/TextInput.cpp new file mode 100644 index 00000000000..7276d8c66b2 --- /dev/null +++ b/dep/src/g3dlite/TextInput.cpp @@ -0,0 +1,1136 @@ +/** + @file TextInput.cpp + + @author Morgan McGuire, graphics3d.com + + @cite Based on a lexer written by Aaron Orenstein. + + @created 2001-11-27 + @edited 2008-07-14 + */ + +#include "G3D/fileutils.h" +#include "G3D/TextInput.h" +#include "G3D/BinaryInput.h" +#include "G3D/stringutils.h" + +#ifdef _MSC_VER +# pragma warning (push) +// conversion from 'int' to 'char', possible loss of data (TODO: fix underlying problems) +# pragma warning (disable: 4244) +#endif + +namespace G3D { + +Token TextInput::readSignificant() { + Token t; + do { + t = read(); + } while ((t.type() == Token::COMMENT) || (t.type() == Token::NEWLINE)); + return t; +} + + +double Token::number() const { + if (_type == NUMBER) { + std::string s = toLower(_string); + if (s == "-1.#ind00") { + return nan(); + } + + if (s == "1.#inf00") { + return inf(); + } + + if (s == "-1.#inf00") { + return -inf(); + } + + double n; + if ((_string.length() > 2) && + (_string[0] == '0') && + (_string[1] == 'x')) { + // Hex + uint32 i; + sscanf(_string.c_str(), "%x", &i); + n = i; + } else { + sscanf(_string.c_str(), "%lg", &n); + } + return n; + } else { + return 0.0; + } +} + + +TextInput::Settings::Settings () : + cppBlockComments(true), + cppLineComments(true), + otherLineComments(true), + escapeSequencesInStrings(true), + otherCommentCharacter('\0'), + otherCommentCharacter2('\0'), + generateCommentTokens(false), + generateNewlineTokens(false), + signedNumbers(true), + singleQuotedStrings(true), + singleQuoteCharacter('\''), + sourceFileName(), + startingLineNumberOffset(0), + msvcSpecials(true), + proofSymbols(false), + caseSensitive(true) +{ + trueSymbols.insert("true"); + falseSymbols.insert("false"); +} + + +Token TextInput::peek() { + if (stack.size() == 0) { + Token t = nextToken(); + push(t); + } + + return stack.front(); +} + + +int TextInput::peekLineNumber() { + return peek().line(); +} + + +int TextInput::peekCharacterNumber() { + return peek().character(); +} + + +Token TextInput::read() { + if (stack.size() > 0) { + Token t = stack.front(); + stack.pop_front(); + return t; + } else { + return nextToken(); + } +} + +static void toUpper(Set<std::string>& set) { + Array<std::string> symbols; + set.getMembers(symbols); + set.clear(); + for (int i = 0; i < symbols.size(); ++i) { + set.insert(toUpper(symbols[i])); + } +} + +void TextInput::init() { + currentCharOffset = 0; + charNumber = 1; + lineNumber = 1 + options.startingLineNumberOffset; + + if (! options.caseSensitive) { + // Convert true and false symbols to all uppercase for fast comparisons + toUpper(options.trueSymbols); + toUpper(options.falseSymbols); + } +} + + +void TextInput::push(const Token& t) { + stack.push_front(t); +} + + +bool TextInput::hasMore() { + return (peek()._type != Token::END); +} + + +int TextInput::eatInputChar() { + // Don't go off the end + if (currentCharOffset >= buffer.length()) { + return EOF; + } + + unsigned char c = buffer[currentCharOffset]; + ++currentCharOffset; + + // update lineNumber and charNumber to reflect the location of the *next* + // character which will be read. + + // increment line number for \r, \n and \r\n which matches Token::NEWLINE parsing + if (c == '\r') { + ++lineNumber; + charNumber = 1; + + // check for \r\n + if (currentCharOffset < buffer.length()) { + unsigned char c2 = buffer[currentCharOffset]; + if (c2 == '\n') { + c = c2; + ++currentCharOffset; + } + } + } else if (c == '\n') { + ++lineNumber; + charNumber = 1; + } else { + ++charNumber; + } + + return c; +} + +int TextInput::peekInputChar(int distance) { + // Don't go off the end + if ((currentCharOffset + distance) >= buffer.length()) { + return EOF; + } + + unsigned char c = buffer[currentCharOffset + distance]; + return c; +} + + +Token TextInput::nextToken() { + Token t; + + t._line = lineNumber; + t._character = charNumber; + t._type = Token::END; + t._extendedType = Token::END_TYPE; + + int c = peekInputChar(); + if (c == EOF) { + return t; + } + + // loop through white space, newlines and comments + // found before other tokens + bool whitespaceDone = false; + while (! whitespaceDone) { + whitespaceDone = true; + + // generate newlines tokens for '\n' and '\r' and '\r\n' + if (options.generateNewlineTokens && isNewline(c)) { + t._type = Token::NEWLINE; + t._extendedType = Token::NEWLINE_TYPE; + t._string = c; + + int c2 = peekInputChar(1); + if (c == '\r' && c2 == '\n') { + t._string += c2; + } + + eatInputChar(); + return t; + } else { + // Consume whitespace + while (isWhiteSpace(c)) { + c = eatAndPeekInputChar(); + } + } + + // update line and character number to include discarded whitespace + t._line = lineNumber; + t._character = charNumber; + + int c2 = peekInputChar(1); + + // parse comments and generate tokens if enabled + std::string commentString; + + // check for line comments first + bool isLineComment = false; + if (options.cppLineComments && (c == '/' && c2 == '/')) { + // set start of line comment and eat markers + isLineComment = true; + eatInputChar(); + eatInputChar(); + } else if ( options.otherCommentCharacter && + (options.otherCommentCharacter != '\0' && c == options.otherCommentCharacter) ) { + // set start of line comment and eat markers + isLineComment = true; + eatInputChar(); + } else if ( options.otherCommentCharacter && + (options.otherCommentCharacter2 != '\0' && c == options.otherCommentCharacter2) ) { + // set start of line comment and eat markers + isLineComment = true; + eatInputChar(); + } + + if (isLineComment) { + + // consume line comment to newline or EOF + c = peekInputChar(); + while (! isNewline(c) && c != EOF) { + // build comment string for token + commentString += c; + + c = eatAndPeekInputChar(); + } + + if (options.generateCommentTokens) { + t._type = Token::COMMENT; + t._extendedType = Token::LINE_COMMENT_TYPE; + t._string = commentString; + return t; + } else { + // There is whitespace after the comment (in particular, the + // newline that terminates the comment). There might also be + // whitespace at the start of the next line. + whitespaceDone = false; + } + + } else if (options.cppBlockComments && (c == '/' && c2 == '*')) { + // consume block comment to end-marker or EOF + + // consume both start-comment chars, can't let the trailing one + // help close the comment. + eatInputChar(); + eatInputChar(); + + c = peekInputChar(); + c2 = peekInputChar(1); + while (! ((c == '*') && (c2 == '/')) && (c != EOF)) { + commentString += c; + + eatInputChar(); + c = c2; + c2 = peekInputChar(1); + } + eatInputChar(); // eat closing '*' + eatInputChar(); // eat closing '/' + + c = peekInputChar(); + + if (options.generateCommentTokens) { + t._type = Token::COMMENT; + t._extendedType = Token::BLOCK_COMMENT_TYPE; + t._string = commentString; + return t; + } else { + // There is whitespace after the comment (in particular, the + // newline that terminates the comment). There might also be + // whitespace at the start of the next line. + whitespaceDone = false; + } + } + + } // while (! whitespaceDone) + + t._line = lineNumber; + t._character = charNumber; + + // handle EOF + if (c == EOF) { + return t; + } + + // Extended ASCII parses as itself, except for EOF + if (c > 127 && c < 255) { + t._type = Token::SYMBOL; + t._extendedType = Token::SYMBOL_TYPE; + t._string = c; + c = eatAndPeekInputChar(); + } + + + // Perform appropriate setup for a symbol (including setting up the token + // string to start with c), eat the input character, and overwrite + // 'c' with the peeked next input character. +#define SETUP_SYMBOL(c) \ + { \ + t._type = Token::SYMBOL; \ + t._extendedType = Token::SYMBOL_TYPE; \ + t._string = c; \ + c = eatAndPeekInputChar(); \ + } + + switch (c) { + + case '@': // Simple symbols -> just themselves. + case '(': + case ')': + case ',': + case ';': + case '{': + case '}': + case '[': + case ']': + case '#': + case '$': + case '?': + case '%': + SETUP_SYMBOL(c); + return t; + + case '-': // negative number, -, --, -=, or -> + SETUP_SYMBOL(c); + + switch (c) { + case '>': // -> + case '-': // -- + case '=': // -= + t._string += c; + eatInputChar(); + return t; + } + + if (options.signedNumbers + && (isDigit(c) || (c == '.' && isDigit(peekInputChar(1))))) { + + // Negative number. 'c' is still the first digit, and is + // the next input char. + + goto numLabel; + } + + // plain - + return t; + + case '+': // positive number, +, ++, or += + SETUP_SYMBOL(c); + + switch (c) { + case '+': // ++ + case '=': // += + t._string += c; + eatInputChar(); + return t; + } + + if (options.signedNumbers + && (isDigit(c) || (c == '.' && isDigit(peekInputChar(1))))) { + + // Positive number. 'c' is still the first digit, and is + // the next input char. + + goto numLabel; + } + + return t; + + case ':': // : or :: or ::> or ::= or := or :> + SETUP_SYMBOL(c); + + if (c == ':') { + t._string += c; + eatInputChar(); + + if (options.proofSymbols) { + c = peekInputChar(0); + + if ((c == '>') || (c == '=')) { + t._string += c; + eatInputChar(); + } + } + } + else if (options.proofSymbols && (c == '=' || c == '>')) { + t._string += c; + eatInputChar(); + } + return t; + + case '=': // = or == or => + SETUP_SYMBOL(c); + + if (c == '=') { + t._string += c; + eatInputChar(); + return t; + } else if (options.proofSymbols && (c == '>')) { + t._string += c; + eatInputChar(); + return t; + } + return t; + + case '*': // * or *= + case '/': // / or /= + case '!': // ! or != + case '~': // ~ or ~= + case '^': // ^ or ^= + SETUP_SYMBOL(c); + + if (c == '=') { + t._string += c; + eatInputChar(); + return t; + } + return t; + + case '>': // >, >>,or >= + case '<': // <<, <<, or <= or <- or <: + case '|': // ||, ||, or |= or |- + case '&': // &, &&, or &= + { + int orig_c = c; + SETUP_SYMBOL(c); + + if ((c == '=') || (orig_c == c)) { + t._string += c; + eatInputChar(); + return t; + } else if (options.proofSymbols) { + if ((orig_c == '<') && (c == '-')) { + t._string += c; + eatInputChar(); + } else if ((orig_c == '|') && (c == '-')) { + t._string += c; + eatInputChar(); + } else if ((orig_c == '<') && (c == ':')) { + t._string += c; + + c = eatAndPeekInputChar(); + + if (c == ':') { + t._string += c; + eatInputChar(); + } + } + } + } + return t; + + case '\\': // backslash or escaped comment char. + SETUP_SYMBOL(c); + + if ((options.otherCommentCharacter != '\0' + && c == options.otherCommentCharacter) + || (options.otherCommentCharacter2 != '\0' + && c == options.otherCommentCharacter2)) { + + // escaped comment character. Return the raw comment + // char (no backslash). + + t._string = c; + eatInputChar(); + return t; + } + return t; + + case '.': // number, ., .., or ... + if (isDigit(peekInputChar(1))) { + // We're parsing a float that began without a leading zero + goto numLabel; + } + + SETUP_SYMBOL(c); + + if (c == '.') { // .. or ... + t._string += c; + c = eatAndPeekInputChar(); + + if (c == '.') { // ... + t._string += c; + eatInputChar(); + } + return t; + } + + return t; + + } // switch (c) + +#undef SETUP_SYMBOL + +numLabel: + if (isDigit(c) || (c == '.')) { + + // A number. Note-- single dots have been + // parsed already, so a . indicates a number + // less than 1 in floating point form. + + // [0-9]*(\.[0-9][f]) or [0-9]+ or 0x[0-9,A-F]+ + + if (t._string != "-") { + // If we picked up a leading "-" sign above, keep it, + // otherwise drop the string parsed thus far + t._string = ""; + } + t._type = Token::NUMBER; + if (c == '.') { + t._extendedType = Token::FLOATING_POINT_TYPE; + } else { + t._extendedType = Token::INTEGER_TYPE; + } + + if ((c == '0') && (peekInputChar(1) == 'x')) { + // Hex number + t._string += "0x"; + + // skip the 0x + eatInputChar(); + eatInputChar(); + + c = peekInputChar(); + while (isDigit(c) || ((c >= 'A') && (c <= 'F')) || ((c >= 'a') && (c <= 'f'))) { + t._string += c; + c = eatAndPeekInputChar(); + } + + } else { + // Non-hex number + + // Read the part before the decimal. + while (isDigit(c)) { + t._string += c; + c = eatAndPeekInputChar(); + } + + // True if we are reading a floating-point special type + bool isSpecial = false; + + // Read the decimal, if one exists + if (c == '.') { + t._extendedType = Token::FLOATING_POINT_TYPE; + + // The '.' character was a decimal point, not the start of a + // method or range operator + t._string += c; + c = eatAndPeekInputChar(); + + // Floating point specials (msvc format only) + if (options.msvcSpecials && (c == '#')) { + isSpecial = true; + // We are reading a floating point special value + // of the form -1.#IND00, -1.#INF00, or 1.#INF00 + c = eatAndPeekInputChar(); + char test = c; + if (! options.caseSensitive) { + test = toupper(c); + } + if (test != 'I') { + throw BadMSVCSpecial + ( + "Incorrect floating-point special (inf or nan) " + "format.", + t.line(), charNumber); + } + c = eatAndPeekInputChar(); + test = c; + if (! options.caseSensitive) { + test = toupper(c); + } + if (test != 'N') { + throw BadMSVCSpecial + ( + "Incorrect floating-point special (inf or nan) " + "format.", + t.line(), charNumber); + } + t._string += "#IN"; + c = eatAndPeekInputChar(); + test = c; + if (! options.caseSensitive) { + test = toupper(c); + } + if ((test != 'F') && (test != 'D')) { + throw BadMSVCSpecial + ( + "Incorrect floating-point special (inf or nan) " + "format.", + t.line(), charNumber); + } + t._string += c; + for (int j = 0; j < 2; ++j) { + c = eatAndPeekInputChar(); + if (c != '0') { + throw BadMSVCSpecial + ( + "Incorrect floating-point special (inf or" + "nan) format.", + t.line(), charNumber); + } + t._string += (char)c; + } + + } else { + + // Read the part after the decimal + while (isDigit((char)c)) { + t._string += (char)c; + c = eatAndPeekInputChar(); + } + } + } + + if (! isSpecial && ((c == 'e') || (c == 'E'))) { + // Read exponent + t._extendedType = Token::FLOATING_POINT_TYPE; + t._string += c; + + c = eatAndPeekInputChar(); + if ((c == '-') || (c == '+')) { + t._string += c; + c = eatAndPeekInputChar(); + } + + while (isDigit(c)) { + t._string += c; + c = eatAndPeekInputChar(); + } + } + + if (! isSpecial && (t._extendedType == Token::FLOATING_POINT_TYPE) && (c == 'f')) { + // Trailing f on a float + t._string += c; + c = eatAndPeekInputChar(); + } + } + return t; + + } else if (isLetter(c) || (c == '_')) { + // Identifier or keyword + // [A-Za-z_][A-Za-z_0-9]* + + t._type = Token::SYMBOL; + t._extendedType = Token::SYMBOL_TYPE; + t._string = ""; + do { + t._string += c; + c = eatAndPeekInputChar(); + } while (isLetter(c) || isDigit(c) || (c == '_')); + + // See if this symbol is actually a boolean + if ((options.trueSymbols.size() > 0) || (options.falseSymbols.size() > 0)) { + std::string str = t._string; + if (! options.caseSensitive) { + str = toUpper(str); + } + if (options.trueSymbols.contains(str)) { + t._type = Token::BOOLEAN; + t._extendedType = Token::BOOLEAN_TYPE; + t._bool = true; + } else if (options.falseSymbols.contains(str)) { + t._type = Token::BOOLEAN; + t._extendedType = Token::BOOLEAN_TYPE; + t._bool = false; + } + } + + return t; + + } else if (c == '\"') { + + // Discard the double-quote. + eatInputChar(); + + // Double quoted string + parseQuotedString('\"', t); + return t; + + } else if (c == options.singleQuoteCharacter) { + + // Discard the single-quote. + eatInputChar(); + + if (options.singleQuotedStrings) { + // Single quoted string + parseQuotedString(options.singleQuoteCharacter, t); + } else { + t._string = c; + t._type = Token::SYMBOL; + t._extendedType = Token::SYMBOL_TYPE; + } + return t; + + } // end of special case tokens + + if (c == EOF) { + t._type = Token::END; + t._extendedType = Token::END_TYPE; + t._string = ""; + return t; + } + + // Some unknown token + debugAssertM(false, + format("Unrecognized token type beginning with character '%c' (ASCII %d)", + c, c)); + return t; +} + + +void TextInput::parseQuotedString(unsigned char delimiter, Token& t) { + + t._type = Token::STRING; + + if (delimiter == options.singleQuoteCharacter) { + t._extendedType = Token::SINGLE_QUOTED_TYPE; + } else { + t._extendedType = Token::DOUBLE_QUOTED_TYPE; + } + + while (true) { + // We're definitely going to consume the next input char, so we get + // it right now. This makes the condition handling below a bit easier. + int c = eatInputChar(); + + if (c == EOF) { + // END inside a quoted string. (We finish the string.) + break; + } + + if (options.escapeSequencesInStrings && (c == '\\')) { + // An escaped character. We're definitely going to consume it, + // so we get it (and consume it) now. + + c = eatInputChar(); + + switch (c) { + case 'r': + t._string += '\r'; + break; + case 'n': + t._string += '\n'; + break; + case 't': + t._string += '\t'; + break; + case '0': + t._string += '\0'; + break; + + case '\\': + case '\"': + t._string += (char)c; + break; + + default: + if (c == options.singleQuoteCharacter) { + t._string += (char)c; + break; + } + + if (((c == options.otherCommentCharacter) && + (options.otherCommentCharacter != '\0')) || + ((c == options.otherCommentCharacter2) && + (options.otherCommentCharacter2 != '\0'))) { + t._string += c; + } + // otherwise, some illegal escape sequence; skip it. + break; + + } // switch + + } else if (c == delimiter) { + // End of the string. Already consumed the character. + break; + } else { + // All other chars, go on to the string. Already consumed the + // character. + t._string += (char)c; + } + + } +} + +bool TextInput::readBoolean() { + Token t(read()); + + if (t._type == Token::BOOLEAN) { + return t.boolean(); + } + + // Push initial token back, and throw an error. We intentionally + // indicate that the wrong type is the type of the initial token. + // Logically, the number started there. + push(t); + throw WrongTokenType(options.sourceFileName, t.line(), t.character(), + Token::BOOLEAN, t._type); +} + +double TextInput::readNumber() { + Token t(read()); + + if (t._type == Token::NUMBER) { + return t.number(); + } + + // Even if signedNumbers is disabled, readNumber attempts to + // read a signed number, so we handle that case here. + if (! options.signedNumbers + && (t._type == Token::SYMBOL) + && ((t._string == "-") + || (t._string == "+"))) { + + Token t2(read()); + + if ((t2._type == Token::NUMBER) + && (t2._character == t._character + 1)) { + + if (t._string == "-") { + return -t2.number(); + } else { + return t2.number(); + } + } + + // push back the second token. + push(t2); + } + + // Push initial token back, and throw an error. We intentionally + // indicate that the wrong type is the type of the initial token. + // Logically, the number started there. + push(t); + throw WrongTokenType(options.sourceFileName, t.line(), t.character(), + Token::NUMBER, t._type); +} + + +Token TextInput::readStringToken() { + Token t(read()); + + if (t._type == Token::STRING) { // fast path + return t; + } + + push(t); + throw WrongTokenType(options.sourceFileName, t.line(), t.character(), + Token::STRING, t._type); +} + +std::string TextInput::readString() { + return readStringToken()._string; +} + +void TextInput::readString(const std::string& s) { + Token t(readStringToken()); + + if (t._string == s) { // fast path + return; + } + + push(t); + throw WrongString(options.sourceFileName, t.line(), t.character(), + s, t._string); +} + +Token TextInput::readCommentToken() { + Token t(read()); + + if (t._type == Token::COMMENT) { // fast path + return t; + } + + push(t); + throw WrongTokenType(options.sourceFileName, t.line(), t.character(), + Token::COMMENT, t._type); +} + +std::string TextInput::readComment() { + return readCommentToken()._string; +} + +void TextInput::readComment(const std::string& s) { + Token t(readCommentToken()); + + if (t._string == s) { // fast path + return; + } + + push(t); + throw WrongString(options.sourceFileName, t.line(), t.character(), + s, t._string); +} + +Token TextInput::readNewlineToken() { + Token t(read()); + + if (t._type == Token::NEWLINE) { // fast path + return t; + } + + push(t); + throw WrongTokenType(options.sourceFileName, t.line(), t.character(), + Token::NEWLINE, t._type); +} + +std::string TextInput::readNewline() { + return readNewlineToken()._string; +} + +void TextInput::readNewline(const std::string& s) { + Token t(readNewlineToken()); + + if (t._string == s) { // fast path + return; + } + + push(t); + throw WrongString(options.sourceFileName, t.line(), t.character(), + s, t._string); +} + +Token TextInput::readSymbolToken() { + Token t(read()); + + if (t._type == Token::SYMBOL) { // fast path + return t; + } + + push(t); + throw WrongTokenType(options.sourceFileName, t.line(), t.character(), + Token::SYMBOL, t._type); +} + + +std::string TextInput::readSymbol() { + return readSymbolToken()._string; +} + +void TextInput::readSymbol(const std::string& symbol) { + Token t(readSymbolToken()); + + if (t._string == symbol) { // fast path + return; + } + + push(t); + throw WrongSymbol(options.sourceFileName, t.line(), t.character(), + symbol, t._string); +} + + +TextInput::TextInput(const std::string& filename, const Settings& opt) : options(opt) { + init(); + std::string input = readWholeFile(filename); + + if (options.sourceFileName.empty()) { + options.sourceFileName = filename; + } + int n = input.size(); + buffer.resize(n); + System::memcpy(buffer.getCArray(), input.c_str(), n); +} + + +TextInput::TextInput(FS fs, const std::string& str, const Settings& opt) : options(opt) { + (void)fs; + init(); + if (options.sourceFileName.empty()) { + if (str.length() < 14) { + options.sourceFileName = std::string("\"") + str + "\""; + } else { + options.sourceFileName = std::string("\"") + str.substr(0, 10) + "...\""; + } + } + buffer.resize(str.length()); // we don't bother copying trailing NUL. + System::memcpy(buffer.getCArray(), str.c_str(), buffer.size()); +} + + +const std::string& TextInput::filename() const { + return options.sourceFileName; +} + +/////////////////////////////////////////////////////////////////////////////////// + +TextInput::TokenException::TokenException( + const std::string& src, + int ln, + int ch) : ParseError(src, ln, ch, format("%s(%d) : ", src.c_str(), ln)), + sourceFile(src) { +} + +/////////////////////////////////////////////////////////////////////////////////// + +static const char* tokenTypeToString(Token::Type t) { + switch (t) { + case Token::SYMBOL: + return "Token::SYMBOL"; + case Token::STRING: + return "Token::STRING"; + case Token::NUMBER: + return "Token::NUMBER"; + case Token::END: + return "Token::END"; + default: + debugAssertM(false, "Fell through switch"); + return "?"; + } +} + +TextInput::WrongTokenType::WrongTokenType( + const std::string& src, + int ln, + int ch, + Token::Type e, + Token::Type a) : + TokenException(src, ln, ch), expected(e), actual(a) { + + message += format("Expected token of type %s, found type %s.", + tokenTypeToString(e), tokenTypeToString(a)); +} + + +TextInput::BadMSVCSpecial::BadMSVCSpecial( + const std::string& src, + int ln, + int ch) : + TokenException(src, ln, ch) { +} + + +TextInput::WrongSymbol::WrongSymbol( + const std::string& src, + int ln, + int ch, + const std::string& e, + const std::string& a) : + TokenException(src, ln, ch), expected(e), actual(a) { + + message += format("Expected symbol '%s', found symbol '%s'.", + e.c_str(), a.c_str()); +} + + +TextInput::WrongString::WrongString( + const std::string& src, + int ln, + int ch, + const std::string& e, + const std::string& a) : + TokenException(src, ln, ch), expected(e), actual(a) { + + message += format("Expected string '%s', found string '%s'.", + e.c_str(), a.c_str()); +} + + +void deserialize(bool& b, TextInput& ti) { + b = ti.readSymbol() == "true"; +} + + +void deserialize(int& b, TextInput& ti) { + b = iRound(ti.readNumber()); +} + + +void deserialize(uint8& b, TextInput& ti) { + b = (uint8)iRound(ti.readNumber()); +} + + +void deserialize(double& b, TextInput& ti) { + b = ti.readNumber(); +} + + +void deserialize(float& b, TextInput& ti) { + b = (float)ti.readNumber(); +} + +} // namespace + +#ifdef _MSC_VER +# pragma warning (pop) +#endif diff --git a/dep/src/g3dlite/TextOutput.cpp b/dep/src/g3dlite/TextOutput.cpp new file mode 100644 index 00000000000..11347252eba --- /dev/null +++ b/dep/src/g3dlite/TextOutput.cpp @@ -0,0 +1,452 @@ +/** + @file TextOutput.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2004-06-21 + @edited 2006-08-14 + + Copyright 2000-2006, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/TextOutput.h" +#include "G3D/Log.h" +#include "G3D/fileutils.h" + +namespace G3D { + +TextOutput::TextOutput(const TextOutput::Settings& opt) : + startingNewLine(true), + currentColumn(0), + inDQuote(false), + filename(""), + indentLevel(0) +{ + setOptions(opt); +} + + +TextOutput::TextOutput(const std::string& fil, const TextOutput::Settings& opt) : + startingNewLine(true), + currentColumn(0), + inDQuote(false), + filename(fil), + indentLevel(0) +{ + + setOptions(opt); +} + + +void TextOutput::setIndentLevel(int i) { + indentLevel = i; + + // If there were more pops than pushes, don't let that take us below 0 indent. + // Don't ever indent more than the number of columns. + indentSpaces = + iClamp(option.spacesPerIndent * indentLevel, + 0, + option.numColumns - 1); +} + + +void TextOutput::setOptions(const Settings& _opt) { + option = _opt; + + debugAssert(option.numColumns > 1); + + setIndentLevel(indentLevel); + + newline = (option.newlineStyle == Settings::NEWLINE_WINDOWS) ? "\r\n" : "\n"; +} + + +void TextOutput::pushIndent() { + setIndentLevel(indentLevel + 1); +} + + +void TextOutput::popIndent() { + setIndentLevel(indentLevel - 1); +} + + +static std::string escape(const std::string& string) { + std::string result = ""; + + for (std::string::size_type i = 0; i < string.length(); ++i) { + char c = string.at(i); + switch (c) { + case '\0': + result += "\\0"; + break; + + case '\r': + result += "\\r"; + break; + + case '\n': + result += "\\n"; + break; + + case '\t': + result += "\\t"; + break; + + case '\\': + result += "\\\\"; + break; + + default: + result += c; + } + } + + return result; +} + +void TextOutput::writeString(const std::string& string) { + // Convert special characters to escape sequences + this->printf("\"%s\"", escape(string).c_str()); +} + + +void TextOutput::writeBoolean(bool b) { + this->printf("%s ", b ? option.trueSymbol.c_str() : option.falseSymbol.c_str()); +} + +void TextOutput::writeNumber(double n) { + this->printf("%f ", n); +} + + +void TextOutput::writeNumber(int n) { + this->printf("%d ", n); +} + + +void TextOutput::writeSymbol(const std::string& string) { + if (string.size() > 0) { + // TODO: check for legal symbols? + this->printf("%s ", string.c_str()); + } +} + +void TextOutput::writeSymbols( + const std::string& a, + const std::string& b, + const std::string& c, + const std::string& d, + const std::string& e, + const std::string& f) { + + writeSymbol(a); + writeSymbol(b); + writeSymbol(c); + writeSymbol(d); + writeSymbol(e); + writeSymbol(f); +} + + +void TextOutput::printf(const std::string formatString, ...) { + va_list argList; + va_start(argList, formatString); + this->vprintf(formatString.c_str(), argList); + va_end(argList); +} + + +void TextOutput::printf(const char* formatString, ...) { + va_list argList; + va_start(argList, formatString); + this->vprintf(formatString, argList); + va_end(argList); +} + + +void TextOutput::convertNewlines(const std::string& in, std::string& out) { + // TODO: can be significantly optimized in cases where + // single characters are copied in order by walking through + // the array and copying substrings as needed. + + if (option.convertNewlines) { + out = ""; + for (uint32 i = 0; i < in.size(); ++i) { + if (in[i] == '\n') { + // Unix newline + out += newline; + } else if ((in[i] == '\r') && (i + 1 < in.size()) && (in[i + 1] == '\n')) { + // Windows newline + out += newline; + ++i; + } else { + out += in[i]; + } + } + } else { + out = in; + } +} + + +void TextOutput::writeNewline() { + for (uint32 i = 0; i < newline.size(); ++i) { + indentAppend(newline[i]); + } +} + + +void TextOutput::writeNewlines(int numLines) { + for (int i = 0; i < numLines; ++i) { + writeNewline(); + } +} + + +void TextOutput::wordWrapIndentAppend(const std::string& str) { + // TODO: keep track of the last space character we saw so we don't + // have to always search. + + if ((option.wordWrap == Settings::WRAP_NONE) || + (currentColumn + (int)str.size() <= option.numColumns)) { + // No word-wrapping is needed + + // Add one character at a time. + // TODO: optimize for strings without newlines to add multiple + // characters. + for (uint32 i = 0; i < str.size(); ++i) { + indentAppend(str[i]); + } + return; + } + + // Number of columns to wrap against + int cols = option.numColumns - indentSpaces; + + // Copy forward until we exceed the column size, + // and then back up and try to insert newlines as needed. + for (uint32 i = 0; i < str.size(); ++i) { + + indentAppend(str[i]); + if ((str[i] == '\r') && (i + 1 < str.size()) && (str[i + 1] == '\n')) { + // \r\n, we need to hit the \n to enter word wrapping. + ++i; + indentAppend(str[i]); + } + + if (currentColumn >= cols) { + debugAssertM(str[i] != '\n' && str[i] != '\r', + "Should never enter word-wrapping on a newline character"); + + // True when we're allowed to treat a space as a space. + bool unquotedSpace = option.allowWordWrapInsideDoubleQuotes || ! inDQuote; + + // Cases: + // + // 1. Currently in a series of spaces that ends with a newline + // strip all spaces and let the newline + // flow through. + // + // 2. Currently in a series of spaces that does not end with a newline + // strip all spaces and replace them with single newline + // + // 3. Not in a series of spaces + // search backwards for a space, then execute case 2. + + // Index of most recent space + uint32 lastSpace = data.size() - 1; + + // How far back we had to look for a space + uint32 k = 0; + uint32 maxLookBackward = currentColumn - indentSpaces; + + // Search backwards (from current character), looking for a space. + while ((k < maxLookBackward) && + (lastSpace > 0) && + (! ((data[lastSpace] == ' ') && unquotedSpace))) { + --lastSpace; + ++k; + + if ((data[lastSpace] == '\"') && !option.allowWordWrapInsideDoubleQuotes) { + unquotedSpace = ! unquotedSpace; + } + } + + if (k == maxLookBackward) { + // We couldn't find a series of spaces + + if (option.wordWrap == Settings::WRAP_ALWAYS) { + // Strip the last character we wrote, force a newline, + // and replace the last character; + data.pop(); + writeNewline(); + indentAppend(str[i]); + } else { + // Must be Settings::WRAP_WITHOUT_BREAKING + // + // Don't write the newline; we'll come back to + // the word wrap code after writing another character + } + } else { + // We found a series of spaces. If they continue + // to the new string, strip spaces off both. Otherwise + // strip spaces from data only and insert a newline. + + // Find the start of the spaces. firstSpace is the index of the + // first non-space, looking backwards from lastSpace. + uint32 firstSpace = lastSpace; + while ((k < maxLookBackward) && + (firstSpace > 0) && + (data[firstSpace] == ' ')) { + --firstSpace; + ++k; + } + + if (k == maxLookBackward) { + ++firstSpace; + } + + if (lastSpace == (uint32)data.size() - 1) { + // Spaces continued up to the new string + data.resize(firstSpace + 1); + writeNewline(); + + // Delete the spaces from the new string + while ((i < str.size() - 1) && (str[i + 1] == ' ')) { + ++i; + } + } else { + // Spaces were somewhere in the middle of the old string. + // replace them with a newline. + + // Copy over the characters that should be saved + Array<char> temp; + for (uint32 j = lastSpace + 1; j < (uint32)data.size(); ++j) { + char c = data[j]; + + if (c == '\"') { + // Undo changes to quoting (they will be re-done + // when we paste these characters back on). + inDQuote = !inDQuote; + } + temp.append(c); + } + + // Remove those characters and replace with a newline. + data.resize(firstSpace + 1); + writeNewline(); + + // Write them back + for (uint32 j = 0; j < (uint32)temp.size(); ++j) { + indentAppend(temp[j]); + } + + // We are now free to continue adding from the + // new string, which may or may not begin with spaces. + + } // if spaces included new string + } // if hit indent + } // if line exceeded + } // iterate over str +} + + +void TextOutput::indentAppend(char c) { + + if (startingNewLine) { + for (int j = 0; j < indentSpaces; ++j) { + data.push(' '); + } + startingNewLine = false; + currentColumn = indentSpaces; + } + + data.push(c); + + // Don't increment the column count on return character + // newline is taken care of below. + if (c != '\r') { + ++currentColumn; + } + + if (c == '\"') { + inDQuote = ! inDQuote; + } + + startingNewLine = (c == '\n'); + if (startingNewLine) { + currentColumn = 0; + } +} + + +void TextOutput::vprintf(const char* formatString, va_list argPtr) { + std::string str = vformat(formatString, argPtr); + + std::string clean; + convertNewlines(str, clean); + wordWrapIndentAppend(clean); +} + + +void TextOutput::commit(bool flush) { + std::string p = filenamePath(filename); + if (! fileExists(p, false)) { + createDirectory(p); + } + + FILE* f = fopen(filename.c_str(), "wb"); + debugAssertM(f, "Could not open \"" + filename + "\""); + fwrite(data.getCArray(), 1, data.size(), f); + if (flush) { + fflush(f); + } + fclose(f); +} + + +void TextOutput::commitString(std::string& out) { + // Null terminate + data.push('\0'); + out = data.getCArray(); + data.pop(); +} + + +std::string TextOutput::commitString() { + std::string str; + commitString(str); + return str; +} + + + +///////////////////////////////////////////////////////////////////// + +void serialize(const float& b, TextOutput& to) { + to.writeNumber(b); +} + + +void serialize(const bool& b, TextOutput& to) { + to.writeSymbol(b ? "true" : "false"); +} + + +void serialize(const int& b, TextOutput& to) { + to.writeNumber(b); +} + + +void serialize(const uint8& b, TextOutput& to) { + to.writeNumber(b); +} + + +void serialize(const double& b, TextOutput& to) { + to.writeNumber(b); +} + + +} diff --git a/dep/src/g3dlite/ThreadSet.cpp b/dep/src/g3dlite/ThreadSet.cpp new file mode 100644 index 00000000000..ee3895fe9de --- /dev/null +++ b/dep/src/g3dlite/ThreadSet.cpp @@ -0,0 +1,166 @@ +#include "G3D/ThreadSet.h" + +namespace G3D { + +int ThreadSet::size() const { + ThreadSet* me = const_cast<ThreadSet*>(this); + me->m_lock.lock(); + int s = m_thread.size(); + me->m_lock.unlock(); + return s; +} + + +int ThreadSet::numStarted() const { + ThreadSet* me = const_cast<ThreadSet*>(this); + me->m_lock.lock(); + int count = 0; + for (int i = 0; i < m_thread.size(); ++i) { + if (m_thread[i]->started()) { + ++count; + } + } + me->m_lock.unlock(); + return count; +} + + +void ThreadSet::start(GThread::SpawnBehavior lastBehavior) const { + ThreadSet* me = const_cast<ThreadSet*>(this); + + Array<GThreadRef> unstarted; + me->m_lock.lock(); + // Find the unstarted threads + for (int i = 0; i < m_thread.size(); ++i) { + if (! m_thread[i]->started()) { + unstarted.append(m_thread[i]); + } + } + + int last = unstarted.size(); + if (lastBehavior == GThread::USE_CURRENT_THREAD) { + // Save the last unstarted for the current thread + --last; + } + + for (int i = 0; i < last; ++i) { + unstarted[i]->start(GThread::USE_NEW_THREAD); + } + + me->m_lock.unlock(); + + // Start the last one on my thread + if ((unstarted.size() > 0) && (lastBehavior == GThread::USE_CURRENT_THREAD)) { + unstarted.last()->start(GThread::USE_CURRENT_THREAD); + } +} + + +void ThreadSet::terminate() const { + ThreadSet* me = const_cast<ThreadSet*>(this); + me->m_lock.lock(); + for (int i = 0; i < m_thread.size(); ++i) { + if (m_thread[i]->started()) { + m_thread[i]->terminate(); + } + } + me->m_lock.unlock(); +} + + +void ThreadSet::waitForCompletion() const { + ThreadSet* me = const_cast<ThreadSet*>(this); + me->m_lock.lock(); + for (int i = 0; i < m_thread.size(); ++i) { + if (m_thread[i]->started()) { + m_thread[i]->waitForCompletion(); + } + } + me->m_lock.unlock(); +} + + +int ThreadSet::removeCompleted() { + m_lock.lock(); + for (int i = 0; i < m_thread.size(); ++i) { + if (m_thread[i]->completed()) { + m_thread.fastRemove(i); + --i; + } + } + + int s = m_thread.size(); + m_lock.unlock(); + return s; +} + + +void ThreadSet::clear() { + m_lock.lock(); + m_thread.clear(); + m_lock.unlock(); +} + + +int ThreadSet::insert(const ThreadRef& t) { + m_lock.lock(); + bool found = false; + for (int i = 0; i < m_thread.size() && ! found; ++i) { + found = (m_thread[i] == t); + } + if (! found) { + m_thread.append(t); + } + int s = m_thread.size(); + m_lock.unlock(); + return s; +} + + +bool ThreadSet::remove(const ThreadRef& t) { + m_lock.lock(); + bool found = false; + for (int i = 0; i < m_thread.size() && ! found; ++i) { + found = (m_thread[i] == t); + if (found) { + m_thread.fastRemove(i); + } + } + m_lock.unlock(); + return found; +} + + +bool ThreadSet::contains(const ThreadRef& t) const { + ThreadSet* me = const_cast<ThreadSet*>(this); + me->m_lock.lock(); + bool found = false; + for (int i = 0; i < m_thread.size() && ! found; ++i) { + found = (m_thread[i] == t); + } + me->m_lock.unlock(); + return found; +} + + +ThreadSet::Iterator ThreadSet::begin() { + return m_thread.begin(); +} + + +ThreadSet::Iterator ThreadSet::end() { + return m_thread.end(); +} + + +ThreadSet::ConstIterator ThreadSet::begin() const { + return m_thread.begin(); +} + + +ThreadSet::ConstIterator ThreadSet::end() const { + return m_thread.end(); +} + + +} // namespace G3D diff --git a/dep/src/g3dlite/Triangle.cpp b/dep/src/g3dlite/Triangle.cpp index 2e221b12f1d..253438ad5fb 100644 --- a/dep/src/g3dlite/Triangle.cpp +++ b/dep/src/g3dlite/Triangle.cpp @@ -1,22 +1,27 @@ /** @file Triangle.cpp - - @maintainer Morgan McGuire, graphics3d.com - + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2001-04-06 - @edited 2006-01-20 + @edited 2008-12-28 - Copyright 2000-2006, Morgan McGuire. + Copyright 2000-2009, Morgan McGuire. All rights reserved. */ #include "G3D/platform.h" #include "G3D/Triangle.h" #include "G3D/Plane.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/debugAssert.h" #include "G3D/AABox.h" +#include "G3D/Ray.h" namespace G3D { + void Triangle::init(const Vector3& v0, const Vector3& v1, const Vector3& v2) { _plane = Plane(v0, v1, v2); @@ -27,8 +32,8 @@ void Triangle::init(const Vector3& v0, const Vector3& v1, const Vector3& v2) { static int next[] = {1,2,0}; for (int i = 0; i < 3; ++i) { - const Vector3 e = _vertex[next[i]] - _vertex[i]; - edgeMagnitude[i] = e.magnitude(); + const Vector3& e = _vertex[next[i]] - _vertex[i]; + edgeMagnitude[i] = e.magnitude(); if (edgeMagnitude[i] == 0) { edgeDirection[i] = Vector3::zero(); @@ -37,37 +42,64 @@ void Triangle::init(const Vector3& v0, const Vector3& v1, const Vector3& v2) { } } - edge01 = _vertex[1] - _vertex[0]; - edge02 = _vertex[2] - _vertex[0]; + _edge01 = _vertex[1] - _vertex[0]; + _edge02 = _vertex[2] - _vertex[0]; _primaryAxis = _plane.normal().primaryAxis(); - _area = (float)edgeDirection[0].cross(edgeDirection[2]).magnitude() * (edgeMagnitude[0] * edgeMagnitude[2]); - + _area = 0.5f * edgeDirection[0].cross(edgeDirection[2]).magnitude() * (edgeMagnitude[0] * edgeMagnitude[2]); + //0.5f * (_vertex[1] - _vertex[0]).cross(_vertex[2] - _vertex[0]).dot(_plane.normal()); } + Triangle::Triangle() { init(Vector3::zero(), Vector3::zero(), Vector3::zero()); } + Triangle::Triangle(const Vector3& v0, const Vector3& v1, const Vector3& v2) { init(v0, v1, v2); } + Triangle::~Triangle() { } -double Triangle::area() const { + +Triangle::Triangle(class BinaryInput& b) { + deserialize(b); +} + + +void Triangle::serialize(class BinaryOutput& b) { + _vertex[0].serialize(b); + _vertex[1].serialize(b); + _vertex[2].serialize(b); +} + + +void Triangle::deserialize(class BinaryInput& b) { + _vertex[0].deserialize(b); + _vertex[1].deserialize(b); + _vertex[2].deserialize(b); + init(_vertex[0], _vertex[1], _vertex[2]); +} + + +float Triangle::area() const { return _area; } + const Vector3& Triangle::normal() const { return _plane.normal(); } + const Plane& Triangle::plane() const { return _plane; } + Vector3 Triangle::center() const { return (_vertex[0] + _vertex[1] + _vertex[2]) / 3.0; } @@ -85,9 +117,10 @@ Vector3 Triangle::randomPoint() const { s = 1.0f - s; } - return edge01 * s + edge02 * t + _vertex[0]; + return _edge01 * s + _edge02 * t + _vertex[0]; } + void Triangle::getBounds(AABox& out) const { Vector3 lo = _vertex[0]; Vector3 hi = lo; @@ -100,5 +133,54 @@ void Triangle::getBounds(AABox& out) const { out = AABox(lo, hi); } -} // G3D +bool Triangle::intersect(const Ray& ray, float& distance, float baryCoord[3]) const { + static const float EPS = 1e-5f; + + // See RTR2 ch. 13.7 for the algorithm. + + const Vector3& e1 = edge01(); + const Vector3& e2 = edge02(); + const Vector3 p(ray.direction().cross(e2)); + const float a = e1.dot(p); + + if (abs(a) < EPS) { + // Determinant is ill-conditioned; abort early + return false; + } + + const float f = 1.0f / a; + const Vector3 s(ray.origin() - vertex(0)); + const float u = f * s.dot(p); + + if ((u < 0.0f) || (u > 1.0f)) { + // We hit the plane of the m_geometry, but outside the m_geometry + return false; + } + + const Vector3 q(s.cross(e1)); + const float v = f * ray.direction().dot(q); + + if ((v < 0.0f) || ((u + v) > 1.0f)) { + // We hit the plane of the triangle, but outside the triangle + return false; + } + + const float t = f * e2.dot(q); + + if ((t > 0.0f) && (t < distance)) { + // This is a new hit, closer than the previous one + distance = t; + + baryCoord[0] = 1.0 - u - v; + baryCoord[1] = u; + baryCoord[2] = v; + + return true; + } else { + // This hit is after the previous hit, so ignore it + return false; + } +} + +} // G3D diff --git a/dep/src/g3dlite/UprightFrame.cpp b/dep/src/g3dlite/UprightFrame.cpp new file mode 100644 index 00000000000..c80264bf4e8 --- /dev/null +++ b/dep/src/g3dlite/UprightFrame.cpp @@ -0,0 +1,132 @@ +/** + @file UprightFrame.cpp + Box class + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-05-02 + @edited 2007-05-05 +*/ + +#include "G3D/UprightFrame.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +UprightFrame::UprightFrame(const CoordinateFrame& cframe) { + Vector3 look = cframe.lookVector(); + + yaw = G3D::pi() + atan2(look.x, look.z); + pitch = asin(look.y); + + translation = cframe.translation; +} + + +CoordinateFrame UprightFrame::toCoordinateFrame() const { + CoordinateFrame cframe; + + Matrix3 P(Matrix3::fromAxisAngle(Vector3::unitX(), pitch)); + Matrix3 Y(Matrix3::fromAxisAngle(Vector3::unitY(), yaw)); + + cframe.rotation = Y * P; + cframe.translation = translation; + + return cframe; +} + + +UprightFrame UprightFrame::operator+(const UprightFrame& other) const { + return UprightFrame(translation + other.translation, pitch + other.pitch, yaw + other.yaw); +} + + +UprightFrame UprightFrame::operator*(const float k) const { + return UprightFrame(translation * k, pitch * k, yaw * k); +} + + +void UprightFrame::unwrapYaw(UprightFrame* a, int N) { + // Use the first point to establish the wrapping convention + for (int i = 1; i < N; ++i) { + const float prev = a[i - 1].yaw; + float& cur = a[i].yaw; + + // No two angles should be more than pi (i.e., 180-degrees) apart. + if (abs(cur - prev) > G3D::pi()) { + // These angles must have wrapped at zero, causing them + // to be interpolated the long way. + + // Find canonical [0, 2pi] versions of these numbers + float p = wrap(prev, twoPi()); + float c = wrap(cur, twoPi()); + + // Find the difference -pi < diff < pi between the current and previous values + float diff = c - p; + if (diff < -G3D::pi()) { + diff += twoPi(); + } else if (diff > G3D::pi()) { + diff -= twoPi(); + } + + // Offset the current from the previous by the difference + // between them. + cur = prev + diff; + } + } +} + + +void UprightFrame::serialize(class BinaryOutput& b) const { + translation.serialize(b); + b.writeFloat32(pitch); + b.writeFloat32(yaw); +} + + +void UprightFrame::deserialize(class BinaryInput& b) { + translation.deserialize(b); + pitch = b.readFloat32(); + yaw = b.readFloat32(); +} + + +void UprightSpline::serialize(class BinaryOutput& b) const { + b.writeBool8(cyclic); + + b.writeInt32(control.size()); + for (int i = 0; i < control.size(); ++i) { + control[i].serialize(b); + } + b.writeInt32(time.size()); + for (int i = 0; i < time.size(); ++i) { + b.writeFloat32(time[i]); + } +} + + +void UprightSpline::deserialize(class BinaryInput& b) { + cyclic = b.readBool8(); + + control.resize(b.readInt32()); + for (int i = 0; i < control.size(); ++i) { + control[i].deserialize(b); + } + + if (b.hasMore()) { + time.resize(b.readInt32()); + for (int i = 0; i < time.size(); ++i) { + time[i] = b.readFloat32(); + } + debugAssert(time.size() == control.size()); + } else { + // Import legacy path + time.resize(control.size()); + for (int i = 0; i < time.size(); ++i) { + time[i] = i; + } + } +} + +} diff --git a/dep/src/g3dlite/Vector2.cpp b/dep/src/g3dlite/Vector2.cpp new file mode 100644 index 00000000000..ec0737c3755 --- /dev/null +++ b/dep/src/g3dlite/Vector2.cpp @@ -0,0 +1,224 @@ +/** + @file Vector2.cpp + + 2D vector class, used for texture coordinates primarily. + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @cite Portions based on Dave Eberly'x Magic Software Library + at http://www.magic-software.com + + @created 2001-06-02 + @edited 2009-11-16 + */ + +#include "G3D/platform.h" +#include <stdlib.h> +#include "G3D/Vector2.h" +#include "G3D/g3dmath.h" +#include "G3D/format.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/TextInput.h" +#include "G3D/TextOutput.h" +#include "G3D/Any.h" + +namespace G3D { + + +Vector2::Vector2(const Any& any) { + any.verifyName("Vector2"); + any.verifyType(Any::TABLE, Any::ARRAY); + any.verifySize(2); + + if (any.type() == Any::ARRAY) { + x = any[0]; + y = any[1]; + } else { + // Table + x = any["x"]; + y = any["y"]; + } +} + + +Vector2::operator Any() const { + Any any(Any::ARRAY, "Vector2"); + any.append(x, y); + return any; +} + + +const Vector2& Vector2::one() { + static const Vector2 v(1, 1); return v; +} + + +const Vector2& Vector2::zero() { + static Vector2 v(0, 0); + return v; +} + +const Vector2& Vector2::unitX() { + static Vector2 v(1, 0); + return v; +} + +const Vector2& Vector2::unitY() { + static Vector2 v(0, 1); + return v; +} + +const Vector2& Vector2::inf() { + static Vector2 v((float)G3D::finf(), (float)G3D::finf()); + return v; +} + + +const Vector2& Vector2::nan() { + static Vector2 v((float)G3D::fnan(), (float)G3D::fnan()); + return v; +} + + +const Vector2& Vector2::minFinite() { + static Vector2 v(-FLT_MAX, -FLT_MAX); + return v; +} + + +const Vector2& Vector2::maxFinite() { + static Vector2 v(FLT_MAX, FLT_MAX); + return v; +} + + +size_t Vector2::hashCode() const { + unsigned int xhash = (*(int*)(void*)(&x)); + unsigned int yhash = (*(int*)(void*)(&y)); + + return xhash + (yhash * 37); +} + + +Vector2::Vector2(BinaryInput& b) { + deserialize(b); +} + + +void Vector2::deserialize(BinaryInput& b) { + x = b.readFloat32(); + y = b.readFloat32(); +} + + +void Vector2::serialize(BinaryOutput& b) const { + b.writeFloat32(x); + b.writeFloat32(y); +} + + +void Vector2::deserialize(TextInput& t) { + t.readSymbol("("); + x = (float)t.readNumber(); + t.readSymbol(","); + y = (float)t.readNumber(); + t.readSymbol(")"); +} + + +void Vector2::serialize(TextOutput& t) const { + t.writeSymbol("("); + t.writeNumber(x); + t.writeSymbol(","); + t.writeNumber(y); + t.writeSymbol(")"); +} + +//---------------------------------------------------------------------------- + +Vector2 Vector2::random(G3D::Random& r) { + Vector2 result; + + do { + result = Vector2(r.uniform(-1, 1), r.uniform(-1, 1)); + + } while (result.squaredLength() >= 1.0f); + + result.unitize(); + + return result; +} + + +Vector2 Vector2::operator/ (float k) const { + return *this * (1.0f / k); +} + +Vector2& Vector2::operator/= (float k) { + this->x /= k; + this->y /= k; + return *this; +} + +//---------------------------------------------------------------------------- +float Vector2::unitize (float fTolerance) { + float fLength = length(); + + if (fLength > fTolerance) { + float fInvLength = 1.0f / fLength; + x *= fInvLength; + y *= fInvLength; + } else { + fLength = 0.0; + } + + return fLength; +} + +//---------------------------------------------------------------------------- + +std::string Vector2::toString() const { + return G3D::format("(%g, %g)", x, y); +} + +// 2-char swizzles + +Vector2 Vector2::xx() const { return Vector2 (x, x); } +Vector2 Vector2::yx() const { return Vector2 (y, x); } +Vector2 Vector2::xy() const { return Vector2 (x, y); } +Vector2 Vector2::yy() const { return Vector2 (y, y); } + +// 3-char swizzles + +Vector3 Vector2::xxx() const { return Vector3 (x, x, x); } +Vector3 Vector2::yxx() const { return Vector3 (y, x, x); } +Vector3 Vector2::xyx() const { return Vector3 (x, y, x); } +Vector3 Vector2::yyx() const { return Vector3 (y, y, x); } +Vector3 Vector2::xxy() const { return Vector3 (x, x, y); } +Vector3 Vector2::yxy() const { return Vector3 (y, x, y); } +Vector3 Vector2::xyy() const { return Vector3 (x, y, y); } +Vector3 Vector2::yyy() const { return Vector3 (y, y, y); } + +// 4-char swizzles + +Vector4 Vector2::xxxx() const { return Vector4 (x, x, x, x); } +Vector4 Vector2::yxxx() const { return Vector4 (y, x, x, x); } +Vector4 Vector2::xyxx() const { return Vector4 (x, y, x, x); } +Vector4 Vector2::yyxx() const { return Vector4 (y, y, x, x); } +Vector4 Vector2::xxyx() const { return Vector4 (x, x, y, x); } +Vector4 Vector2::yxyx() const { return Vector4 (y, x, y, x); } +Vector4 Vector2::xyyx() const { return Vector4 (x, y, y, x); } +Vector4 Vector2::yyyx() const { return Vector4 (y, y, y, x); } +Vector4 Vector2::xxxy() const { return Vector4 (x, x, x, y); } +Vector4 Vector2::yxxy() const { return Vector4 (y, x, x, y); } +Vector4 Vector2::xyxy() const { return Vector4 (x, y, x, y); } +Vector4 Vector2::yyxy() const { return Vector4 (y, y, x, y); } +Vector4 Vector2::xxyy() const { return Vector4 (x, x, y, y); } +Vector4 Vector2::yxyy() const { return Vector4 (y, x, y, y); } +Vector4 Vector2::xyyy() const { return Vector4 (x, y, y, y); } +Vector4 Vector2::yyyy() const { return Vector4 (y, y, y, y); } + + + +} // namespace diff --git a/dep/src/g3dlite/Vector2int16.cpp b/dep/src/g3dlite/Vector2int16.cpp new file mode 100644 index 00000000000..2a4035a4d09 --- /dev/null +++ b/dep/src/g3dlite/Vector2int16.cpp @@ -0,0 +1,47 @@ +/** + @file Vector2int16.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-08-09 + @edited 2006-01-29 + */ + +#include "G3D/platform.h" +#include "G3D/g3dmath.h" +#include "G3D/Vector2int16.h" +#include "G3D/Vector2.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" + +namespace G3D { + +Vector2int16::Vector2int16(const class Vector2& v) { + x = (int16)iFloor(v.x + 0.5); + y = (int16)iFloor(v.y + 0.5); +} + + +Vector2int16::Vector2int16(class BinaryInput& bi) { + deserialize(bi); +} + + +void Vector2int16::serialize(class BinaryOutput& bo) const { + bo.writeInt16(x); + bo.writeInt16(y); +} + + +void Vector2int16::deserialize(class BinaryInput& bi) { + x = bi.readInt16(); + y = bi.readInt16(); +} + + +Vector2int16 Vector2int16::clamp(const Vector2int16& lo, const Vector2int16& hi) { + return Vector2int16(iClamp(x, lo.x, hi.x), iClamp(y, lo.y, hi.y)); +} + + +} diff --git a/dep/src/g3dlite/Vector3.cpp b/dep/src/g3dlite/Vector3.cpp index b0ca1990a3f..a53fa8269b7 100644 --- a/dep/src/g3dlite/Vector3.cpp +++ b/dep/src/g3dlite/Vector3.cpp @@ -1,44 +1,84 @@ /** @file Vector3.cpp - + 3D vector class - - @maintainer Morgan McGuire, matrix@graphics3d.com - + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @cite Portions based on Dave Eberly's Magic Software Library at http://www.magic-software.com - + @created 2001-06-02 - @edited 2006-01-30 + @edited 2009-11-27 */ #include <limits> #include <stdlib.h> #include "G3D/Vector3.h" #include "G3D/g3dmath.h" -#include "G3D/format.h" #include "G3D/stringutils.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/TextInput.h" +#include "G3D/TextOutput.h" #include "G3D/Vector3int16.h" #include "G3D/Matrix3.h" #include "G3D/Vector2.h" - +#include "G3D/Color3.h" +#include "G3D/Vector4int8.h" +#include "G3D/Vector3int32.h" +#include "G3D/Any.h" + namespace G3D { -Vector3 Vector3::dummy; +Vector3::Vector3(const Any& any) { + any.verifyName("Vector3"); + any.verifyType(Any::TABLE, Any::ARRAY); + any.verifySize(3); -// Deprecated. -const Vector3 Vector3::ZERO(0, 0, 0); -const Vector3 Vector3::ZERO3(0, 0, 0); -const Vector3 Vector3::UNIT_X(1, 0, 0); -const Vector3 Vector3::UNIT_Y(0, 1, 0); -const Vector3 Vector3::UNIT_Z(0, 0, 1); -const Vector3 Vector3::INF3((float)G3D::inf(), (float)G3D::inf(), (float)G3D::inf()); -const Vector3 Vector3::NAN3((float)G3D::nan(), (float)G3D::nan(), (float)G3D::nan()); + if (any.type() == Any::ARRAY) { + x = any[0]; + y = any[1]; + z = any[2]; + } else { + // Table + x = any["x"]; + y = any["y"]; + z = any["z"]; + } +} + +Vector3::operator Any() const { + Any any(Any::ARRAY, "Vector3"); + any.append(x, y, z); + return any; +} + +Vector3::Vector3(const class Color3& v) : x(v.r), y(v.g), z(v.b) {} + +Vector3::Vector3(const class Vector3int32& v) : x((float)v.x), y((float)v.y), z((float)v.z) {} + +Vector3::Vector3(const Vector4int8& v) : x(v.x / 127.0f), y(v.y / 127.0f), z(v.z / 127.0f) {} Vector3::Vector3(const class Vector2& v, float _z) : x(v.x), y(v.y), z(_z) { } -Vector3::Axis Vector3::primaryAxis() const { +Vector3& Vector3::ignore() { + static Vector3 v; + return v; +} +const Vector3& Vector3::zero() { static const Vector3 v(0, 0, 0); return v; } +const Vector3& Vector3::one() { static const Vector3 v(1, 1, 1); return v; } +const Vector3& Vector3::unitX() { static const Vector3 v(1, 0, 0); return v; } +const Vector3& Vector3::unitY() { static const Vector3 v(0, 1, 0); return v; } +const Vector3& Vector3::unitZ() { static const Vector3 v(0, 0, 1); return v; } +const Vector3& Vector3::inf() { static const Vector3 v((float)G3D::finf(), (float)G3D::finf(), (float)G3D::finf()); return v; } +const Vector3& Vector3::nan() { static const Vector3 v((float)G3D::fnan(), (float)G3D::fnan(), (float)G3D::fnan()); return v; } +const Vector3& Vector3::minFinite(){ static const Vector3 v(-FLT_MAX, -FLT_MAX, -FLT_MAX); return v; } +const Vector3& Vector3::maxFinite(){ static const Vector3 v(FLT_MAX, FLT_MAX, FLT_MAX); return v; } + +Vector3::Axis Vector3::primaryAxis() const { + Axis a = X_AXIS; double nx = abs(x); @@ -62,7 +102,8 @@ Vector3::Axis Vector3::primaryAxis() const { return a; } -unsigned int Vector3::hashCode() const { + +size_t Vector3::hashCode() const { unsigned int xhash = (*(int*)(void*)(&x)); unsigned int yhash = (*(int*)(void*)(&y)); unsigned int zhash = (*(int*)(void*)(&z)); @@ -74,65 +115,73 @@ std::ostream& operator<<(std::ostream& os, const Vector3& v) { return os << v.toString(); } + //---------------------------------------------------------------------------- double frand() { return rand() / (double) RAND_MAX; } +Vector3::Vector3(TextInput& t) { + deserialize(t); +} + +Vector3::Vector3(BinaryInput& b) { + deserialize(b); +} + + Vector3::Vector3(const class Vector3int16& v) { x = v.x; y = v.y; z = v.z; } -Vector3 Vector3::random() { - Vector3 result; - do { - result = Vector3(uniformRandom(-1.0, 1.0), - uniformRandom(-1.0, 1.0), - uniformRandom(-1.0, 1.0)); - } while (result.squaredMagnitude() >= 1.0f); +void Vector3::deserialize(BinaryInput& b) { + x = b.readFloat32(); + y = b.readFloat32(); + z = b.readFloat32(); +} - result.unitize(); - return result; +void Vector3::deserialize(TextInput& t) { + t.readSymbol("("); + x = (float)t.readNumber(); + t.readSymbol(","); + y = (float)t.readNumber(); + t.readSymbol(","); + z = (float)t.readNumber(); + t.readSymbol(")"); } -//---------------------------------------------------------------------------- -Vector3 Vector3::operator/ (float fScalar) const { - Vector3 kQuot; - - if ( fScalar != 0.0 ) { - float fInvScalar = 1.0f / fScalar; - kQuot.x = fInvScalar * x; - kQuot.y = fInvScalar * y; - kQuot.z = fInvScalar * z; - return kQuot; - } else { - return Vector3::inf(); - } + +void Vector3::serialize(TextOutput& t) const { + t.writeSymbol("("); + t.writeNumber(x); + t.writeSymbol(","); + t.writeNumber(y); + t.writeSymbol(","); + t.writeNumber(z); + t.writeSymbol(")"); } -//---------------------------------------------------------------------------- -Vector3& Vector3::operator/= (float fScalar) { - if (fScalar != 0.0) { - float fInvScalar = 1.0f / fScalar; - x *= fInvScalar; - y *= fInvScalar; - z *= fInvScalar; - } else { - x = (float)G3D::inf(); - y = (float)G3D::inf(); - z = (float)G3D::inf(); - } - return *this; +void Vector3::serialize(BinaryOutput& b) const { + b.writeFloat32(x); + b.writeFloat32(y); + b.writeFloat32(z); } -//---------------------------------------------------------------------------- -float Vector3::unitize (float fTolerance) { + +Vector3 Vector3::random(Random& r) { + Vector3 result; + r.sphere(result.x, result.y, result.z); + return result; +} + + +float Vector3::unitize(float fTolerance) { float fMagnitude = magnitude(); if (fMagnitude > fTolerance) { @@ -147,10 +196,8 @@ float Vector3::unitize (float fTolerance) { return fMagnitude; } -//---------------------------------------------------------------------------- Vector3 Vector3::reflectAbout(const Vector3& normal) const { - Vector3 out; Vector3 N = normal.direction(); @@ -159,36 +206,49 @@ Vector3 Vector3::reflectAbout(const Vector3& normal) const { return N * 2 * this->dot(N) - *this; } -//---------------------------------------------------------------------------- -#if 0 -Vector3 Vector3::cosRandom(const Vector3& normal) { - double e1 = G3D::random(0, 1); - double e2 = G3D::random(0, 1); - // Angle from normal - double theta = acos(sqrt(e1)); +Vector3 Vector3::cosHemiRandom(const Vector3& normal, Random& r) { + debugAssertM(G3D::fuzzyEq(normal.length(), 1.0f), + "cosHemiRandom requires its argument to have unit length"); - // Angle about normal - double phi = 2 * G3D_PI * e2; + float x, y, z; + r.cosHemi(x, y, z); // Make a coordinate system - Vector3 U = normal.direction(); - Vector3 V = Vector3::unitX(); + const Vector3& Z = normal; - if (abs(U.dot(V)) > .9) { - V = Vector3::unitY(); - } + Vector3 X, Y; + normal.getTangents(X, Y); + + return + x * X + + y * Y + + z * Z; +} + + +Vector3 Vector3::cosPowHemiRandom(const Vector3& normal, const float k, Random& r) { + debugAssertM(G3D::fuzzyEq(normal.length(), 1.0f), + "cosPowHemiRandom requires its argument to have unit length"); - Vector3 W = U.cross(V).direction(); - V = W.cross(U); + float x, y, z; + r.cosPowHemi(k, x, y, z); - // Convert to rectangular form - return cos(theta) * U + sin(theta) * (cos(phi) * V + sin(phi) * W); + // Make a coordinate system + const Vector3& Z = normal; + + Vector3 X, Y; + normal.getTangents(X, Y); + + return + x * X + + y * Y + + z * Z; } -//---------------------------------------------------------------------------- -Vector3 Vector3::hemiRandom(const Vector3& normal) { - Vector3 V = Vector3::random(); + +Vector3 Vector3::hemiRandom(const Vector3& normal, Random& r) { + const Vector3& V = Vector3::random(r); if (V.dot(normal) < 0) { return -V; @@ -196,7 +256,7 @@ Vector3 Vector3::hemiRandom(const Vector3& normal) { return V; } } -#endif + //---------------------------------------------------------------------------- Vector3 Vector3::reflectionDirection(const Vector3& normal) const { @@ -256,12 +316,12 @@ void Vector3::orthonormalize (Vector3 akVector[3]) { akVector[0].unitize(); // compute u1 - float fDot0 = akVector[0].dot(akVector[1]); + float fDot0 = akVector[0].dot(akVector[1]); akVector[1] -= akVector[0] * fDot0; akVector[1].unitize(); // compute u2 - float fDot1 = akVector[1].dot(akVector[2]); + float fDot1 = akVector[1].dot(akVector[2]); fDot0 = akVector[0].dot(akVector[2]); akVector[2] -= akVector[0] * fDot0 + akVector[1] * fDot1; akVector[2].unitize(); @@ -294,6 +354,7 @@ std::string Vector3::toString() const { return G3D::format("(%g, %g, %g)", x, y, z); } + //---------------------------------------------------------------------------- Matrix3 Vector3::cross() const { @@ -302,6 +363,15 @@ Matrix3 Vector3::cross() const { -y, x, 0); } + +void serialize(const Vector3::Axis& a, class BinaryOutput& bo) { + bo.writeUInt8((uint8)a); +} + +void deserialize(Vector3::Axis& a, class BinaryInput& bi) { + a = (Vector3::Axis)bi.readUInt8(); +} + //---------------------------------------------------------------------------- // 2-char swizzles @@ -431,5 +501,7 @@ Vector4 Vector3::zzzz() const { return Vector4 (z, z, z, z); } -} // namespace + + +} // namespace diff --git a/dep/src/g3dlite/Vector3int16.cpp b/dep/src/g3dlite/Vector3int16.cpp new file mode 100644 index 00000000000..44069b85d8c --- /dev/null +++ b/dep/src/g3dlite/Vector3int16.cpp @@ -0,0 +1,49 @@ +/** + @file Vector3int16.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2003-04-07 + @edited 2006-01-17 + */ + +#include "G3D/platform.h" +#include "G3D/g3dmath.h" +#include "G3D/Vector3int16.h" +#include "G3D/Vector3.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/format.h" + +namespace G3D { + +Vector3int16::Vector3int16(const class Vector3& v) { + x = (int16)iFloor(v.x + 0.5); + y = (int16)iFloor(v.y + 0.5); + z = (int16)iFloor(v.z + 0.5); +} + + +Vector3int16::Vector3int16(class BinaryInput& bi) { + deserialize(bi); +} + + +void Vector3int16::serialize(class BinaryOutput& bo) const { + bo.writeInt16(x); + bo.writeInt16(y); + bo.writeInt16(z); +} + + +void Vector3int16::deserialize(class BinaryInput& bi) { + x = bi.readInt16(); + y = bi.readInt16(); + z = bi.readInt16(); +} + +std::string Vector3int16::toString() const { + return G3D::format("(%d, %d, %d)", x, y, z); +} + +} diff --git a/dep/src/g3dlite/Vector3int32.cpp b/dep/src/g3dlite/Vector3int32.cpp new file mode 100644 index 00000000000..3bd8e9f2bc2 --- /dev/null +++ b/dep/src/g3dlite/Vector3int32.cpp @@ -0,0 +1,57 @@ +/** + @file Vector3int32.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + + @created 2008-07-01 + @edited 2008-07-01 + */ + +#include "G3D/platform.h" +#include "G3D/g3dmath.h" +#include "G3D/Vector3int32.h" +#include "G3D/Vector3int16.h" +#include "G3D/Vector3.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/format.h" + +namespace G3D { + +Vector3int32::Vector3int32(const class Vector3& v) { + x = (int32)iFloor(v.x + 0.5); + y = (int32)iFloor(v.y + 0.5); + z = (int32)iFloor(v.z + 0.5); +} + + +Vector3int32::Vector3int32(const class Vector3int16& v) { + x = v.x; + y = v.y; + z = v.z; +} + + +Vector3int32::Vector3int32(class BinaryInput& bi) { + deserialize(bi); +} + + +void Vector3int32::serialize(class BinaryOutput& bo) const { + bo.writeInt32(x); + bo.writeInt32(y); + bo.writeInt32(z); +} + + +void Vector3int32::deserialize(class BinaryInput& bi) { + x = bi.readInt32(); + y = bi.readInt32(); + z = bi.readInt32(); +} + +std::string Vector3int32::toString() const { + return G3D::format("(%d, %d, %d)", x, y, z); +} + +} diff --git a/dep/src/g3dlite/Vector4.cpp b/dep/src/g3dlite/Vector4.cpp index b38e6f7cb57..f6abc1a6e0c 100644 --- a/dep/src/g3dlite/Vector4.cpp +++ b/dep/src/g3dlite/Vector4.cpp @@ -1,23 +1,74 @@ /** @file Vector4.cpp - - @maintainer Morgan McGuire, matrix@graphics3d.com - + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2001-07-09 - @edited 2003-09-29 + @edited 2009-11-29 */ #include <stdlib.h> #include <limits> #include "G3D/Vector4.h" -//#include "G3D/Color4.h" +#include "G3D/Color4.h" #include "G3D/g3dmath.h" -#include "G3D/format.h" #include "G3D/stringutils.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/Vector4int8.h" +#include "G3D/Matrix4.h" +#include "G3D/Any.h" namespace G3D { -unsigned int Vector4::hashCode() const { +Vector4::Vector4(const Any& any) { + any.verifyName("Vector4"); + any.verifyType(Any::TABLE, Any::ARRAY); + any.verifySize(4); + + if (any.type() == Any::ARRAY) { + x = any[0]; + y = any[1]; + z = any[2]; + w = any[3]; + } else { + // Table + x = any["x"]; + y = any["y"]; + z = any["z"]; + w = any["w"]; + } +} + +Vector4::operator Any() const { + Any any(Any::ARRAY, "Vector4"); + any.append(x, y, z, w); + return any; +} + + +Vector4::Vector4(const Vector4int8& v) : x(v.x / 127.0f), y(v.y / 127.0f), z(v.z / 127.0f), w(v.w / 127.0f) { +} + + +const Vector4& Vector4::inf() { + static const Vector4 v((float)G3D::finf(), (float)G3D::finf(), (float)G3D::finf(), (float)G3D::finf()); + return v; +} + + +const Vector4& Vector4::zero() { + static const Vector4 v(0,0,0,0); + return v; +} + +const Vector4& Vector4::nan() { + static Vector4 v((float)G3D::fnan(), (float)G3D::fnan(), (float)G3D::fnan(), (float)G3D::fnan()); + return v; +} + + +size_t Vector4::hashCode() const { unsigned int xhash = (*(int*)(void*)(&x)); unsigned int yhash = (*(int*)(void*)(&y)); unsigned int zhash = (*(int*)(void*)(&z)); @@ -26,14 +77,14 @@ unsigned int Vector4::hashCode() const { return xhash + (yhash * 37) + (zhash * 101) + (whash * 241); } -#if 0 + Vector4::Vector4(const class Color4& c) { x = c.r; y = c.g; z = c.b; w = c.a; } -#endif + Vector4::Vector4(const Vector2& v1, const Vector2& v2) { x = v1.x; @@ -42,6 +93,7 @@ Vector4::Vector4(const Vector2& v1, const Vector2& v2) { w = v2.y; } + Vector4::Vector4(const Vector2& v1, float fz, float fw) { x = v1.x; y = v1.y; @@ -49,13 +101,45 @@ Vector4::Vector4(const Vector2& v1, float fz, float fw) { w = fw; } +Vector4::Vector4(BinaryInput& b) { + deserialize(b); +} + + +void Vector4::deserialize(BinaryInput& b) { + x = b.readFloat32(); + y = b.readFloat32(); + z = b.readFloat32(); + w = b.readFloat32(); +} + + +void Vector4::serialize(BinaryOutput& b) const { + b.writeFloat32(x); + b.writeFloat32(y); + b.writeFloat32(z); + b.writeFloat32(w); +} + //---------------------------------------------------------------------------- +Vector4 Vector4::operator*(const Matrix4& M) const { + Vector4 result; + for (int i = 0; i < 4; ++i) { + result[i] = 0.0f; + for (int j = 0; j < 4; ++j) { + result[i] += (*this)[j] * M[j][i]; + } + } + return result; +} + + Vector4 Vector4::operator/ (float fScalar) const { Vector4 kQuot; if ( fScalar != 0.0 ) { - float fInvScalar = 1.0f / fScalar; + float fInvScalar = 1.0f / fScalar; kQuot.x = fInvScalar * x; kQuot.y = fInvScalar * y; kQuot.z = fInvScalar * z; @@ -69,18 +153,19 @@ Vector4 Vector4::operator/ (float fScalar) const { //---------------------------------------------------------------------------- Vector4& Vector4::operator/= (float fScalar) { if (fScalar != 0.0f) { - float fInvScalar = 1.0f / fScalar; + float fInvScalar = 1.0f / fScalar; x *= fInvScalar; y *= fInvScalar; z *= fInvScalar; w *= fInvScalar; } else { - *this = Vector4::inf(); + *this = Vector4::inf(); } return *this; } + //---------------------------------------------------------------------------- std::string Vector4::toString() const { @@ -431,5 +516,5 @@ Vector4 Vector4::ywww() const { return Vector4 (y, w, w, w); } Vector4 Vector4::zwww() const { return Vector4 (z, w, w, w); } Vector4 Vector4::wwww() const { return Vector4 (w, w, w, w); } -}; // namespace +}; // namespace diff --git a/dep/src/g3dlite/Vector4int8.cpp b/dep/src/g3dlite/Vector4int8.cpp new file mode 100644 index 00000000000..70bd143e01d --- /dev/null +++ b/dep/src/g3dlite/Vector4int8.cpp @@ -0,0 +1,58 @@ +/** + @file Vector4int8.cpp + + Homogeneous vector class. + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2007-02-09 + @edited 2007-02-09 + + Copyright 2000-2007, Morgan McGuire. + All rights reserved. + */ + +#include "G3D/platform.h" +#include "G3D/Vector4int8.h" +#include "G3D/Vector3.h" +#include "G3D/Vector4.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include <string> + +namespace G3D { + +Vector4int8::Vector4int8(const Vector4& source) { + x = iClamp(iRound(source.x), -128, 127); + y = iClamp(iRound(source.y), -128, 127); + z = iClamp(iRound(source.z), -128, 127); + w = iClamp(iRound(source.w), -128, 127); +} + +Vector4int8::Vector4int8(const Vector3& source, int8 w) : w(w) { + x = iClamp(iRound(source.x), -128, 127); + y = iClamp(iRound(source.y), -128, 127); + z = iClamp(iRound(source.z), -128, 127); +} + +Vector4int8::Vector4int8(class BinaryInput& b) { + deserialize(b); +} + +void Vector4int8::serialize(class BinaryOutput& b) const { + // Intentionally write individual bytes to avoid endian issues + b.writeInt8(x); + b.writeInt8(y); + b.writeInt8(z); + b.writeInt8(w); +} + +void Vector4int8::deserialize(class BinaryInput& b) { + x = b.readInt8(); + y = b.readInt8(); + z = b.readInt8(); + w = b.readInt8(); +} + +} // namespace G3D + diff --git a/dep/src/g3dlite/Welder.cpp b/dep/src/g3dlite/Welder.cpp new file mode 100644 index 00000000000..b4f752f38bd --- /dev/null +++ b/dep/src/g3dlite/Welder.cpp @@ -0,0 +1,416 @@ +/** + @file Welder.cpp + + @author Morgan McGuire, Kyle Whitson, Corey Taylor + + @created 2008-07-30 + @edited 2009-11-29 + */ + +#include "G3D/platform.h" +#include "G3D/Vector2.h" +#include "G3D/Vector3.h" +#include "G3D/Sphere.h" +#include "G3D/PointHashGrid.h" +#include "G3D/Welder.h" +#include "G3D/Stopwatch.h" // for profiling +#include "G3D/AreaMemoryManager.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { namespace _internal{ + + +/** Used by WeldHelper2::smoothNormals. */ +class VN { +public: + Vector3 vertex; + Vector3 normal; + + VN() {} + VN(const Vector3& v, const Vector3& n) : vertex(v), normal(n) {} +}; + +/** Used by WeldHelper::getIndex to maintain a list of vertices by location. */ +class VNTi { +public: + Vector3 vertex; + Vector3 normal; + Vector2 texCoord; + int index; + + VNTi() : index(0) {} + + VNTi(const Vector3& v, const Vector3& n, const Vector2& t, int i) : + vertex(v), normal(n), texCoord(t), index(i) {} +}; + + +}} // G3D + +template <> struct HashTrait <G3D::_internal::VN> { + static size_t hashCode(const G3D::_internal::VN& k) { return static_cast<size_t>(k.vertex.hashCode()); } +}; +template <> struct HashTrait <G3D::_internal::VNTi> { + static size_t hashCode(const G3D::_internal::VNTi& k) { return static_cast<size_t>(k.vertex.hashCode()); } +}; + + +template<> struct EqualsTrait <G3D::_internal::VN> { + static bool equals(const G3D::_internal::VN& a, const G3D::_internal::VN& b) { return a.vertex == b.vertex; } +}; +template<> struct EqualsTrait <G3D::_internal::VNTi> { + static bool equals(const G3D::_internal::VNTi& a, const G3D::_internal::VNTi& b) { return a.vertex == b.vertex; } +}; + +template<> struct PositionTrait<G3D::_internal::VN> { + static void getPosition(const G3D::_internal::VN& v, G3D::Vector3& p) { p = v.vertex; } +}; +template<> struct PositionTrait<G3D::_internal::VNTi> { + static void getPosition(const G3D::_internal::VNTi& v, G3D::Vector3& p) { p = v.vertex; } +}; + +namespace G3D { namespace _internal { + +class WeldHelper { +private: + /** Used by getIndex and updateTriLists */ + PointHashGrid<VNTi> weldGrid; + + Array<Vector3>* outputVertexArray; + Array<Vector3>* outputNormalArray; + Array<Vector2>* outputTexCoordArray; + + float vertexWeldRadius; + /** Squared radius allowed for welding similar normals. */ + float normalWeldRadius2; + float texCoordWeldRadius2; + + float normalSmoothingAngle; + + /** + Returns the index of the vertex in + outputVertexArray/outputNormalArray/outputTexCoordArray + that is within the global tolerances of v,n,t. If there + is no such vertex, adds it to the arrays and returns that index. + + Called from updateTriLists(). + */ + int getIndex(const Vector3& v, const Vector3& n, const Vector2& t) { + PointHashGrid<VNTi>::SphereIterator it = + weldGrid.beginSphereIntersection(Sphere(v, vertexWeldRadius)); + + if (n.isZero()) { + // Don't bother trying to match the surface normal, since this vertex has no surface normal. + while (it.hasMore()) { + if ((t - it->texCoord).squaredLength() <= texCoordWeldRadius2) { + // This is the vertex + return it->index; + } + ++it; + } + } else { + while (it.hasMore()) { + if (((n - it->normal).squaredLength() <= normalWeldRadius2) && + ((t - it->texCoord).squaredLength() <= texCoordWeldRadius2)) { + // This is the vertex + return it->index; + } + ++it; + } + } + + // Note that a sliver triangle processed before its neighbors may reach here + // with a zero length normal. + + // The vertex does not exist. Create it. + const int i = outputVertexArray->size(); + outputVertexArray->append(v); + outputNormalArray->append(n); + outputTexCoordArray->append(t); + + // Store in the grid so that it will be remembered. + weldGrid.insert(VNTi(v, n, t, i)); + + return i; + } + + + /** + Updates each indexArray to refer to vertices in the + outputVertexArray. + + Called from process() + */ + void updateTriLists( + Array<Array<int>*>& indexArrayArray, + const Array<Vector3>& vertexArray, + const Array<Vector3>& normalArray, + const Array<Vector2>& texCoordArray) { + + // Compute a hash grid so that we can find neighbors quickly. + // It begins empty and is extended as the tri lists are iterated + // through. + weldGrid.clear(); + + // Process all triLists + int numTriLists = indexArrayArray.size(); + int u = 0; + for (int t = 0; t < numTriLists; ++t) { + Array<int>& triList = *(indexArrayArray[t]); + + // For all vertices in this list + for (int v = 0; v < triList.size(); ++v) { + // This vertex mapped to u in the flatVertexArray + triList[v] = getIndex(vertexArray[u], normalArray[u], texCoordArray[u]); + + /* +# ifdef G3D_DEBUG + { + int i = triList[v]; + Vector3 N = normalArray[i]; + debugAssertM(N.length() > 0.9f, "Produced non-unit normal"); + } +# endif + */ + ++u; + } + } + } + + /** Expands the indexed triangle lists into a triangle list. + + Called from process() */ + void unroll( + const Array<Array<int>*>& indexArrayArray, + const Array<Vector3>& vertexArray, + const Array<Vector2>& texCoordArray, + Array<Vector3>& unrolledVertexArray, + Array<Vector2>& unrolledTexCoordArray) { + + int numTriLists = indexArrayArray.size(); + for (int t = 0; t < numTriLists; ++t) { + const Array<int>& triList = *(indexArrayArray[t]); + for (int v = 0; v < triList.size(); ++v) { + int i = triList[v]; + unrolledVertexArray.append(vertexArray[i]); + unrolledTexCoordArray.append(texCoordArray[i]); + } + } + } + + /** For every three vertices, compute the face normal and store it three times. + Sliver triangles have a zero surface normal, which we will later take to + match *any* surface normal. */ + void computeFaceNormals( + const Array<Vector3>& vertexArray, + Array<Vector3>& faceNormalArray) { + + debugAssertM(vertexArray.size() % 3 == 0, "Input is not a triangle soup"); + debugAssertM(faceNormalArray.size() == 0, "Output must start empty."); + + for (int v = 0; v < vertexArray.size(); v += 3) { + const Vector3& e0 = vertexArray[v + 1] - vertexArray[v]; + const Vector3& e1 = vertexArray[v + 2] - vertexArray[v]; + + // Note that the length may be zero in the case of sliver polygons, e.g., + // those correcting a T-junction. + const Vector3& n = e0.cross(e1).directionOrZero(); + + // Append the normal once per vertex. + faceNormalArray.append(n, n, n); + } + } + + /** + Computes @a smoothNormalArray, whose elements are those of normalArray averaged + with neighbors within the angular cutoff. + */ + void smoothNormals( + const Array<Vector3>& vertexArray, + const Array<Vector3>& normalArray, + Array<Vector3>& smoothNormalArray) { + + // Create an area memory manager for fast deallocation + MemoryManager::Ref mm = AreaMemoryManager::create(iRound(sizeof(VN) * normalArray.size() * 1.5)); + + if (normalSmoothingAngle <= 0) { + smoothNormalArray = normalArray; + return; + } + + const float cosThresholdAngle = (float)cos(normalSmoothingAngle); + + debugAssert(vertexArray.size() == normalArray.size()); + smoothNormalArray.resize(normalArray.size()); + + // Compute a hash grid so that we can find neighbors quickly. + PointHashGrid<VN> grid(vertexWeldRadius, mm); + for (int v = 0; v < normalArray.size(); ++v) { + grid.insert(VN(vertexArray[v], normalArray[v])); + } + + for (int v = 0; v < normalArray.size(); ++v) { + // Compute the sum of all nearby normals within the cutoff angle. + // Search within the vertexWeldRadius, since those are the vertices + // that will collapse to the same point. + PointHashGrid<VN>::SphereIterator it = + grid.beginSphereIntersection(Sphere(vertexArray[v], vertexWeldRadius)); + + Vector3 sum; + + const Vector3& original = normalArray[v]; + while (it.hasMore()) { + const Vector3& N = it->normal; + const float cosAngle = N.dot(original); + + if (cosAngle > cosThresholdAngle) { + // This normal is close enough to consider + sum += N; + } + ++it; + } + + const Vector3& average = sum.directionOrZero(); + + const bool indeterminate = average.isZero(); + // Never "smooth" a normal so far that it points backwards + const bool backFacing = original.dot(average) < 0; + + if (indeterminate || backFacing) { + // Revert to the face normal + smoothNormalArray[v] = original; + } else { + // Average available normals + smoothNormalArray[v] = average; + } + } + } + +public: + + + /** + Algorithm: + + 1. Unroll the indexed triangle list into a triangle list, where + there are duplicated vertices. + + 2. Compute face normals for all triangles, and expand those into + the triangle vertices. + + 3. At each vertex, average all normals that are within normalSmoothingAngle. + + 4. Generate output indexArrayArray. While doing so, merge all vertices where + the distance between position, texCoord, and normal is within the thresholds. + */ + void process( + Array<Vector3>& vertexArray, + Array<Vector2>& texCoordArray, + Array<Vector3>& normalArray, + Array<Array<int>*>& indexArrayArray, + float normAngle, + float texRadius, + float normRadius) { + + normalSmoothingAngle = normAngle; + normalWeldRadius2 = square(normRadius); + texCoordWeldRadius2 = square(texRadius); + + const bool hasTexCoords = (texCoordArray.size() > 0); + + if (hasTexCoords) { + debugAssertM(vertexArray.size() == texCoordArray.size(), + "Input arrays are not parallel."); + } + + Array<Vector3> unrolledVertexArray; + Array<Vector3> unrolledFaceNormalArray; + Array<Vector3> unrolledSmoothNormalArray; + Array<Vector2> unrolledTexCoordArray; + + if (! hasTexCoords) { + // Generate all zero texture coordinates + texCoordArray.resize(vertexArray.size()); + } + + // Generate a flat (unrolled) triangle list with texture coordinates. + unroll(indexArrayArray, vertexArray, texCoordArray, + unrolledVertexArray, unrolledTexCoordArray); + + // Put the output back into the input slots. + outputVertexArray = &vertexArray; + outputNormalArray = &normalArray; + outputTexCoordArray = &texCoordArray; + outputVertexArray->fastClear(); + outputNormalArray->fastClear(); + outputTexCoordArray->fastClear(); + + // For every three vertices, generate their face normal and store it at + // each vertex. The output array has the same length as the input. + computeFaceNormals(unrolledVertexArray, unrolledFaceNormalArray); + + // Compute smooth normals at vertices. + if (unrolledFaceNormalArray.size() > 0) { + smoothNormals(unrolledVertexArray, unrolledFaceNormalArray, unrolledSmoothNormalArray); + unrolledFaceNormalArray.clear(); + } + + // Regenerate the triangle lists + updateTriLists(indexArrayArray, unrolledVertexArray, unrolledSmoothNormalArray, unrolledTexCoordArray); + + if (! hasTexCoords) { + // Throw away the generated texCoords + texCoordArray.resize(0); + } + } + + WeldHelper(float vertRadius) : + weldGrid(vertRadius), + vertexWeldRadius(vertRadius) {} + +}; +} // Internal + +void Welder::weld( + Array<Vector3>& vertexArray, + Array<Vector2>& texCoordArray, + Array<Vector3>& normalArray, + Array<Array<int>*>& indexArrayArray, + const Welder::Settings& settings) { + + _internal::WeldHelper(settings.vertexWeldRadius).process( + vertexArray, texCoordArray, normalArray, indexArrayArray, + settings.normalSmoothingAngle, settings.textureWeldRadius, settings.normalWeldRadius); +} + + +Welder::Settings::Settings(const Any& any) { + *this = Settings(); + any.verifyName("Welder::Settings"); + for (Any::AnyTable::Iterator it = any.table().begin(); it.hasMore(); ++it) { + const std::string& key = toLower(it->key); + if (key == "normalsmoothingangle") { + normalSmoothingAngle = it->value; + } else if (key == "vertexweldradius") { + vertexWeldRadius = it->value; + } else if (key == "textureweldradius") { + textureWeldRadius = it->value; + } else if (key == "normalweldradius") { + normalWeldRadius = it->value; + } else { + any.verify(false, "Illegal key: " + it->key); + } + } +} + +Welder::Settings::operator Any() const { + Any a(Any::TABLE, "Welder::Settings"); + a.set("normalSmoothingAngle", normalSmoothingAngle); + a.set("vertexWeldRadius", vertexWeldRadius); + a.set("textureWeldRadius", textureWeldRadius); + a.set("normalWeldRadius", normalWeldRadius); + return a; +} + +} // G3D diff --git a/dep/src/g3dlite/WinMain.cpp b/dep/src/g3dlite/WinMain.cpp new file mode 100644 index 00000000000..3cee71084e4 --- /dev/null +++ b/dep/src/g3dlite/WinMain.cpp @@ -0,0 +1,159 @@ +/* + Dervied from SDL_main.c, which was placed in the public domain by Sam Lantinga 4/13/98 + + The WinMain function -- calls your program's main() function +*/ + +#include "G3D/platform.h" + +#ifdef G3D_WIN32 + +#include <stdio.h> +#include <stdlib.h> +#include <cctype> + +#ifdef main +# ifndef _WIN32_WCE_EMULATION +# undef main +# endif /* _WIN32_WCE_EMULATION */ +#endif /* main */ + +#if defined(_WIN32_WCE) && _WIN32_WCE < 300 +/* seems to be undefined in Win CE although in online help */ +#define isspace(a) (((CHAR)a == ' ') || ((CHAR)a == '\t')) +#endif /* _WIN32_WCE < 300 */ + +// Turn off the G3D for loop scoping for C++ +#ifdef for +# undef for +#endif + +extern int main(int argc, const char** argv); + +/* Parse a command line buffer into arguments */ +static int ParseCommandLine(char *cmdline, char **argv) { + char *bufp; + int argc; + + argc = 0; + for (bufp = cmdline; *bufp;) { + /* Skip leading whitespace */ + while (isspace(*bufp)) { + ++bufp; + } + /* Skip over argument */ + if (*bufp == '"') { + ++bufp; + if (*bufp) { + if (argv) { + argv[argc] = bufp; + } + ++argc; + } + /* Skip over word */ + while (*bufp && (*bufp != '"')) { + ++bufp; + } + } else { + if (*bufp) { + if (argv) { + argv[argc] = bufp; + } + ++argc; + } + /* Skip over word */ + while (*bufp && !isspace(*bufp)) { + ++bufp; + } + } + if (*bufp) { + if (argv) { + *bufp = '\0'; + } + ++bufp; + } + } + if (argv) { + argv[argc] = NULL; + } + return (argc); +} + +/* Show an error message */ +static void ShowError(const char *title, const char *message) { +/* If USE_MESSAGEBOX is defined, you need to link with user32.lib */ +#ifdef USE_MESSAGEBOX + MessageBox(NULL, message, title, MB_ICONEXCLAMATION | MB_OK); +#else + fprintf(stderr, "%s: %s\n", title, message); +#endif +} + +/* Pop up an out of memory message, returns to Windows */ +static BOOL OutOfMemory(void) { + ShowError("Fatal Error", "Out of memory - aborting"); + return FALSE; +} + + +int WINAPI G3D_WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw) { + char **argv; + int argc; + int status; + char *cmdline; +# ifdef _WIN32_WCE + wchar_t *bufp; + int nLen; +# else + char *bufp; + size_t nLen; +# endif + (void)sw; + (void)szCmdLine; + (void)hInst; + (void)hPrev; + +#ifdef _WIN32_WCE +#error WinCE not supported + /* + nLen = wcslen(szCmdLine) + 128 + 1; + bufp = SDL_stack_alloc(wchar_t, nLen * 2); + wcscpy(bufp, TEXT("\"")); + GetModuleFileName(NULL, bufp + 1, 128 - 3); + wcscpy(bufp + wcslen(bufp), TEXT("\" ")); + wcsncpy(bufp + wcslen(bufp), szCmdLine, nLen - wcslen(bufp)); + nLen = wcslen(bufp) + 1; + cmdline = SDL_stack_alloc(char, nLen); + if (cmdline == NULL) { + return OutOfMemory(); + } + WideCharToMultiByte(CP_ACP, 0, bufp, -1, cmdline, nLen, NULL, NULL); + */ +#else + /* Grab the command line */ + bufp = GetCommandLineA(); + nLen = strlen(bufp) + 1; + cmdline = (char*)malloc(sizeof(char) * nLen); + if (cmdline == NULL) { + return OutOfMemory(); + } + strncpy(cmdline, bufp, nLen); +#endif + + /* Parse it into argv and argc */ + argc = ParseCommandLine(cmdline, NULL); + argv = (char**)malloc(sizeof(char*) * (argc + 1)); + if (argv == NULL) { + return OutOfMemory(); + } + ParseCommandLine(cmdline, argv); + + /* Run the main program */ + status = main(argc, (const char**)argv); + free(argv); + free(cmdline); + + return status; +} + +#endif // if Win32 diff --git a/dep/src/g3dlite/constants.cpp b/dep/src/g3dlite/constants.cpp new file mode 100644 index 00000000000..52cad3cd90b --- /dev/null +++ b/dep/src/g3dlite/constants.cpp @@ -0,0 +1,82 @@ +/** + @file constants.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @created 2009-05-20 + @edited 2010-01-29 +*/ +#include "G3D/constants.h" +#include "G3D/Any.h" +#include "G3D/stringutils.h" + +namespace G3D { + +const std::string MirrorQuality::str[] = {"NONE", "STATIC_ENV", "DYNAMIC_PLANAR", "DYNAMIC_ENV", "BEST"}; +const MirrorQuality::Value MirrorQuality::enm[] = {MirrorQuality::NONE, MirrorQuality::STATIC_ENV, + MirrorQuality::DYNAMIC_PLANAR, MirrorQuality::DYNAMIC_ENV, MirrorQuality::BEST}; + +MirrorQuality::MirrorQuality(const class Any& any) { + *this = any; +} + + +MirrorQuality& MirrorQuality::operator=(const Any& any) { + const std::string& s = toUpper(any.string()); + + for (int i = 0; ! str[i].empty(); ++i) { + if (s == str[i]) { + value = enm[i]; + return *this; + } + } + + any.verify(false, "Unrecognized MirrorQuality constant"); + return *this; +} + + +MirrorQuality::operator Any() const { + return toString(); +} + + +const std::string& MirrorQuality::toString() const { + return str[value]; +} + +///////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +const std::string RefractionQuality::str[] = {"NONE", "STATIC_ENV", "DYNAMIC_FLAT", "DYNAMIC_FLAT_MULTILAYER", "DYNAMIC_ENV", "BEST"}; +const RefractionQuality::Value RefractionQuality::enm[] = {RefractionQuality::NONE, RefractionQuality::STATIC_ENV, + RefractionQuality::DYNAMIC_FLAT, RefractionQuality::DYNAMIC_FLAT_MULTILAYER, RefractionQuality::DYNAMIC_ENV, RefractionQuality::BEST}; + +RefractionQuality::RefractionQuality(const class Any& any) { + *this = any; +} + + +RefractionQuality& RefractionQuality::operator=(const Any& any) { + const std::string& s = toUpper(any.string()); + + for (int i = 0; ! str[i].empty(); ++i) { + if (s == str[i]) { + value = enm[i]; + return *this; + } + } + + any.verify(false, "Unrecognized RefractionQuality constant"); + return *this; +} + + +RefractionQuality::operator Any() const { + return toString(); +} + + +const std::string& RefractionQuality::toString() const { + return str[value]; +} + +} // G3D diff --git a/dep/src/g3dlite/debugAssert.cpp b/dep/src/g3dlite/debugAssert.cpp new file mode 100644 index 00000000000..a87161b261f --- /dev/null +++ b/dep/src/g3dlite/debugAssert.cpp @@ -0,0 +1,389 @@ +/** + @file debugAssert.cpp + + Windows implementation of assertion routines. + + @maintainer Morgan McGuire, graphics3d.com + + @created 2001-08-26 + @edited 2009-06-02 + */ + +#include "G3D/debugAssert.h" +#include "G3D/platform.h" +#ifdef G3D_WIN32 + #include <tchar.h> +#endif +#include "G3D/format.h" +#include "G3D/prompt.h" +#include <string> +#include "G3D/debugPrintf.h" +#include "G3D/Log.h" + +#include <cstdlib> + +#ifdef _MSC_VER + // disable: "C++ exception handler used" +# pragma warning (push) +# pragma warning (disable : 4530) +#endif + +using namespace std; + +namespace G3D { namespace _internal { + +ConsolePrintHook _consolePrintHook; +AssertionHook _debugHook = _handleDebugAssert_; +AssertionHook _failureHook = _handleErrorCheck_; + +#ifdef G3D_LINUX +#if SOMEONE_MADE_THIS_USEFUL + Display* x11Display = NULL; + Window x11Window = 0; +#endif +#endif + + +#ifdef G3D_WIN32 +static void postToClipboard(const char *text) { + if (OpenClipboard(NULL)) { + HGLOBAL hMem = GlobalAlloc(GHND | GMEM_DDESHARE, strlen(text) + 1); + if (hMem) { + char *pMem = (char*)GlobalLock(hMem); + strcpy(pMem, text); + GlobalUnlock(hMem); + + EmptyClipboard(); + SetClipboardData(CF_TEXT, hMem); + } + + CloseClipboard(); + GlobalFree(hMem); + } +} +#endif + +/** + outTitle should be set before the call + */ +static void createErrorMessage( + const char* expression, + const std::string& message, + const char* filename, + int lineNumber, + std::string& outTitle, + std::string& outMessage) { + + std::string le = ""; + const char* newline = "\n"; + + #ifdef G3D_WIN32 + newline = "\r\n"; + + // The last error value. (Which is preserved across the call). + DWORD lastErr = GetLastError(); + + // The decoded message from FormatMessage + LPTSTR formatMsg = NULL; + + if (NULL == formatMsg) { + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_IGNORE_INSERTS | + FORMAT_MESSAGE_FROM_SYSTEM, + NULL, + lastErr, + 0, + (LPTSTR)&formatMsg, + 0, + NULL); + } + + // Make sure the message got translated into something. + LPTSTR realLastErr; + if (NULL != formatMsg) { + realLastErr = formatMsg; + } else { + realLastErr = _T("Last error code does not exist."); + } + + if (lastErr != 0) { + le = G3D::format("Last Error (0x%08X): %s\r\n\r\n", lastErr, (LPCSTR)realLastErr); + } + + // Get rid of the allocated memory from FormatMessage. + if (NULL != formatMsg) { + LocalFree((LPVOID)formatMsg); + } + + char modulePath[MAX_PATH]; + GetModuleFileNameA(NULL, modulePath, MAX_PATH); + + const char* moduleName = strrchr(modulePath, '\\'); + outTitle = outTitle + string(" - ") + string(moduleName ? (moduleName + 1) : modulePath); + + #endif + + // Build the message. + outMessage = + G3D::format("%s%s%sExpression: %s%s%s:%d%s%s%s", + message.c_str(), newline, newline, expression, newline, + filename, lineNumber, newline, newline, le.c_str()); +} + + +bool _handleDebugAssert_( + const char* expression, + const std::string& message, + const char* filename, + int lineNumber, + bool useGuiPrompt) { + + std::string dialogTitle = "Assertion Failure"; + std::string dialogText = ""; + createErrorMessage(expression, message, filename, lineNumber, dialogTitle, dialogText); + + #ifdef G3D_WIN32 + DWORD lastErr = GetLastError(); + postToClipboard(dialogText.c_str()); + debugPrintf("\n%s\n", dialogText.c_str()); + #endif + + const int cBreak = 0; + const int cIgnore = 1; + const int cAbort = 2; + + static const char* choices[] = {"Debug", "Ignore", "Exit"}; + + // Log the error + Log::common()->print(std::string("\n**************************\n\n") + dialogTitle + "\n" + dialogText); + + int result = G3D::prompt(dialogTitle.c_str(), dialogText.c_str(), (const char**)choices, 3, useGuiPrompt); + +# ifdef G3D_WIN32 + // Put the incoming last error back. + SetLastError(lastErr); +# endif + + switch (result) { + // -1 shouldn't actually occur because it means + // that we're in release mode. + case -1: + case cBreak: + return true; + break; + + case cIgnore: + return false; + break; + + case cAbort: + exit(-1); + break; + } + + // Should never get here + return false; +} + + +bool _handleErrorCheck_( + const char* expression, + const std::string& message, + const char* filename, + int lineNumber, + bool useGuiPrompt) { + + std::string dialogTitle = "Critical Error"; + std::string dialogText = ""; + + createErrorMessage(expression, message, filename, lineNumber, dialogTitle, dialogText); + + // Log the error + Log::common()->print(std::string("\n**************************\n\n") + dialogTitle + "\n" + dialogText); + #ifdef G3D_WIN32 + DWORD lastErr = GetLastError(); + (void)lastErr; + postToClipboard(dialogText.c_str()); + debugPrintf("\n%s\n", dialogText.c_str()); + #endif + + static const char* choices[] = {"Ok"}; + + const std::string& m = + std::string("An internal error has occured in this program and it will now close. " + "The specific error is below. More information has been saved in \"") + + Log::getCommonLogFilename() + "\".\n" + dialogText; + + int result = G3D::prompt("Error", m.c_str(), (const char**)choices, 1, useGuiPrompt); + (void)result; + + return true; +} + + +#ifdef G3D_WIN32 +static HCURSOR oldCursor; +static RECT oldCursorRect; +static POINT oldCursorPos; +static int oldShowCursorCount; +#endif + +void _releaseInputGrab_() { + #ifdef G3D_WIN32 + + GetCursorPos(&oldCursorPos); + + // Stop hiding the cursor if the application hid it. + oldShowCursorCount = ShowCursor(true) - 1; + + if (oldShowCursorCount < -1) { + for (int c = oldShowCursorCount; c < -1; ++c) { + ShowCursor(true); + } + } + + // Set the default cursor in case the application + // set the cursor to NULL. + oldCursor = GetCursor(); + SetCursor(LoadCursor(NULL, IDC_ARROW)); + + // Allow the cursor full access to the screen + GetClipCursor(&oldCursorRect); + ClipCursor(NULL); + + #elif defined(G3D_LINUX) +#if SOMEONE_MADE_THIS_USEFUL + if (x11Display != NULL) { + XUngrabPointer(x11Display, CurrentTime); + XUngrabKeyboard(x11Display, CurrentTime); + if (x11Window != 0) { + //XUndefineCursor(x11Display, x11Window); + // TODO: Note that we leak this cursor; it should be + // freed in the restore code. + Cursor c = XCreateFontCursor(x11Display, 68); + XDefineCursor(x11Display, x11Window, c); + } + XSync(x11Display, false); + XAllowEvents(x11Display, AsyncPointer, CurrentTime); + XFlush(x11Display); + } +#endif + #elif defined(G3D_OSX) + // TODO: OS X + #endif +} + + +void _restoreInputGrab_() { + #ifdef G3D_WIN32 + + // Restore the old clipping region + ClipCursor(&oldCursorRect); + + SetCursorPos(oldCursorPos.x, oldCursorPos.y); + + // Restore the old cursor + SetCursor(oldCursor); + + // Restore old visibility count + if (oldShowCursorCount < 0) { + for (int c = 0; c > oldShowCursorCount; --c) { + ShowCursor(false); + } + } + + #elif defined(G3D_LINUX) + // TODO: Linux + #elif defined(G3D_OSX) + // TODO: OS X + #endif +} + + +}; // internal namespace + +void setAssertionHook(AssertionHook hook) { + G3D::_internal::_debugHook = hook; +} + +AssertionHook assertionHook() { + return G3D::_internal::_debugHook; +} + +void setFailureHook(AssertionHook hook) { + G3D::_internal::_failureHook = hook; +} + +AssertionHook failureHook() { + return G3D::_internal::_failureHook; +} + + +void setConsolePrintHook(ConsolePrintHook h) { + G3D::_internal::_consolePrintHook = h; +} + +ConsolePrintHook consolePrintHook() { + return G3D::_internal::_consolePrintHook; +} + + +std::string __cdecl debugPrint(const std::string& s) { +# ifdef G3D_WIN32 + const int MAX_STRING_LEN = 1024; + + // Windows can't handle really long strings sent to + // the console, so we break the string. + if (s.size() < MAX_STRING_LEN) { + OutputDebugStringA(s.c_str()); + } else { + for (unsigned int i = 0; i < s.size(); i += MAX_STRING_LEN) { + std::string sub = s.substr(i, MAX_STRING_LEN); + OutputDebugStringA(sub.c_str()); + } + } +# else + fprintf(stderr, "%s", s.c_str()); + fflush(stderr); +# endif + + return s; +} + +std::string __cdecl debugPrintf(const char* fmt ...) { + va_list argList; + va_start(argList, fmt); + std::string s = G3D::vformat(fmt, argList); + va_end(argList); + + return debugPrint(s); +// return debugPrint(consolePrint(s)); +} + +std::string consolePrint(const std::string& s) { + FILE* L = Log::common()->getFile(); + fprintf(L, "%s", s.c_str()); + + if (consolePrintHook()) { + consolePrintHook()(s); + } + + fflush(L); + return s; +} + + +std::string __cdecl consolePrintf(const char* fmt ...) { + va_list argList; + va_start(argList, fmt); + std::string s = G3D::vformat(fmt, argList); + va_end(argList); + + return consolePrint(s); +} + +} // namespace + +#ifdef _MSC_VER +# pragma warning (pop) +#endif diff --git a/dep/src/g3dlite/fileutils.cpp b/dep/src/g3dlite/fileutils.cpp new file mode 100644 index 00000000000..3f5eb579ba9 --- /dev/null +++ b/dep/src/g3dlite/fileutils.cpp @@ -0,0 +1,1165 @@ +/** + @file fileutils.cpp + + @author Morgan McGuire, graphics3d.com + + @author 2002-06-06 + @edited 2010-02-05 + */ + +#include <cstring> +#include <cstdio> +#include "G3D/platform.h" +#include "G3D/fileutils.h" +#include "G3D/BinaryInput.h" +#include "G3D/BinaryOutput.h" +#include "G3D/g3dmath.h" +#include "G3D/stringutils.h" +#include "G3D/Set.h" +#include "G3D/g3dfnmatch.h" + +#include <sys/stat.h> +#include <sys/types.h> +#if _HAVE_ZIP + #include "zip.h" +#endif + +#ifdef G3D_WIN32 + // Needed for _getcwd + #include <direct.h> + #include <io.h> +#else + #include <dirent.h> + #include <fnmatch.h> + #include <unistd.h> + #define _getcwd getcwd + #define _stat stat +#endif + + +namespace G3D { + +namespace _internal { + Set<std::string> currentFilesUsed; +} + +std::string pathConcat(const std::string& dirname, const std::string& file) { + // Ensure that the directory ends in a slash + if ((dirname.size() != 0) && + (dirname[dirname.size() - 1] != '/') && + (dirname[dirname.size() - 1] != '\\') && + (dirname[dirname.size() - 1] != ':')) { + return dirname + '/' + file; + } else { + return dirname + file; + } +} + +std::string resolveFilename(const std::string& filename) { + if (filename.size() >= 1) { + if ((filename[0] == '/') || (filename[0] == '\\')) { + // Already resolved + return filename; + } else { + + #ifdef G3D_WIN32 + if ((filename.size() >= 2) && (filename[1] == ':')) { + // There is a drive spec on the front. + if ((filename.size() >= 3) && ((filename[2] == '\\') || + (filename[2] == '/'))) { + // Already fully qualified + return filename; + } else { + // The drive spec is relative to the + // working directory on that drive. + debugAssertM(false, "Files of the form d:path are" + " not supported (use a fully qualified" + " name)."); + return filename; + } + } + #endif + } + } + + char buffer[1024]; + + // Prepend the working directory. + _getcwd(buffer, 1024); + + return format("%s/%s", buffer, filename.c_str()); +} + +bool zipfileExists(const std::string& filename) { + std::string outZipfile; + std::string outInternalFile; + return zipfileExists(filename, outZipfile, outInternalFile); +} + +std::string readWholeFile( + const std::string& filename) { + + _internal::currentFilesUsed.insert(filename); + + std::string s; + + debugAssert(filename != ""); + if (fileExists(filename, false)) { + + int64 length = fileLength(filename); + + char* buffer = (char*)System::alignedMalloc(length + 1, 16); + debugAssert(buffer); + FILE* f = fopen(filename.c_str(), "rb"); + debugAssert(f); + int ret = fread(buffer, 1, length, f); + debugAssert(ret == length);(void)ret; + fclose(f); + + buffer[length] = '\0'; + s = std::string(buffer); + + System::alignedFree(buffer); + + } else if (zipfileExists(filename)) { + + void* zipBuffer; + size_t length; + zipRead(filename, zipBuffer, length); + + char* buffer = (char*)System::alignedMalloc(length + 1, 16); + System::memcpy(buffer,zipBuffer, length + 1); + zipClose(zipBuffer); + + buffer[length] = '\0'; + s = std::string(buffer); + System::alignedFree(buffer); + } else { + debugAssertM(false, filename + " not found"); + } + + return s; +} + + +void zipRead(const std::string& file, + void*& data, + size_t& length) { + std::string zip, desiredFile; +#if _HAVE_ZIP + if (zipfileExists(file, zip, desiredFile)) { + struct zip *z = zip_open( zip.c_str(), ZIP_CHECKCONS, NULL ); + { + struct zip_stat info; + zip_stat_init( &info ); // TODO: Docs unclear if zip_stat_init is required. + zip_stat( z, desiredFile.c_str(), ZIP_FL_NOCASE, &info ); + length = info.size; + // sets machines up to use MMX, if they want + data = System::alignedMalloc(length, 16); + struct zip_file *zf = zip_fopen( z, desiredFile.c_str(), ZIP_FL_NOCASE ); + { + int test = zip_fread( zf, data, length ); + debugAssertM((size_t)test == length, + desiredFile + " was corrupt because it unzipped to the wrong size."); + (void)test; + } + zip_fclose( zf ); + } + zip_close( z ); + } else { + data = NULL; + } +#else + data = NULL; +#endif +} + + +void zipClose(void* data) { + System::alignedFree(data); +} + + +int64 fileLength(const std::string& filename) { + struct _stat st; + int result = _stat(filename.c_str(), &st); + + if (result == -1) { +#if _HAVE_ZIP + std::string zip, contents; + if(zipfileExists(filename, zip, contents)){ + int64 requiredMem; + + struct zip *z = zip_open( zip.c_str(), ZIP_CHECKCONS, NULL ); + debugAssertM(z != NULL, zip + ": zip open failed."); + { + struct zip_stat info; + zip_stat_init( &info ); // TODO: Docs unclear if zip_stat_init is required. + int success = zip_stat( z, contents.c_str(), ZIP_FL_NOCASE, &info ); + debugAssertM(success == 0, zip + ": " + contents + ": zip stat failed."); + requiredMem = info.size; + } + zip_close( z ); + return requiredMem; + } else { + return -1; + } +#else + return -1; +#endif + } + + return st.st_size; +} + +/** Used by robustTmpfile. Returns nonzero if fread, fwrite, and fseek all +succeed on the file. + @author Morgan McGuire, http://graphics.cs.williams.edu */ +static int isFileGood(FILE* f) { + + int x, n, result; + + /* Must be a valid file handle */ + if (f == NULL) { + return 0; + } + + /* Try to write */ + x = 1234; + n = fwrite(&x, sizeof(int), 1, f); + + if (n != 1) { + return 0; + } + + /* Seek back to the beginning */ + result = fseek(f, 0, SEEK_SET); + if (result != 0) { + return 0; + } + + /* Read */ + n = fread(&x, sizeof(int), 1, f); + if (n != 1) { + return 0; + } + + /* Seek back to the beginning again */ + fseek(f, 0, SEEK_SET); + + return 1; +} + +FILE* createTempFile() { + FILE* t = NULL; + +//# ifdef G3D_WIN32 + t = tmpfile(); +//# else +// // On Unix, tmpfile generates a warning for any code that links against it. +// const char* tempfilename = "/tmp/g3dtemp.XXXXXXXX"; +// mktemp(tempfilename); +// t = fopen(tempfilename, "w"); +//# endif + +# ifdef _WIN32 + char* n = NULL; +# endif + char name[256]; + + if (isFileGood(t)) { + return t; + } + +# ifdef G3D_WIN32 + /* tmpfile failed; try the tmpnam routine */ + t = fopen(tmpnam(NULL), "w+"); + if (isFileGood(t)) { + return t; + } + + n = _tempnam("c:/tmp/", "t"); + /* Try to create something in C:\tmp */ + t = fopen(n, "w+"); + if (isFileGood(t)) { + return t; + } + + /* Try c:\temp */ + n = _tempnam("c:/temp/", "t"); + t = fopen(n, "w+"); + if (isFileGood(t)) { + return t; + } + + /* try the current directory */ + n = _tempnam("./", "t"); + t = fopen(n, "w+"); + if (isFileGood(t)) { + return t; + } + + sprintf(name, "%s/tmp%d", "c:/temp", rand()); + t = fopen(name, "w+"); + if (isFileGood(t)) { + return t; + } + + /* Try some hardcoded paths */ + sprintf(name, "%s/tmp%d", "c:/tmp", rand()); + t = fopen(name, "w+"); + if (isFileGood(t)) { + return t; + } +# else + sprintf(name, "%s/tmp%d", "/tmp", rand()); + t = fopen(name, "w+"); + if (isFileGood(t)) { + return t; + } +#endif + + sprintf(name, "tmp%d", rand()); + t = fopen(name, "w+"); + if (isFileGood(t)) { + return t; + } + + fprintf(stderr, "Unable to create a temporary file; robustTmpfile returning NULL\n"); + + return NULL; +} + +/////////////////////////////////////////////////////////////////////////////// +void writeWholeFile( + const std::string& filename, + const std::string& str, + bool flush) { + + // Make sure the directory exists. + std::string root, base, ext, path; + Array<std::string> pathArray; + parseFilename(filename, root, pathArray, base, ext); + + path = root + stringJoin(pathArray, '/'); + if (! fileExists(path, false)) { + createDirectory(path); + } + + FILE* file = fopen(filename.c_str(), "wb"); + + debugAssert(file); + + fwrite(str.c_str(), str.size(), 1, file); + + if (flush) { + fflush(file); + } + fclose(file); +} + +/////////////////////////////////////////////////////////////////////////////// + +/** + Creates the directory (which may optionally end in a /) + and any parents needed to reach it. + */ +void createDirectory( + const std::string& dir) { + + if (dir == "") { + return; + } + + std::string d; + + // Add a trailing / if there isn't one. + switch (dir[dir.size() - 1]) { + case '/': + case '\\': + d = dir; + break; + + default: + d = dir + "/"; + } + + // If it already exists, do nothing + if (fileExists(d.substr(0, d.size() - 1)), false) { + return; + } + + // Parse the name apart + std::string root, base, ext; + Array<std::string> path; + + std::string lead; + parseFilename(d, root, path, base, ext); + debugAssert(base == ""); + debugAssert(ext == ""); + + // Begin with an extra period so "c:\" becomes "c:\.\" after + // appending a path and "c:" becomes "c:.\", not root: "c:\" + std::string p = root + "."; + + // Create any intermediate that doesn't exist + for (int i = 0; i < path.size(); ++i) { + p += "/" + path[i]; + if (! fileExists(p, false)) { + // Windows only requires one argument to mkdir, + // where as unix also requires the permissions. +# ifndef G3D_WIN32 + mkdir(p.c_str(), 0777); +# else + _mkdir(p.c_str()); +# endif + } + } +} + +/////////////////////////////////////////////////////////////////////////////// + +class FileSystemCache { +private: + + Table<std::string, Array<std::string> > m_files; + +public: + + bool fileExists(const std::string& filename) { + const std::string& path = resolveFilename(filenamePath(filename)); + const std::string& name = filenameBaseExt(filename); + + bool neverBeforeSeen = false; + Array<std::string>& fileList = m_files.getCreate(path, neverBeforeSeen); + if (neverBeforeSeen) { + if (! G3D::fileExists(path, true, false)) { + // The path itself doesn't exist... back out our insertion (which makes fileList& invalid) + m_files.remove(path); + return false; + } + + std::string spec = pathConcat(path, "*"); + + // Will automatically recurse into zipfiles + getFiles(spec, fileList); + getDirs(spec, fileList); + +# ifdef G3D_WIN32 + { + // Case insensitive + for (int i = 0; i < fileList.size(); ++i) { + fileList[i] = toLower(fileList[i]); + } + } +# endif + } + + if (filenameContainsWildcards(name)) { + // See if anything matches + for (int i = 0; i < fileList.size(); ++i) { + if (g3dfnmatch(name.c_str(), fileList[i].c_str(), 0) == 0) { + return true; + } + } + return false; + } else { + // On windows, this is a lower-lower comparison, so it is case insensitive + return fileList.contains(name); + } + } + + void clear() { + m_files.clear(); + } + + static FileSystemCache& instance() { + static FileSystemCache i; + return i; + } +}; + + +void clearFileSystemCache() { + FileSystemCache::instance().clear(); +} + +bool fileExists +(const std::string& _filename, + bool lookInZipfiles, + bool trustCache) { + + if (_filename.empty()) { + return false; + } + + // Remove trailing slash from directories + const std::string& filename = (endsWith(_filename, "/") || endsWith(_filename, "\\")) ? _filename.substr(0, _filename.length() - 1) : _filename; + + if (trustCache && lookInZipfiles) { +# ifdef G3D_WIN32 + // Case insensitive + return FileSystemCache::instance().fileExists(toLower(filename)); +# else + return FileSystemCache::instance().fileExists(filename); +# endif + } + + // Useful for debugging + //char curdir[1024]; _getcwd(curdir, 1024); + + struct _stat st; + int ret = _stat(filename.c_str(), &st); + + // _stat returns zero on success + bool exists = (ret == 0); + + if (! exists && lookInZipfiles) { + // Does not exist standalone, but might exist in a zipfile + + // These output arguments will be ignored + std::string zipDir, internalPath; + return zipfileExists(filename, zipDir, internalPath); + } else { + return exists; + } +} + +/////////////////////////////////////////////////////////////////////////////// + +#if _HAVE_ZIP +/* Helper methods for zipfileExists()*/ +// Given a string (the drive) and an array (the path), computes the directory +static void _zip_resolveDirectory(std::string& completeDir, const std::string& drive, const Array<std::string>& path, const int length){ + completeDir = drive; + int tempLength; + // if the given length is longer than the array, we correct it + if(length > path.length()){ + tempLength = path.length(); + } else{ + tempLength = length; + } + + for(int t = 0; t < tempLength; ++t){ + if(t > 0){ + completeDir += "/"; + } + completeDir += path[t]; + } +} + + +// assumes that zipDir references a .zip file +static bool _zip_zipContains(const std::string& zipDir, const std::string& desiredFile){ + struct zip *z = zip_open( zipDir.c_str(), ZIP_CHECKCONS, NULL ); + //the last parameter, an int, determines case sensitivity: + //1 is sensitive, 2 is not, 0 is default + int test = zip_name_locate( z, desiredFile.c_str(), ZIP_FL_NOCASE ); + zip_close( z ); + if(test == -1){ + return false; + } + return true; +} +#endif + +// If no zipfile exists, outZipfile and outInternalFile are unchanged +bool zipfileExists(const std::string& filename, std::string& outZipfile, + std::string& outInternalFile){ +#if _HAVE_ZIP + Array<std::string> path; + std::string drive, base, ext, zipfile, infile; + parseFilename(filename, drive, path, base, ext); + + // Put the filename back together + if ((base != "") && (ext != "")) { + infile = base + "." + ext; + } else { + infile = base + ext; + } + + // Remove "." from path + for (int i = 0; i < path.length(); ++i) { + if (path[i] == ".") { + path.remove(i); + --i; + } + } + + // Remove ".." from path + for (int i = 1; i < path.length(); ++i) { + if ((path[i] == "..") && (i > 0) && (path[i - 1] != "..")) { + // Remove both i and i - 1 + path.remove(i - 1, 2); + i -= 2; + } + } + + // Walk the path backwards, accumulating pieces onto the infile until + // we find a zipfile that contains it + for (int t = 0; t < path.length(); ++t){ + _zip_resolveDirectory(zipfile, drive, path, path.length() - t); + if (t > 0) { + infile = path[path.length() - t] + "/" + infile; + } + + if (endsWith(zipfile, "..")) { + return false; + } + + if (fileExists(zipfile, false)) { + // test if it actually is a zipfile + // if not, return false, a bad + // directory structure has been given, + // not a .zip + if (isZipfile(zipfile)){ + + if (_zip_zipContains(zipfile, infile)){ + outZipfile = zipfile; + outInternalFile = infile; + return true; + } else { + return false; + } + } else { + // the directory structure was valid but did not point to a .zip + return false; + } + } + + } +#endif + // not a valid directory structure ever, + // obviously no .zip was found within the path + return false; +} + +/////////////////////////////////////////////////////////////////////////////// + +std::string generateFilenameBase(const std::string& prefix, const std::string& suffix) { + Array<std::string> exist; + + // Note "template" is a reserved word in C++ + std::string templat = prefix + System::currentDateString() + "_"; + getFiles(templat + "*", exist); + + // Remove extensions + for (int i = 0; i < exist.size(); ++i) { + exist[i] = filenameBase(exist[i]); + } + + int num = 0; + std::string result; + templat += "%03d" + suffix; + do { + result = format(templat.c_str(), num); + ++num; + } while (exist.contains(result)); + + return result; +} + +/////////////////////////////////////////////////////////////////////////////// + +void copyFile( + const std::string& source, + const std::string& dest) { + + #ifdef G3D_WIN32 + CopyFileA(source.c_str(), dest.c_str(), FALSE); + #else + // TODO: don't use BinaryInput and BinaryOutput + // Read it all in, then dump it out + BinaryInput in(source, G3D_LITTLE_ENDIAN); + BinaryOutput out(dest, G3D_LITTLE_ENDIAN); + out.writeBytes(in.getCArray(), in.size()); + out.commit(false); + #endif +} + +////////////////////////////////////////////////////////////////////////////// + +void parseFilename( + const std::string& filename, + std::string& root, + Array<std::string>& path, + std::string& base, + std::string& ext) { + + std::string f = filename; + + root = ""; + path.clear(); + base = ""; + ext = ""; + + if (f == "") { + // Empty filename + return; + } + + // See if there is a root/drive spec. + if ((f.size() >= 2) && (f[1] == ':')) { + + if ((f.size() > 2) && isSlash(f[2])) { + + // e.g. c:\foo + root = f.substr(0, 3); + f = f.substr(3, f.size() - 3); + + } else { + + // e.g. c:foo + root = f.substr(2); + f = f.substr(2, f.size() - 2); + + } + + } else if ((f.size() >= 2) & isSlash(f[0]) && isSlash(f[1])) { + + // e.g. //foo + root = f.substr(0, 2); + f = f.substr(2, f.size() - 2); + + } else if (isSlash(f[0])) { + + root = f.substr(0, 1); + f = f.substr(1, f.size() - 1); + + } + + // Pull the extension off + { + // Find the period + size_t i = f.rfind('.'); + + if (i != std::string::npos) { + // Make sure it is after the last slash! + size_t j = iMax(f.rfind('/'), f.rfind('\\')); + if ((j == std::string::npos) || (i > j)) { + ext = f.substr(i + 1, f.size() - i - 1); + f = f.substr(0, i); + } + } + } + + // Pull the basename off + { + // Find the last slash + size_t i = iMax(f.rfind('/'), f.rfind('\\')); + + if (i == std::string::npos) { + + // There is no slash; the basename is the whole thing + base = f; + f = ""; + + } else if ((i != std::string::npos) && (i < f.size() - 1)) { + + base = f.substr(i + 1, f.size() - i - 1); + f = f.substr(0, i); + + } + } + + // Parse what remains into path. + size_t prev, cur = 0; + + while (cur < f.size()) { + prev = cur; + + // Allow either slash + size_t i = f.find('/', prev + 1); + size_t j = f.find('\\', prev + 1); + if (i == std::string::npos) { + i = f.size(); + } + + if (j == std::string::npos) { + j = f.size(); + } + + cur = iMin(i, j); + + if (cur == std::string::npos) { + cur = f.size(); + } + + path.append(f.substr(prev, cur - prev)); + ++cur; + } +} + + +/** + Helper for getFileList and getDirectoryList. + + @param wantFiles If false, returns the directories, otherwise + returns the files. + @param includePath If true, the names include paths + */ +static void getFileOrDirListNormal +(const std::string& filespec, + Array<std::string>& files, + bool wantFiles, + bool includePath) { + + bool test = wantFiles ? true : false; + + std::string path = ""; + + // Find the place where the path ends and the file-spec begins + size_t i = filespec.rfind('/'); + size_t j = filespec.rfind('\\'); + + // Drive letters on Windows can separate a path + size_t k = filespec.rfind(':'); + + if (((j != std::string::npos) && (j > i)) || + (i == std::string::npos)) { + i = j; + } + + if (((k != std::string::npos) && (k > i)) || + (i == std::string::npos)) { + i = k; + } + + // If there is a path, pull it off + if (i != std::string::npos) { + path = filespec.substr(0, i + 1); + } + + std::string prefix = path; + + if (path.size() > 0) { + // Strip the trailing character + path = path.substr(0, path.size() - 1); + } + +# ifdef G3D_WIN32 + { + struct _finddata_t fileinfo; + + long handle = _findfirst(filespec.c_str(), &fileinfo); + int result = handle; + + while (result != -1) { + if ((((fileinfo.attrib & _A_SUBDIR) == 0) == test) && + strcmp(fileinfo.name, ".") && + strcmp(fileinfo.name, "..")) { + + if (includePath) { + files.append(prefix + fileinfo.name); + } else { + files.append(fileinfo.name); + } + } + + result = _findnext(handle, &fileinfo); + } + } +# else + { + if (path == "") { + // Empty paths don't work on Unix + path = "."; + } + + // Unix implementation + DIR* dir = opendir(path.c_str()); + + if (dir != NULL) { + struct dirent* entry = readdir(dir); + + while (entry != NULL) { + + // Exclude '.' and '..' + if ((strcmp(entry->d_name, ".") != 0) && + (strcmp(entry->d_name, "..") != 0)) { + + // Form a name with a path + std::string filename = prefix + entry->d_name; + // See if this is a file or a directory + struct _stat st; + bool exists = _stat(filename.c_str(), &st) != -1; + + if (exists && + + // Make sure it has the correct type + (((st.st_mode & S_IFDIR) == 0) == test) && + + // Make sure it matches the wildcard + (fnmatch(filespec.c_str(), + filename.c_str(), + FNM_PATHNAME) == 0)) { + + if (includePath) { + files.append(filename); + } else { + files.append(entry->d_name); + } + } + } + + entry = readdir(dir); + } + closedir(dir); + } + } +# endif +} + +#if _HAVE_ZIP +/** + @param path The zipfile name (no trailing slash) + @param prefix Directory inside the zipfile. No leading slash, must have trailing slash if non-empty. + @param file Name inside the zipfile that we are testing to see if it matches prefix + "*" + */ +static void _zip_addEntry(const std::string& path, + const std::string& prefix, + const std::string& file, + Set<std::string>& files, + bool wantFiles, + bool includePath) { + + // Make certain we are within the desired parent folder (prefix) + if (beginsWith(file, prefix)) { + // validityTest was prefix/file + + // Extract everything to the right of the prefix + std::string s = file.substr(prefix.length()); + + if (s == "") { + // This was the name of the prefix + return; + } + + // See if there are any slashes + size_t slashPos = s.find('/'); + + bool add = false; + + if (slashPos == std::string::npos) { + // No slashes, so s must be a file + add = wantFiles; + } else if (! wantFiles) { + // Not all zipfiles list directories as explicit entries. + // Because of this, if we're looking for directories and see + // any path longer than prefix, we must add the subdirectory. + // The Set will fix duplicates for us. + s = s.substr(0, slashPos); + add = true; + } + + if (add) { + if (includePath) { + files.insert(path + "/" + prefix + s); + } else { + files.insert(s); + } + } + } +} +#endif + +static void getFileOrDirListZip(const std::string& path, + const std::string& prefix, + Array<std::string>& files, + bool wantFiles, + bool includePath){ +#if _HAVE_ZIP + struct zip *z = zip_open( path.c_str(), ZIP_CHECKCONS, NULL ); + + Set<std::string> fileSet; + + int count = zip_get_num_files( z ); + for( int i = 0; i < count; ++i ) { + struct zip_stat info; + zip_stat_init( &info ); // TODO: Docs unclear if zip_stat_init is required. + zip_stat_index( z, i, ZIP_FL_NOCASE, &info ); + _zip_addEntry(path, prefix, info.name, fileSet, wantFiles, includePath); + } + + zip_close( z ); + + fileSet.getMembers(files); +#endif +} + + +static void determineFileOrDirList( + const std::string& filespec, + Array<std::string>& files, + bool wantFiles, + bool includePath) { + + // if it is a .zip, prefix will specify the folder within + // whose contents we want to see + std::string prefix = ""; + std::string path = filenamePath(filespec); + + if ((path.size() > 0) && isSlash(path[path.size() - 1])) { + // Strip the trailing slash + path = path.substr(0, path.length() -1); + } + + if ((path == "") || fileExists(path, false)) { + if ((path != "") && isZipfile(path)) { + // .zip should only work if * is specified as the Base + Ext + // Here, we have been asked for the root's contents + debugAssertM(filenameBaseExt(filespec) == "*", "Can only call getFiles/getDirs on zipfiles using '*' wildcard"); + getFileOrDirListZip(path, prefix, files, wantFiles, includePath); + } else { + // It is a normal directory + getFileOrDirListNormal(filespec, files, wantFiles, includePath); + } + } else if (zipfileExists(filenamePath(filespec), path, prefix)) { + // .zip should only work if * is specified as the Base + Ext + // Here, we have been asked for the contents of a folder within the .zip + debugAssertM(filenameBaseExt(filespec) == "*", "Can only call getFiles/getDirs on zipfiles using '*' wildcard"); + getFileOrDirListZip(path, prefix, files, wantFiles, includePath); + } +} + + +void getFiles(const std::string& filespec, + Array<std::string>& files, + bool includePath) { + + determineFileOrDirList(filespec, files, true, includePath); +} + + +void getDirs( + const std::string& filespec, + Array<std::string>& files, + bool includePath) { + + determineFileOrDirList(filespec, files, false, includePath); +} + + +std::string filenameBaseExt(const std::string& filename) { + int i = filename.rfind("/"); + int j = filename.rfind("\\"); + + if ((j > i) && (j >= 0)) { + i = j; + } + +# ifdef G3D_WIN32 + j = filename.rfind(":"); + if ((i == -1) && (j >= 0)) { + i = j; + } +# endif + + if (i == -1) { + return filename; + } else { + return filename.substr(i + 1, filename.length() - i); + } +} + + +std::string filenameBase(const std::string& s) { + std::string drive; + std::string base; + std::string ext; + Array<std::string> path; + + parseFilename(s, drive, path, base, ext); + return base; +} + + +std::string filenameExt(const std::string& filename) { + int i = filename.rfind("."); + if (i >= 0) { + return filename.substr(i + 1, filename.length() - i); + } else { + return ""; + } +} + + +std::string filenamePath(const std::string& filename) { + int i = filename.rfind("/"); + int j = filename.rfind("\\"); + + if ((j > i) && (j >= 0)) { + i = j; + } + +# ifdef G3D_WIN32 + j = filename.rfind(":"); + if ((i == -1) && (j >= 0)) { + i = j; + } +# endif + + if (i == -1) { + return ""; + } else { + return filename.substr(0, i+1); + } +} + + +bool isZipfile(const std::string& filename) { + + FILE* f = fopen(filename.c_str(), "r"); + if (f == NULL) { + return false; + } + uint8 header[4]; + fread(header, 4, 1, f); + + const uint8 zipHeader[4] = {0x50, 0x4b, 0x03, 0x04}; + for (int i = 0; i < 4; ++i) { + if (header[i] != zipHeader[i]) { + fclose(f); + return false; + } + } + + fclose(f); + return true; +} + + +bool isDirectory(const std::string& filename) { + struct _stat st; + bool exists = _stat(filename.c_str(), &st) != -1; + return exists && ((st.st_mode & S_IFDIR) != 0); +} + + +bool filenameContainsWildcards(const std::string& filename) { + return (filename.find('*') != std::string::npos) || (filename.find('?') != std::string::npos); +} + + +bool fileIsNewer(const std::string& src, const std::string& dst) { + struct _stat sts; + bool sexists = _stat(src.c_str(), &sts) != -1; + + struct _stat dts; + bool dexists = _stat(dst.c_str(), &dts) != -1; + + return sexists && ((! dexists) || (sts.st_mtime > dts.st_mtime)); +} + + +Array<std::string> filesUsed() { + Array<std::string> f; + _internal::currentFilesUsed.getMembers(f); + return f; +} + +} + +#ifndef G3D_WIN32 + #undef _stat +#endif diff --git a/dep/src/g3dlite/filter.cpp b/dep/src/g3dlite/filter.cpp new file mode 100644 index 00000000000..72d6f0e05a7 --- /dev/null +++ b/dep/src/g3dlite/filter.cpp @@ -0,0 +1,32 @@ +/** + @file filter.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + @created 2007-03-01 + @edited 2007-03-01 + + Copyright 2000-2007, Morgan McGuire. + All rights reserved. + */ +#include "G3D/filter.h" + +namespace G3D { + +void gaussian1D(Array<float>& coeff, int N, float std) { + coeff.resize(N); + float sum = 0.0f; + for (int i = 0; i < N; ++i) { + float x = i - (N - 1) / 2.0f; + float p = -square(x / std) / 2.0f; + float y = exp(p); + coeff[i] = y; + sum += y; + } + + for (int i = 0; i < N; ++i) { + coeff[i] /= sum; + } +} + + +} // namespace diff --git a/dep/src/g3dlite/format.cpp b/dep/src/g3dlite/format.cpp index 13f01e26e6b..d9d1b516393 100644 --- a/dep/src/g3dlite/format.cpp +++ b/dep/src/g3dlite/format.cpp @@ -4,22 +4,13 @@ @author Morgan McGuire, graphics3d.com @created 2000-09-09 - @edited 2006-04-30 + @edited 2006-08-14 */ #include "G3D/format.h" #include "G3D/platform.h" #include "G3D/System.h" -#ifdef G3D_WIN32 - #include <math.h> - #define vsnprintf _vsnprintf - #define NEWLINE "\r\n" -#else - #include <stdarg.h> - #define NEWLINE "\n" -#endif - #ifdef _MSC_VER // disable: "C++ exception handler used" # pragma warning (push) @@ -31,7 +22,7 @@ namespace G3D { -std::string format(const char* fmt,...) { +std::string __cdecl format(const char* fmt,...) { va_list argList; va_start(argList,fmt); std::string result = vformat(fmt, argList); @@ -40,10 +31,10 @@ std::string format(const char* fmt,...) { return result; } -#if defined(G3D_WIN32) && (_MSC_VER >= 1300) -// Both MSVC6 and 7 seem to use the non-standard vsnprintf +#if defined(_MSC_VER) && (_MSC_VER >= 1300) +// Both MSVC seems to use the non-standard vsnprintf // so we are using vscprintf to determine buffer size, however -// only MSVC7 headers include vscprintf for some reason. +// only MSVC7 and up headers include vscprintf for some reason. std::string vformat(const char *fmt, va_list argPtr) { // We draw the line at a 1MB string. const int maxSize = 1000000; @@ -52,8 +43,9 @@ std::string vformat(const char *fmt, va_list argPtr) { // allocate it on the stack because this saves // the malloc/free time. const int bufSize = 161; - char stackBuffer[bufSize]; + char stackBuffer[bufSize]; + // MSVC does not support va_copy int actualSize = _vscprintf(fmt, argPtr) + 1; if (actualSize > bufSize) { @@ -64,11 +56,11 @@ std::string vformat(const char *fmt, va_list argPtr) { if (actualSize < maxSize) { heapBuffer = (char*)System::malloc(maxSize + 1); - vsnprintf(heapBuffer, maxSize, fmt, argPtr); + _vsnprintf(heapBuffer, maxSize, fmt, argPtr); heapBuffer[maxSize] = '\0'; } else { heapBuffer = (char*)System::malloc(actualSize); - vsprintf(heapBuffer, fmt, argPtr); + vsprintf(heapBuffer, fmt, argPtr); } std::string formattedString(heapBuffer); @@ -81,7 +73,7 @@ std::string vformat(const char *fmt, va_list argPtr) { } } -#elif defined(G3D_WIN32) && (_MSC_VER < 1300) +#elif defined(_MSC_VER) && (_MSC_VER < 1300) std::string vformat(const char *fmt, va_list argPtr) { // We draw the line at a 1MB string. @@ -91,9 +83,12 @@ std::string vformat(const char *fmt, va_list argPtr) { // allocate it on the stack because this saves // the malloc/free time. const int bufSize = 161; - char stackBuffer[bufSize]; + char stackBuffer[bufSize]; - int actualWritten = vsnprintf(stackBuffer, bufSize, fmt, argPtr); + // MSVC6 doesn't support va_copy, however it also seems to compile + // correctly if we just pass our argument list along. Note that + // this whole code block is only compiled if we're on MSVC6 anyway + int actualWritten = _vsnprintf(stackBuffer, bufSize, fmt, argPtr); // Not a big enough buffer, bufSize characters written if (actualWritten == -1) { @@ -101,8 +96,8 @@ std::string vformat(const char *fmt, va_list argPtr) { int heapSize = 512; double powSize = 1.0; char* heapBuffer = (char*)System::malloc(heapSize); - - while ((vsnprintf(heapBuffer, heapSize, fmt, argPtr) == -1) && + + while ((_vsnprintf(heapBuffer, heapSize, fmt, argPtr) == -1) && (heapSize < maxSize)) { heapSize = iCeil(heapSize * ::pow((double)2.0, powSize++)); @@ -133,18 +128,22 @@ std::string vformat(const char* fmt, va_list argPtr) { const int bufSize = 161; char stackBuffer[bufSize]; - int numChars = vsnprintf(stackBuffer, bufSize, fmt, argPtr); + va_list argPtrCopy; + va_copy(argPtrCopy, argPtr); + int numChars = vsnprintf(stackBuffer, bufSize, fmt, argPtrCopy); + va_end(argPtrCopy); if (numChars >= bufSize) { // We didn't allocate a big enough string. char* heapBuffer = (char*)System::malloc((numChars + 1) * sizeof(char)); - assert(heapBuffer); + debugAssert(heapBuffer); int numChars2 = vsnprintf(heapBuffer, numChars + 1, fmt, argPtr); - assert(numChars2 == numChars); + debugAssert(numChars2 == numChars); + (void)numChars2; std::string result(heapBuffer); - + System::free(heapBuffer); return result; @@ -160,13 +159,6 @@ std::string vformat(const char* fmt, va_list argPtr) { } // namespace -#ifdef G3D_WIN32 -# undef vsnprintf -#endif - #ifdef _MSC_VER # pragma warning (pop) #endif - -#undef NEWLINE - diff --git a/dep/src/g3dlite/g3dfnmatch.cpp b/dep/src/g3dlite/g3dfnmatch.cpp new file mode 100644 index 00000000000..39ef7b31914 --- /dev/null +++ b/dep/src/g3dlite/g3dfnmatch.cpp @@ -0,0 +1,204 @@ +/*- +* Copyright (c) 1992, 1993 +*The Regents of the University of California. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* 3. All advertising materials mentioning features or use of this software +* must display the following acknowledgement: +*This product includes software developed by the University of +*California, Berkeley and its contributors. +* 4. Neither the name of the University nor the names of its contributors +* may be used to endorse or promote products derived from this software +* without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +* SUCH DAMAGE. +* +*@(#)fnmatch.h8.1 (Berkeley) 6/2/93 +* +* From FreeBSD fnmatch.h 1.7 +* $Id: g3dfnmatch.cpp,v 1.2 2010/02/06 10:03:24 corey_taylor Exp $ +*/ +#include "G3D/g3dfnmatch.h" + +#ifdef G3D_WIN32 + +#include <ctype.h> +#include <string.h> +#include <stdio.h> + +namespace G3D { + +#define EOS '\0' + +static const char *rangematch(const char *, char, int); + +int g3dfnmatch(const char *pattern, const char *string, int flags) +{ + const char *stringstart; + char c, test; + + for (stringstart = string;;) + switch (c = *pattern++) { + case EOS: + if ((flags & FNM_LEADING_DIR) && *string == '/') + return (0); + return (*string == EOS ? 0 : FNM_NOMATCH); + case '?': + if (*string == EOS) + return (FNM_NOMATCH); + if (*string == '/' && (flags & FNM_PATHNAME)) + return (FNM_NOMATCH); + if (*string == '.' && (flags & FNM_PERIOD) && + (string == stringstart || + ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) + return (FNM_NOMATCH); + ++string; + break; + case '*': + c = *pattern; + /* Collapse multiple stars. */ + while (c == '*') + c = *++pattern; + + if (*string == '.' && (flags & FNM_PERIOD) && + (string == stringstart || + ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) + return (FNM_NOMATCH); + + /* Optimize for pattern with * at end or before /. */ + if (c == EOS) + if (flags & FNM_PATHNAME) + return ((flags & FNM_LEADING_DIR) || + strchr(string, '/') == NULL ? + 0 : FNM_NOMATCH); + else + return (0); + else if (c == '/' && flags & FNM_PATHNAME) { + if ((string = strchr(string, '/')) == NULL) + return (FNM_NOMATCH); + break; + } + + /* General case, use recursion. */ + while ((test = *string) != EOS) { + if (!rangematch(pattern, *string, flags & ~FNM_PERIOD)) + return (0); + if (test == '/' && flags & FNM_PATHNAME) + break; + ++string; + } + return (FNM_NOMATCH); + case '[': + if (*string == EOS) + return (FNM_NOMATCH); + if (*string == '/' && flags & FNM_PATHNAME) + return (FNM_NOMATCH); + if ((pattern = + rangematch(pattern, *string, flags)) == NULL) + return (FNM_NOMATCH); + ++string; + break; + case '\\': + if (!(flags & FNM_NOESCAPE)) { + if ((c = *pattern++) == EOS) { + c = '\\'; + --pattern; + } + } + /* FALLTHROUGH */ + default: + if (c == *string) + ; + else if ((flags & FNM_CASEFOLD) && + (tolower((unsigned char)c) == + tolower((unsigned char)*string))) + ; + else if ((flags & FNM_PREFIX_DIRS) && *string == EOS && + ((c == '/' && string != stringstart) || + (string == stringstart+1 && *stringstart == '/'))) + return (0); + else + return (FNM_NOMATCH); + string++; + break; + } + /* NOTREACHED */ +} + +static const char * +rangematch(const char *pattern, char test, int flags) +{ + int negate, ok; + char c, c2; + + /* + * A bracket expression starting with an unquoted circumflex + * character produces unspecified results (IEEE 1003.2-1992, + * 3.13.2). This implementation treats it like '!', for + * consistency with the regular expression syntax. + * J.T. Conklin (conklin@ngai.kaleida.com) + */ + if ( (negate = (*pattern == '!' || *pattern == '^')) ) + ++pattern; + + if (flags & FNM_CASEFOLD) + test = tolower((unsigned char)test); + + for (ok = 0; (c = *pattern++) != ']';) { + if (c == '\\' && !(flags & FNM_NOESCAPE)) + c = *pattern++; + if (c == EOS) + return (NULL); + + if (flags & FNM_CASEFOLD) + c = tolower((unsigned char)c); + + if (*pattern == '-' + && (c2 = *(pattern+1)) != EOS && c2 != ']') { + pattern += 2; + if (c2 == '\\' && !(flags & FNM_NOESCAPE)) + c2 = *pattern++; + if (c2 == EOS) + return (NULL); + + if (flags & FNM_CASEFOLD) + c2 = tolower((unsigned char)c2); + + if ((unsigned char)c <= (unsigned char)test && + (unsigned char)test <= (unsigned char)c2) + ok = 1; + } else if (c == test) + ok = 1; + } + return (ok == negate ? NULL : pattern); +} + +} + +#else + +namespace G3D { +int g3dfnmatch(const char * a, const char *b, int c) { + return fnmatch(a, b, c); +} +} + +#endif + diff --git a/dep/src/g3dlite/g3dmath.cpp b/dep/src/g3dlite/g3dmath.cpp new file mode 100644 index 00000000000..ad85e9efb9b --- /dev/null +++ b/dep/src/g3dlite/g3dmath.cpp @@ -0,0 +1,108 @@ +/** + @file g3dmath.cpp + + @author Morgan McGuire, graphics3d.com + + @created 2001-06-02 + @edited 2004-02-24 + */ + +#include "G3D/g3dmath.h" +#include <cstdlib> +#include <cstring> + +namespace G3D { + +float gaussRandom(float mean, float stdev) { + + // Using Box-Mueller method from http://www.taygeta.com/random/gaussian.html + // Modified to specify standard deviation and mean of distribution + float w, x1, x2; + + // Loop until w is less than 1 so that log(w) is negative + do { + x1 = uniformRandom(-1.0, 1.0); + x2 = uniformRandom(-1.0, 1.0); + + w = float(square(x1) + square(x2)); + } while (w > 1.0f); + + // Transform to gassian distribution + // Multiply by sigma (stdev ^ 2) and add mean. + return x2 * (float)square(stdev) * sqrtf((-2.0f * logf(w) ) / w) + mean; +} + +/** + This value should not be tested against directly, instead + G3D::isNan() and G3D::isFinite() will return reliable results. */ +double inf() { + return std::numeric_limits<double>::infinity(); +} + +bool isNaN(float x) { + static const float n = nan(); + return memcmp(&x, &n, sizeof(float)) == 0; +} + +bool isNaN(double x) { + static const double n = nan(); + return memcmp(&x, &n, sizeof(double)) == 0; +} + + +/** + This value should not be tested against directly, instead + G3D::isNan() and G3D::isFinite() will return reliable results. */ +float finf() { + return std::numeric_limits<float>::infinity(); +} + +/** This value should not be tested against directly, instead + G3D::isNan() and G3D::isFinite() will return reliable results. */ +double nan() { + // double is a standard type and should have quiet NaN + return std::numeric_limits<double>::quiet_NaN(); +} + +float fnan() { + // double is a standard type and should have quiet NaN + return std::numeric_limits<float>::quiet_NaN(); +} + + +int highestBit(uint32 x) { + // Binary search. + int base = 0; + + if (x & 0xffff0000) { + base = 16; + x >>= 16; + } + if (x & 0x0000ff00) { + base += 8; + x >>= 8; + } + if (x & 0x000000f0) { + base += 4; + x >>= 4; + } + + static const int lut[] = {-1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3}; + return base + lut[x]; +} + + +int iRandom(int low, int high) { + int r = iFloor(low + (high - low + 1) * (double)rand() / RAND_MAX); + + // There is a *very small* chance of generating + // a number larger than high. + if (r > high) { + return high; + } else { + return r; + } +} + + +} diff --git a/dep/src/g3dlite/license.cpp b/dep/src/g3dlite/license.cpp new file mode 100644 index 00000000000..5049184cf9b --- /dev/null +++ b/dep/src/g3dlite/license.cpp @@ -0,0 +1,73 @@ +/** + @file license.cpp + + @author Morgan McGuire, graphics3d.com + + @created 2004-04-15 + @edited 2004-04-15 +*/ + +#include "G3D/format.h" +#include <string> + +namespace G3D { + +std::string license() { + return format( + +"This software is based in part on the PNG Reference Library which is\n" +"Copyright (c) 2004 Glenn Randers-Pehrson\n\n" +"This software is based in part on the work of the Independent JPEG Group.\n\n" +"This software is based on part on the FFmpeg libavformat and libavcodec libraries\n" +"(\"FFmpeg\", http://ffmpeg.mplayerhq.hu), which are included under the terms of the\n" +"GNU Lesser General Public License (LGPL), (http://www.gnu.org/copyleft/lesser.html).\n\n" +"%s" +"This program uses the G3D Library (http://g3d.sf.net), which\n" +"is licensed under the \"Modified BSD\" Open Source license. The G3D library\n" +"source code is Copyright © 2000-2010, Morgan McGuire, All rights reserved.\n" +"This program uses The OpenGL Extension Wrangler Library, which \n" +"is licensed under the \"Modified BSD\" Open Source license. \n" +"The OpenGL Extension Wrangler Library source code is\n" +"Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>\n" +"Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>\n" +"Copyright (C) 2002, Lev Povalahev\n" +"All rights reserved.\n\n" +"The Modified BSD license is below, and requires the following statement:\n" +"\n" +"Redistribution and use in source and binary forms, with or without \n" +"modification, are permitted provided that the following conditions are met:\n" +"\n" +"* Redistributions of source code must retain the above copyright notice, \n" +" this list of conditions and the following disclaimer.\n" +"* Redistributions in binary form must reproduce the above copyright notice, \n" +" this list of conditions and the following disclaimer in the documentation \n" +" and/or other materials provided with the distribution.\n" +"* The name of the author may be used to endorse or promote products \n" +" derived from this software without specific prior written permission.\n" +"\n" +"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" \n" +"AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE \n" +"IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n" +"ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE \n" +"LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR \n" +"CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF \n" +"SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n" +"INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n" +"CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n" +"ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n" +"THE POSSIBILITY OF SUCH DAMAGE.\n" +"\n\n" +"G3D VERSION %d\n", + +#ifdef G3D_WIN32 + "" // Win32 doesn't use SDL +#else + "This software uses the Simple DirectMedia Layer library (\"SDL\",\n" + "http://www.libsdl.org), which is included under the terms of the\n" + "GNU Lesser General Public License, (http://www.gnu.org/copyleft/lesser.html).\n\n" +#endif +, +G3D_VER); +} + +} diff --git a/dep/src/g3dlite/license.html b/dep/src/g3dlite/license.html index 9bbb2ad5f9a..11c33882248 100644 --- a/dep/src/g3dlite/license.html +++ b/dep/src/g3dlite/license.html @@ -3,107 +3,113 @@ <head> <meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> - <title>G3D: License</title> + <title>G3D Innovation Engine: License</title> <link href="stylesheet.css" rel="stylesheet" type="text/css"> - <style type="text/css"> - span.menu_tab a { - background: #FFE183; - border-width: 1px; - border-style: solid; - border-color: #FFB143; - padding: 5px; - margin: 0px; - margin-left: 2px; - font-size: 11px; - font-weight: bold; - font-family: arial; - color: #000000; - position: relative; - display: inline; - } - - span.menu_tab a:link, a:visited { - text-decoration: none; - } - span.menu_tab a:hover { - background: #FDEFA0; - color: #000000; - text-decoration: none; - } - .widthadjust { - min-width: 800px; - width: 80%; - background: #FFFFFF; - padding-left: 5px; - padding-right: 5px; - } - * html .widthadjust { - width: expression(document.body.clientWidth < 1000? "1000px": "auto"; - } - </style> </head> <body style="width: 100%; background: #aaaaaa"> <table class="widthadjust" align=center><tr><td> <table style="height: 44px; border-bottom-width: 1px; border-bottom-style: solid; border-bottom-color: #FFc161;" width=100% cellspacing=0 cellpadding=0> + + <tr> + <td rowspan="2" valign="bottom" style="width: 51;"> + <a href="index.html"> + <img src="G3D-small-shadow.jpg" border="0" align="left"> + </a> + </td> + <td style="width: 65%;" nowrap="true" valign="bottom"> + <font size="2"> + <center> + <a href="http://groups.google.com/group/g3d-users/topics">Support Forum</a> + <a href="http://g3d.cvs.sourceforge.net/g3d/G3D/">Library Source</a> + <a href="http://sourceforge.net/projects/g3d/">SourceForge Page</a> + <a href="http://g3d.sf.net/">Web Page</a> + </center> + </font> + </td> + </tr> <tr cellspacing=0 cellpadding=0> - <td style="width: 70%;" nowrap=true> - <img src="G3D-small-shadow.jpg"> - <span class="menu_tab"><a href="index.html">Contents</a></span> - <span class="menu_tab"><a href="globals_func.html">Functions</a></span> - <span class="menu_tab"><a href="classes.html">Classes</a></span> - <span class="menu_tab"><a href="indexedbytopic.html">Topics</a></span> - <span class="menu_tab"><a href="http://sourceforge.net/forum/forum.php?forum_id=262426">User Forum</a></span> - <span class="menu_tab"><a href="http://cvs.sourceforge.net/viewcvs.py/g3d-cpp/cpp/">CVS</a></span> - </td> +<td style="width: 65%;" nowrap=true valign=bottom> + + <span class="menu_tab"> + <a href="http://sourceforge.net/apps/mediawiki/g3d/index.php?title=Main_Page">Wiki Doc</a> + </span> + <span class="menu_tab"> + <a href="dataindex.html">Data</a> + </span> + <span class="menu_tab"> + <a href="annotated.html">API Index</a> + </span> + <span class="menu_tab"> + <a href="apiindex.html">APIs by Level</a> + </span> + <span class="menu_tab"> + <a href="topicindex.html">APIs by Task</a> + </span> +</td> </tr> </table> - +<br> +<br> <table cellspacing=0 cellpadding=0 width=100% > <tr><td> <!-- code goes here --> -<!-- Generated by Doxygen 1.4.6-NO --> -<h1><a class="anchor" name="license">License</a></h1> -<TABLE BORDER=0 WIDTH=80%><TR><TD><I><FONT FACE="Arial"> -<A HREF="guideintro.html"><IMG SRC="backarrow.gif" BORDER=0 ALIGN=MIDDLE> -Introduction</A></I></FONT></TD><TD ALIGN=RIGHT><FONT FACE="Arial"><I> -<A HREF="guideinstall.html"> -Installation <IMG SRC="forwardarrow.gif" BORDER=0 ALIGN=MIDDLE></A></I></FONT></TD></TR></TABLE> -<h2><a class="anchor" name="intent"> + +<!-- Generated by Doxygen 1.6.1 --> +<div class="contents"> + + +<h1><a class="anchor" id="license">License </a></h1><h2><a class="anchor" id="intent"> Intent of License</a></h2> -(This section is informal and not legally binding.)<p> -<br> - This library is free code-- you can use it without charge and it is minimally legally encumbered. Unlike some other free libraries, we <u>do not</u> require you to release your source code or make your own program open source.<p> -I intend the license (below) to protect me and the other contributors from liability and allow you to use the source however you want. You can make your own closed or open-source programs, sell them, give them away, whatever.<p> -You have an obligation to say "this software is based in part on the work of the Independent JPEG Group" in your documentation or application help if you use the <a class="el" href="classG3D_1_1GImage.html">G3D::GImage</a> class because it is based on the IJG library. The OpenGL headers and ZLib headers included may be freely distributed provided their copyright notices remain intact.<p> -For convenience, <a class="el" href="namespaceG3D.html#2d6bccd0c2fa5b44882b7d0c732e2712">G3D::license</a> is a function that returns the license string you must put in your documentation. <a class="el" href="classG3D_1_1GApp.html">G3D::GApp</a> will automatically write a file (g3d-license.txt) to disk with the contents of this license unless you tell it not to.<p> -Most of the data resources have either entered the public domain and have been in several published papers or are data that I have explicitly received permission to distribute with <a class="el" href="namespaceG3D.html">G3D</a>. The <a class="el" href="namespaceG3D.html">G3D</a> fonts are actually font images, not TrueType font descriptions and may be freely distributed. As a rule of thumb, you can freely use and distribute anything you find in the data directory but may need permission to use it in a commercial product. Check the various copyright.txt files in the data directories for specific information.<p> -You are required by the BSD license to acknowledge <a class="el" href="namespaceG3D.html">G3D</a> in your documentation. This can be as minimal as a note buried in the fine print at the end of a manual or a text file accompanying your program. I appreciate it if you acknowledged the library more publicly but you aren't required to.<p> -Likewise, you are encouraged but not required to submit patches to improve the library for the benefit of all. E-mail me with bugs, patches, and questions.<p> --Morgan McGuire <<em><a href="mailto:matrix@graphics3d.com">matrix@graphics3d.com</a></em>><p> -<hr> -<h2><a class="anchor" name="reallicense"> +<p>(This section is informal and not legally binding.)</p> +<p><br/> + This library is free code-- you can use it without charge and it is minimally legally encumbered. Unlike some other free libraries, we <b>do not</b> require you to release your source code or make your own program open source.</p> +<p>I intend the license (below) to protect me and the other contributors from liability and allow you to use the source however you want. You can make your own closed or open-source programs, sell them, give them away, whatever.</p> +<p>The license for <a class="el" href="namespace_g3_d.html">G3D</a> itself and the libaries included in the <a class="el" href="namespace_g3_d.html">G3D</a> distribution create certain documentation obligations for you. For convenience, <a class="el" href="namespace_g3_d.html#a2d6bccd0c2fa5b44882b7d0c732e2712" title="G3D, SDL, and IJG libraries require license documentation to be distributed with...">G3D::license</a> is a function that returns the license string you must put in your documentation. <a class="el" href="class_g3_d_1_1_g_app.html" title="For each frame, the GApp has several tasks that can be implemented by overriding...">G3D::GApp</a> will automatically write a file (g3d-license.txt) to disk with the contents of this license unless you tell it not to, thus automatically satisfying your documentation requirement after the first time you run a <a class="el" href="namespace_g3_d.html">G3D</a> program.</p> +<p>Most of the data resources have either entered the public domain and have been in several published papers or are data that I have explicitly received permission to distribute with <a class="el" href="namespace_g3_d.html">G3D</a>. The <a class="el" href="namespace_g3_d.html">G3D</a> fonts are actually font images, not TrueType font descriptions and may be freely distributed. As a rule of thumb, you can freely use and distribute anything you find in the data directory but may need permission to use it in a commercial product. Check the various copyright.txt files in the data directories for specific information.</p> +<p>You are required by the BSD license to acknowledge <a class="el" href="namespace_g3_d.html">G3D</a> in your documentation. This can be as minimal as a note buried in the fine print at the end of a manual or a text file accompanying your program. I appreciate it if you acknowledged the library more publicly but you aren't required to.</p> +<p>Likewise, you are encouraged but not required to submit patches to improve the library for the benefit of all. Post bugs, patches, and questions to the g3d-users forum linked at the top of this page. </p> +<p>-Morgan McGuire <<em><a href="mailto:morgan@cs.williams.edu">morgan@cs.williams.edu</a></em>></p> +<hr/> +<h2><a class="anchor" id="reallicense"> License</a></h2> -<em><a class="el" href="namespaceG3D.html">G3D</a> is licensed under the <a href="http://www.opensource.org/licenses/bsd-license.php">BSD license</a>, with portions controlled by the <a href="IJG-README.TXT">IJG license</a> and <a href="libpng-LICENSE.txt">PNG Reference Library license</a></em><p> -<code> <div align="center"> -<img src="http://opensource.org/trademarks/osi-certified/web/osi-certified-120x100.gif" alt="osi-certified-120x100.gif"> +<p><em><a class="el" href="namespace_g3_d.html">G3D</a> is licensed under the <a href="http://www.opensource.org/licenses/bsd-license.php">BSD license</a>, with portions controlled by the <a href="IJG-README.TXT">IJG license</a>, <a href="libpng-LICENSE.txt">PNG Reference Library license</a>.</em></p> +<p><code> </p> +<div align="center"> +<img src="http://opensource.org/trademarks/osi-certified/web/osi-certified-120x100.gif" alt="osi-certified-120x100.gif"/> </div> - </code><p> -<code>This product uses software from the <a class="el" href="namespaceG3D.html">G3D</a> project (<a href="http://g3d-cpp.sf.net">http://g3d-cpp.sf.net</a>) </code><p> -<code>Copyright © 2000-2006, Morgan McGuire </code><p> -<code>All rights reserved. </code><p> -<code> Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: </code><p> -<code> Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. </code><p> -<code> Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. </code><p> -<code> Neither the name of Morgan McGuire, Williams College, Brown University, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. </code><p> -<code> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. </code><p> -You must also agree to be bound by the terms of the Independent JPEG Group license for the portions of this library that are based on the work of the Independent JPEG Group, <b>if you use those portions</b>. Note: if you do not use the <a class="el" href="classG3D_1_1GImage.html">G3D::GImage</a> class, this clause does not apply to you because the linker will strip that code from your project. The <a href="IJG-README.TXT" ->IJG-README.TXT</a> file contains the Independent JPEG Group license.</A> +<p> </code></p> +<p><code>This product uses software from the <a class="el" href="namespace_g3_d.html">G3D</a> project (<a href="http://g3d.sf.net">http://g3d.sf.net</a>) </code></p> +<p><code>Copyright © 2000-2010, Morgan McGuire </code></p> +<p><code>All rights reserved. </code></p> +<p><code> Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: </code></p> +<p><code> Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. </code></p> +<p><code> Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. </code></p> +<p><code> Neither the name of Morgan McGuire, Williams College, Brown University, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. </code></p> +<p><code> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. </code> </p> +</div> +</A> <hr><address style="align: right;"><small> -Generated on Tue Jul 18 12:05:54 2006 for G3D by <a href="http://www.doxygen.org/index.html"> +G3D Innovation Engine documentation generated on Thu Mar 25 14:54:30 2010 using <a href="http://www.doxygen.org/index.html"> <img src="doxygen.png" alt="doxygen" align="middle" border=0 width=55 height=26> -</a> 1.4.6-NO</small></address> +</a> 1.6.1</small></address> + <!-- Removed to make page loading faster Hosted by <A href="http://sourceforge.net"> <IMG src="http://sourceforge.net/sflogo.php?group_id=76879&type=5" width="210" height="62" border="0" alt="SourceForge.net Logo"></A> +--> + +<!-- Piwik --> +<script type="text/javascript"> +var pkBaseURL = (("https:" == document.location.protocol) ? "https://apps.sourceforge.net/piwik/g3d/" : "http://apps.sourceforge.net/piwik/g3d/"); +document.write(unescape("%3Cscript src='" + pkBaseURL + "piwik.js' type='text/javascript'%3E%3C/script%3E")); +</script><script type="text/javascript"> +piwik_action_name = ''; +piwik_idsite = 2; +piwik_url = pkBaseURL + "piwik.php"; +piwik_log(piwik_action_name, piwik_idsite, piwik_url); +</script> +<object><noscript><p><img src="http://apps.sourceforge.net/piwik/g3d/piwik.php?idsite=2" alt="piwik"/></p></noscript></object> +<!-- End Piwik Tag --> + </body> </html> diff --git a/dep/src/g3dlite/prompt.cpp b/dep/src/g3dlite/prompt.cpp new file mode 100644 index 00000000000..6a28e6462b4 --- /dev/null +++ b/dep/src/g3dlite/prompt.cpp @@ -0,0 +1,729 @@ +/** + @file prompt.cpp + + @author Morgan McGuire, http://graphics.cs.williams.edu + @cite Windows dialog interface by Max McGuire, mmcguire@ironlore.com + @cite Font setting code by Kurt Miller, kurt@flipcode.com + + @created 2000-08-26 + @edited 2005-01-14 + */ + +#include "G3D/prompt.h" +#include "G3D/platform.h" + +#include <stdio.h> + +#ifdef G3D_WIN32 +# include <sstream> +# include <conio.h> +#else +# define _getch getchar +#endif + +#ifdef G3D_OSX + +/*#ifdef __LP64__ +# undef __LP64__ +#endif +*/ + +# include <Carbon/Carbon.h> + +/* +#ifdef G3D_64BIT +# define __LP64__ +#endif +*/ + +#endif + +namespace G3D { + +#ifdef G3D_WIN32 + +namespace _internal { +/** + Generic Win32 dialog facility. + @author Max McGuire + */ +class DialogTemplate { +public: + + DialogTemplate(LPCSTR caption, DWORD style, + int x, int y, int w, int h, + LPCSTR font = NULL, WORD fontSize = 8) { + + usedBufferLength = sizeof(DLGTEMPLATE); + totalBufferLength = usedBufferLength; + + dialogTemplate = (DLGTEMPLATE*)malloc(totalBufferLength); + + dialogTemplate->style = style; + + if (font != NULL) { + dialogTemplate->style |= DS_SETFONT; + } + + dialogTemplate->x = (short)x; + dialogTemplate->y = (short)y; + dialogTemplate->cx = (short)w; + dialogTemplate->cy = (short)h; + dialogTemplate->cdit = 0; + + dialogTemplate->dwExtendedStyle = 0; + + // The dialog box doesn't have a menu or a special class + AppendData("\0", 2); + AppendData("\0", 2); + + // Add the dialog's caption to the template + + AppendString(caption); + + if (font != NULL) { + AppendData(&fontSize, sizeof(WORD)); + AppendString(font); + } + } + + void AddComponent(LPCSTR type, LPCSTR caption, DWORD style, DWORD exStyle, int x, int y, int w, int h, WORD id) { + + DLGITEMTEMPLATE item; + + item.style = style; + item.x = (short)x; + item.y = (short)y; + item.cx = (short)w; + item.cy = (short)h; + item.id = id; + + item.dwExtendedStyle = exStyle; + + AppendData(&item, sizeof(DLGITEMTEMPLATE)); + + AppendString(type); + AppendString(caption); + + WORD creationDataLength = 0; + AppendData(&creationDataLength, sizeof(WORD)); + + // Increment the component count + dialogTemplate->cdit++; + + } + + + void AddButton(LPCSTR caption, DWORD style, DWORD exStyle, int x, int y, int w, int h, WORD id) { + + AddStandardComponent(0x0080, caption, style, exStyle, x, y, w, h, id); + + WORD creationDataLength = 0; + AppendData(&creationDataLength, sizeof(WORD)); + + } + + + void AddEditBox(LPCSTR caption, DWORD style, DWORD exStyle, int x, int y, int w, int h, WORD id) { + + AddStandardComponent(0x0081, caption, style, exStyle, x, y, w, h, id); + + WORD creationDataLength = 0; + AppendData(&creationDataLength, sizeof(WORD)); + + } + + + void AddStatic(LPCSTR caption, DWORD style, DWORD exStyle, int x, int y, int w, int h, WORD id) { + + AddStandardComponent(0x0082, caption, style, exStyle, x, y, w, h, id); + + WORD creationDataLength = 0; + AppendData(&creationDataLength, sizeof(WORD)); + + } + + + void AddListBox(LPCSTR caption, DWORD style, DWORD exStyle, int x, int y, int w, int h, WORD id) { + + AddStandardComponent(0x0083, caption, style, exStyle, x, y, w, h, id); + + WORD creationDataLength = sizeof(WORD) + 5 * sizeof(WCHAR); + AppendData(&creationDataLength, sizeof(WORD)); + + AppendString("TEST"); + + } + + + void AddScrollBar(LPCSTR caption, DWORD style, DWORD exStyle, int x, int y, int w, int h, WORD id) { + + AddStandardComponent(0x0084, caption, style, exStyle, x, y, w, h, id); + + WORD creationDataLength = 0; + AppendData(&creationDataLength, sizeof(WORD)); + + } + + + void AddComboBox(LPCSTR caption, DWORD style, DWORD exStyle, int x, int y, int w, int h, WORD id) { + + AddStandardComponent(0x0085, caption, style, exStyle, x, y, w, h, id); + + WORD creationDataLength = 0; + AppendData(&creationDataLength, sizeof(WORD)); + + } + + + /** + * + * Returns a pointer to the Win32 dialog template which the object + * represents. This pointer may become invalid if additional components + * are added to the template. + * + */ + operator const DLGTEMPLATE*() const { + return dialogTemplate; + } + + virtual ~DialogTemplate() { + free(dialogTemplate); + } + +protected: + + void AddStandardComponent(WORD type, LPCSTR caption, DWORD style, DWORD exStyle, + int x, int y, int w, int h, WORD id, LPSTR font = NULL, WORD fontSize = 8) { + + DLGITEMTEMPLATE item; + + // DWORD align the beginning of the component data + + AlignData(sizeof(DWORD)); + + item.style = style; + if (font != NULL) { + item.style |= DS_SETFONT; + } + item.x = (short)x; + item.y = (short)y; + item.cx = (short)w; + item.cy = (short)h; + item.id = id; + + item.dwExtendedStyle = exStyle; + + AppendData(&item, sizeof(DLGITEMTEMPLATE)); + + WORD preType = 0xFFFF; + + AppendData(&preType, sizeof(WORD)); + AppendData(&type, sizeof(WORD)); + + AppendString(caption); + + if (font != NULL) { + AppendData(&fontSize, sizeof(WORD)); + AppendString(font); + } + + // Increment the component count + dialogTemplate->cdit++; + } + + + void AlignData(int size) { + + int paddingSize = usedBufferLength % size; + + if (paddingSize != 0) { + EnsureSpace(paddingSize); + usedBufferLength += paddingSize; + } + + } + + void AppendString(LPCSTR string) { + + int length = MultiByteToWideChar(CP_ACP, 0, string, -1, NULL, 0); + + WCHAR* wideString = (WCHAR*)malloc(sizeof(WCHAR) * length); + MultiByteToWideChar(CP_ACP, 0, string, -1, wideString, length); + + AppendData(wideString, length * sizeof(WCHAR)); + free(wideString); + + } + + void AppendData(const void* data, int dataLength) { + + EnsureSpace(dataLength); + + memcpy((char*)dialogTemplate + usedBufferLength, data, dataLength); + usedBufferLength += dataLength; + + } + + void EnsureSpace(int length) { + if (length + usedBufferLength > totalBufferLength) { + totalBufferLength += length * 2; + + void* newBuffer = malloc(totalBufferLength); + memcpy(newBuffer, dialogTemplate, usedBufferLength); + + free(dialogTemplate); + dialogTemplate = (DLGTEMPLATE*)newBuffer; + } + } + +private: + + DLGTEMPLATE* dialogTemplate; + + int totalBufferLength; + int usedBufferLength; + +}; + + +struct PromptParams { + const char* message; + const char* title; +}; + +/** + * Constants for controls. + */ +#define IDC_MESSAGE 1000 +#define IDC_BUTTON0 2000 + +INT_PTR CALLBACK PromptDlgProc(HWND hDlg, UINT msg, + WPARAM wParam, LPARAM lParam) { + switch(msg) { + case WM_INITDIALOG: + { + PromptParams *params = (PromptParams*)lParam; + ::SetWindowTextA(::GetDlgItem(hDlg, IDC_MESSAGE), params->message); + + ::SetFocus(::GetDlgItem(hDlg, IDC_BUTTON0)); + + SetWindowTextA(hDlg, params->title); + + HFONT hfont = + CreateFontA(16, 0, 0, 0, FW_NORMAL, + FALSE, FALSE, FALSE, + ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS, + PROOF_QUALITY, FIXED_PITCH | FF_MODERN, "Courier New"); + + SendDlgItemMessage(hDlg, IDC_MESSAGE, WM_SETFONT, (WPARAM)hfont, MAKELPARAM(TRUE,0)); + + + break; + } + case WM_COMMAND: + { + int choiceNumber = LOWORD(wParam) - IDC_BUTTON0; + if ((choiceNumber >= 0) && (choiceNumber < 10)) { + EndDialog(hDlg, choiceNumber); + return TRUE; + } + } + + break; + + case WM_NCDESTROY: + // Under SDL 1.2.6 we get a NCDESTROY message for no reason and the + // window is immediately closed. This is here to debug the problem. + (void)0; + break; + + } + + return FALSE; +} + +}; // namespace _internal + + +using namespace _internal; + +/** + * Show a dialog prompt. + */ +static int guiPrompt( + const char* windowTitle, + const char* prompt, + const char** choice, + int numChoices) { + + int width = 280; + int height = 128; + + const int buttonSpacing = 2; + const int buttonWidth = + (width - buttonSpacing * 2 - + buttonSpacing * (numChoices - 1)) / numChoices; + const int buttonHeight = 13; + + + DialogTemplate dialogTemplate( + windowTitle, + WS_CAPTION | DS_CENTER | WS_SYSMENU, + 10, 10, width, height, + "Tahoma"); + + dialogTemplate.AddEditBox( + "Edit", WS_VISIBLE | ES_READONLY | ES_OEMCONVERT | ES_MULTILINE | WS_TABSTOP, WS_EX_STATICEDGE, + 2, 2, width - 4, height - buttonHeight - 7, IDC_MESSAGE); + + int i; + for (i = 0; i < numChoices; i++) { + + int x = buttonSpacing + i * (buttonWidth + buttonSpacing); + int y = height - buttonHeight - buttonSpacing; + + dialogTemplate.AddButton(choice[i], WS_VISIBLE | WS_TABSTOP, 0, + x, y, buttonWidth, buttonHeight, IDC_BUTTON0 + (WORD)i); + + } + + // Convert all single \n characters to \r\n for proper printing + int strLen = 0; + const char* pStr = prompt; + + while (*pStr != '\0') { + if ((*pStr == '\n') && (pStr != prompt)) { + if (*(pStr - 1) != '\r') { + ++strLen; + } + } + ++strLen; + ++pStr; + } + + char* newStr = (char*)malloc(strLen + 1); + + const char* pStr2 = prompt; + char* pNew = newStr; + + while (*pStr2 != '\0') { + if ((*pStr2 == '\n') && (pStr2 != prompt)) { + if (*(pStr2 - 1) != '\r') { + *pNew = '\r'; + ++pNew; + } + } + *pNew = *pStr2; + ++pNew; + ++pStr2; + } + + *pNew = '\0'; + + PromptParams params; + params.message = newStr;; + params.title = windowTitle; + + HMODULE module = GetModuleHandle(0); + int ret = DialogBoxIndirectParam(module, dialogTemplate, NULL, (DLGPROC) PromptDlgProc, (DWORD)¶ms); + + free(newStr); + + /* + For debugging when DialogBoxIndirectParam fails: + + // The last error value. (Which is preserved across the call). + DWORD lastErr = GetLastError(); + + // The decoded message from FormatMessage + LPTSTR formatMsg = NULL; + + if (NULL == formatMsg) { + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_IGNORE_INSERTS | + FORMAT_MESSAGE_FROM_SYSTEM, + NULL, + lastErr, + 0, + (LPTSTR)&formatMsg, + 0, + NULL); + } + + // Make sure the message got translated into something. + LPTSTR realLastErr; + if (NULL != formatMsg) { + realLastErr = formatMsg; + } else { + realLastErr = "Last error code does not exist."; + } + + // Get rid of the allocated memory from FormatMessage. + if (NULL != formatMsg) { + LocalFree((LPVOID)formatMsg); + } + */ + + return ret; +} + +#endif + + +/** + * Show a prompt on stdout + */ +static int textPrompt( + const char* windowTitle, + const char* prompt, + const char** choice, + int numChoices) { + + printf("\n___________________________________________________\n"); + printf("%s\n", windowTitle); + printf("%s", prompt); + + if (numChoices > 10) { + numChoices = 10; + } + + int c = -1; + if (numChoices > 1) { + printf("\n"); + printf("Choose an option by number:"); + + while ((c < 0) || (c >= numChoices)) { + printf("\n"); + + for (int i = 0; i < numChoices; i++) { + if (numChoices <= 3) { + printf(" (%d) %s ", i, choice[i]); + } else { + printf(" (%d) %s\n", i, choice[i]); + } + } + + printf("\n> "); + c = _getch() - '0'; + + if ((c < 0) || (c >= numChoices)) { + printf("'%d' is not a valid choice.", c); + } else { + printf("%d", c); + } + } + + } else if (numChoices == 1) { + + printf("\nPress any key for '%s'...", choice[0]); + _getch(); + c = 0; + + } else { + + printf("\nPress any key..."); + _getch(); + c = 0; + } + + printf("\n___________________________________________________\n"); + return c; +} + +#ifdef G3D_OSX + +// See http://developer.apple.com/documentation/Carbon/Reference/Carbon_Event_Manager_Ref/index.html + +#define CARBON_COMMANDID_START 128 +#define CARBON_BUTTON_SPACING 12 +#define CARBON_BUTTON_HEIGHT 20 +#define CARBON_BUTTON_MINWIDTH 69 +#define CARBON_WINDOW_PADDING 20 + +struct CallbackData { + WindowRef refWindow; + + /** Index of this particular button */ + int myIndex; + + /** Buttons store their index into here when pressed. */ + int* whichButton; +}; + +/** + Assumes that userData is a pointer to a carbon_evt_data_t. + + */ +static pascal OSStatus DoCommandEvent(EventHandlerCallRef handlerRef, EventRef event, void* userData) { + // See http://developer.apple.com/documentation/Carbon/Conceptual/HandlingWindowsControls/index.html + + CallbackData& callbackData = *(CallbackData*)userData; + +# pragma unused(handlerRef) + + callbackData.whichButton[0] = callbackData.myIndex; + + // If we get here we can close the window + ::QuitAppModalLoopForWindow(callbackData.refWindow); + + // Return noErr to indicate that we handled the event + return noErr; +} + +static int guiPrompt +(const char* windowTitle, + const char* prompt, + const char** choice, + int numChoices) { + + WindowRef window; + + int iNumButtonRows = 0; + int iButtonWidth = -1; + OSStatus err = noErr; + + // Determine number of rows of buttons + while (iButtonWidth < CARBON_BUTTON_MINWIDTH) { + ++iNumButtonRows; + iButtonWidth = + (550 - (CARBON_WINDOW_PADDING*2 + + (CARBON_BUTTON_SPACING*numChoices))) / + (numChoices/iNumButtonRows); + } + + // Window Variables + Rect rectWin = {0, 0, 200 + ((iNumButtonRows-1) * (CARBON_BUTTON_HEIGHT+CARBON_BUTTON_SPACING)), 550}; // top, left, bottom, right + CFStringRef szWindowTitle = CFStringCreateWithCString(kCFAllocatorDefault, windowTitle, kCFStringEncodingUTF8); + + window = NULL; + + err = CreateNewWindow(kMovableAlertWindowClass, kWindowStandardHandlerAttribute|kWindowCompositingAttribute, &rectWin, &window); + err = SetWindowTitleWithCFString(window, szWindowTitle); + err = SetThemeWindowBackground(window, kThemeBrushAlertBackgroundActive, false); + assert(err == noErr); + + // Event Handler Variables + EventTypeSpec buttonSpec[] = {{ kEventClassControl, kEventControlHit }, { kEventClassCommand, kEventCommandProcess }}; + EventHandlerUPP buttonHandler = NewEventHandlerUPP(DoCommandEvent); + + // Static Text Variables + Rect rectStatic = {20, 20, 152, 530}; + CFStringRef szStaticText = CFStringCreateWithCString(kCFAllocatorDefault, prompt, kCFStringEncodingUTF8); + ControlRef refStaticText = NULL; + err = CreateStaticTextControl(window, &rectStatic, szStaticText, NULL, &refStaticText); + + // Button Variables + Rect bounds[numChoices]; + CFStringRef caption[numChoices]; + ControlRef button[numChoices]; + + int whichButton=-1; + CallbackData callbackData[numChoices]; + + // Create the Buttons and assign event handlers + for (int i = 0; i < numChoices; ++i) { + bounds[i].top = 160 + ((CARBON_BUTTON_HEIGHT+CARBON_BUTTON_SPACING)*(i%iNumButtonRows)); + bounds[i].right = 530 - ((iButtonWidth+CARBON_BUTTON_SPACING)*(i/iNumButtonRows)); + bounds[i].left = bounds[i].right - iButtonWidth; + bounds[i].bottom = bounds[i].top + CARBON_BUTTON_HEIGHT; + + // Convert the button captions to Apple strings + caption[i] = CFStringCreateWithCString(kCFAllocatorDefault, choice[i], kCFStringEncodingUTF8); + + err = CreatePushButtonControl(window, &bounds[i], caption[i], &button[i]); + assert(err == noErr); + + err = SetControlCommandID(button[i], CARBON_COMMANDID_START + i); + assert(err == noErr); + + callbackData[i].refWindow = window; + callbackData[i].myIndex = i; + callbackData[i].whichButton = &whichButton; + + err = InstallControlEventHandler(button[i], buttonHandler, + GetEventTypeCount(buttonSpec), buttonSpec, + &callbackData[i], NULL); + assert(err == noErr); + } + + // Show Dialog + err = RepositionWindow(window, NULL, kWindowCenterOnMainScreen); + ShowWindow(window); + BringToFront(window); + err = ActivateWindow(window, true); + + // Hack to get our window/process to the front... + ProcessSerialNumber psn = { 0, kCurrentProcess}; + TransformProcessType(&psn, kProcessTransformToForegroundApplication); + SetFrontProcess (&psn); + + // Run in Modal State + err = RunAppModalLoopForWindow(window); + + // Dispose of Button Related Data + for (int i = 0; i < numChoices; ++i) { + // Dispose of controls + DisposeControl(button[i]); + + // Release CFStrings + CFRelease(caption[i]); + } + + // Dispose of Other Controls + DisposeControl(refStaticText); + + // Dispose of Event Handlers + DisposeEventHandlerUPP(buttonHandler); + + // Dispose of Window + DisposeWindow(window); + + // Release CFStrings + CFRelease(szWindowTitle); + CFRelease(szStaticText); + + // Return Selection + return whichButton; +} + +#endif + +int prompt( + const char* windowTitle, + const char* prompt, + const char** choice, + int numChoices, + bool useGui) { + + #ifdef G3D_WIN32 + if (useGui) { + // Build the message box + return guiPrompt(windowTitle, prompt, choice, numChoices); + } + #endif + + #ifdef G3D_OSX + if (useGui){ + //Will default to text prompt if numChoices > 4 + return guiPrompt(windowTitle, prompt, choice, numChoices); + } + #endif + return textPrompt(windowTitle, prompt, choice, numChoices); +} + + +void msgBox( + const std::string& message, + const std::string& title) { + + const char *choice[] = {"Ok"}; + prompt(title.c_str(), message.c_str(), choice, 1, true); +} + +#ifndef G3D_WIN32 + #undef _getch +#endif + +};// namespace + diff --git a/dep/src/g3dlite/stringutils.cpp b/dep/src/g3dlite/stringutils.cpp new file mode 100644 index 00000000000..c3876ebb6a4 --- /dev/null +++ b/dep/src/g3dlite/stringutils.cpp @@ -0,0 +1,275 @@ +/** + @file stringutils.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + + @created 2000-09-09 + @edited 2008-01-10 +*/ + +#include "G3D/platform.h" +#include "G3D/stringutils.h" +#include "G3D/BinaryInput.h" +#include <algorithm> + +namespace G3D { + +#ifdef _MSC_VER + // disable: "C++ exception handler used" +# pragma warning (push) +# pragma warning (disable : 4530) +#endif +#ifdef G3D_WIN32 + const char* NEWLINE = "\r\n"; +#else + const char* NEWLINE = "\n"; + static bool iswspace(int ch) { return (ch==' ' || ch=='\t' || ch=='\n' || ch=='\r'); } +#endif + +void parseCommaSeparated(const std::string s, Array<std::string>& array, bool stripQuotes) { + array.fastClear(); + if (s == "") { + return; + } + + size_t begin = 0; + const char delimiter = ','; + const char quote = '\"'; + do { + size_t end = begin; + // Find the next comma, or the end of the string + bool inQuotes = false; + while ((end < s.length()) && (inQuotes || (s[end] != delimiter))) { + if (s[end] == quote) { + if ((end < s.length() - 2) && (s[end + 1] == quote) && (s[end + 2]) == quote) { + // Skip over the superquote + end += 2; + } + inQuotes = ! inQuotes; + } + ++end; + } + array.append(s.substr(begin, end - begin)); + begin = end + 1; + } while (begin < s.length()); + + if (stripQuotes) { + for (int i = 0; i < array.length(); ++i) { + std::string& t = array[i]; + int L = t.length(); + if ((L > 1) && (t[0] == quote) && (t[L - 1] == quote)) { + if ((L > 6) && (t[1] == quote) && (t[2] == quote) && (t[L - 3] == quote) && (t[L - 2] == quote)) { + // Triple-quote + t = t.substr(3, L - 6); + } else { + // Double-quote + t = t.substr(1, L - 2); + } + } + } + } +} + +bool beginsWith( + const std::string& test, + const std::string& pattern) { + + if (test.size() >= pattern.size()) { + for (int i = 0; i < (int)pattern.size(); ++i) { + if (pattern[i] != test[i]) { + return false; + } + } + return true; + } else { + return false; + } +} + + +bool endsWith( + const std::string& test, + const std::string& pattern) { + + if (test.size() >= pattern.size()) { + int te = test.size() - 1; + int pe = pattern.size() - 1; + for (int i = pattern.size() - 1; i >= 0; --i) { + if (pattern[pe - i] != test[te - i]) { + return false; + } + } + return true; + } else { + return false; + } +} + + +std::string wordWrap( + const std::string& input, + int numCols) { + + std::string output; + size_t c = 0; + int len; + + // Don't make lines less than this length + int minLength = numCols / 4; + size_t inLen = input.size(); + + bool first = true; + while (c < inLen) { + if (first) { + first = false; + } else { + output += NEWLINE; + } + + if ((int)inLen - (int)c - 1 < numCols) { + // The end + output += input.substr(c, inLen - c); + break; + } + + len = numCols; + + // Look at character c + numCols, see if it is a space. + while ((len > minLength) && + (input[c + len] != ' ')) { + len--; + } + + if (len == minLength) { + // Just crop + len = numCols; + + } + + output += input.substr(c, len); + c += len; + if (c < input.size()) { + // Collapse multiple spaces. + while ((input[c] == ' ') && (c < input.size())) { + c++; + } + } + } + + return output; +} + + +int stringCompare( + const std::string& s1, + const std::string& s2) { + + return stringPtrCompare(&s1, &s2); +} + + +int stringPtrCompare( + const std::string* s1, + const std::string* s2) { + + return s1->compare(*s2); +} + + +std::string toUpper(const std::string& x) { + std::string result = x; + std::transform(result.begin(), result.end(), result.begin(), toupper); + return result; +} + + +std::string toLower(const std::string& x) { + std::string result = x; + std::transform(result.begin(), result.end(), result.begin(), tolower); + return result; +} + + +Array<std::string> stringSplit( + const std::string& x, + char splitChar) { + + Array<std::string> out; + + // Pointers to the beginning and end of the substring + const char* start = x.c_str(); + const char* stop = start; + + while ((stop = strchr(start, splitChar))) { + out.append(std::string(start, stop - start)); + start = stop + 1; + } + + // Append the last one + out.append(std::string(start)); + + return out; +} + + +std::string stringJoin( + const Array<std::string>& a, + char joinChar) { + + std::string out; + + for (int i = 0; i < (int)a.size() - 1; ++i) { + out += a[i] + joinChar; + } + + if (a.size() > 0) { + return out + a.last(); + } else { + return out; + } +} + + +std::string stringJoin( + const Array<std::string>& a, + const std::string& joinStr) { + + std::string out; + + for (int i = 0; i < (int)a.size() - 1; ++i) { + out += a[i] + joinStr; + } + + if (a.size() > 0) { + return out + a.last(); + } else { + return out; + } +} + + +std::string trimWhitespace( + const std::string& s) { + + size_t left = 0; + + // Trim from left + while ((left < s.length()) && iswspace(s[left])) { + ++left; + } + + int right = s.length() - 1; + // Trim from right + while ((right > (int)left) && iswspace(s[right])) { + --right; + } + + return s.substr(left, right - left + 1); +} + +}; // namespace + +#undef NEWLINE +#ifdef _MSC_VER +# pragma warning (pop) +#endif diff --git a/dep/src/g3dlite/uint128.cpp b/dep/src/g3dlite/uint128.cpp new file mode 100644 index 00000000000..1f596fc3e51 --- /dev/null +++ b/dep/src/g3dlite/uint128.cpp @@ -0,0 +1,155 @@ +/** + @file uint128.cpp + + @maintainer Morgan McGuire, http://graphics.cs.williams.edu + @author Kyle Whitson + + @created 2008-07-17 + @edited 2008-07-17 + */ + +#include "G3D/uint128.h" + +namespace G3D { + +/** Adds two 64-bit integers, placing the result and the overflow into 64-bit integers.*/ +static void addAndCarry(const uint64& _a, const uint64& _b, uint64& carry, uint64& result) { + + // Break each number into 4 32-bit chunks. Since we are using uints, right-shifting will fill with zeros. + // This eliminates the need to and with 0xFFFFFFFF. + uint32 a [2] = {_a & 0xFFFFFFFF, _a >> 32}; + uint32 b [2] = {_b & 0xFFFFFFFF, _b >> 32}; + + uint64 tmp = uint64(a[0]) + b[0]; + + result = tmp & 0xFFFFFFFF; + uint32 c = tmp >> 32; + + tmp = uint64(c) + a[1] + b[1]; + result += tmp << 32; + carry = (tmp >> 32); +} + +/** Multiplies two unsigned 64-bit integers, placing the result into one 64-bit int and the overflow into another.*/ +void multiplyAndCarry(const uint64& _a, const uint64& _b, uint64& carry, uint64& result) { + + // Break each number into 4 32-bit chunks. Since we are using uints, right-shifting will fill with zeros. + // This eliminates the need to and with 0xFFFFFFFF. + uint32 a [2] = {_a & 0xFFFFFFFF, _a >> 32}; + uint32 b [2] = {_b & 0xFFFFFFFF, _b >> 32}; + + uint64 prod [2][2]; + for(int i = 0; i < 2; ++i) { + for(int j = 0; j < 2; ++j) { + prod[i][j] = uint64(a[i]) * b[j]; + } + } + + // The product of the low bits of a and b will always fit into the result + result = prod[0][0]; + + // The product of the high bits of a and b will never fit into the result + carry = prod[1][1]; + + // The high 32 bits of prod[0][1] and prod[1][0] will never fit into the result + carry += prod[0][1] >> 32; + carry += prod[1][0] >> 32; + + uint64 tmp; + addAndCarry(result, (prod[0][1] << 32), tmp, result); + carry += tmp; + addAndCarry(result, (prod[1][0] << 32), tmp, result); + carry += tmp; +} + + +uint128::uint128(const uint64& hi, const uint64& lo) : hi(hi), lo(lo) { +} + +uint128::uint128(const uint64& lo) : hi(0), lo(lo) { +} + +uint128& uint128::operator+=(const uint128& x) { + + G3D::uint64 carry; + addAndCarry(lo, x.lo, carry, lo); + + // Adding the carry will change hi. Save the old hi bits in case this == x. + const uint64 xHi = x.hi; + hi += carry; + hi += xHi; + return *this; +} + +uint128& uint128::operator*=(const uint128& x) { + + // The low bits will get overwritten when doing the multiply, so back up both (in case &x == this) + const uint64 oldLo = lo; + const uint64 oldXLo = x.lo; + + G3D::uint64 carry; + multiplyAndCarry(oldLo, oldXLo, carry, lo); + + // Overflow doesn't matter here because the result is going into hi - any overflow will exceed the capacity of a 128-bit number + // Note: hi * x.hi will always overflow, since (x * 2^64) * (y * 2^64) = x*y*(2^128). The largest number expressable in 128 bits is + // 2^128 - 1. + hi = carry + (oldLo * x.hi) + (hi * oldXLo); + + return *this; +} + +uint128& uint128::operator^=(const uint128& x) { + hi ^= x.hi; + lo ^= x.lo; + return *this; +} + +uint128& uint128::operator&=(const uint128& x) { + hi &= x.hi; + lo &= x.lo; + return *this; +} + +uint128& uint128::operator|=(const uint128& x) { + hi |= x.hi; + lo |= x.lo; + return *this; +} + +bool uint128::operator==(const uint128& x) { + return (hi == x.hi) && (lo == x.lo); +} + +uint128& uint128::operator>>=(const int x) { + + //Before shifting, mask out the bits that will be shifted out of hi. + //Put a 1 in the first bit that will not be lost in the shift, then subtract 1 to get the mask. + uint64 mask = ((uint64)1L << x) - 1; + uint64 tmp = hi & mask; + hi >>= x; + + //Shift lo and add the bits shifted down from hi + lo = (lo >> x) + (tmp << (64 - x)); + + return *this; +} + +uint128& uint128::operator<<=(const int x) { + + //Before shifting, mask out the bits that will be shifted out of lo. + //Put a 1 in the last bit that will be lost in the shift, then subtract 1 to get the logical inverse of the mask. + //A bitwise NOT will then produce the correct mask. + uint64 mask = ~((((uint64)1L) << (64 - x)) - 1); + uint64 tmp = lo & mask; + lo <<= x; + + //Shift hi and add the bits shifted up from lo + hi = (hi << x) + (tmp >> (64 - x)); + + return *this; +} + +uint128 uint128::operator&(const uint128& x) { + return uint128(hi & x.hi, lo & x.lo); +} +} |