Compare commits
551 Commits
RELEASE_0_
...
AFTER_OPEN
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
46a32dd3ee | ||
|
|
ecb4dc57b4 | ||
|
|
89d426470b | ||
|
|
23c7a1b5b7 | ||
|
|
3b21e9434f | ||
|
|
d4a4428e64 | ||
|
|
2dfc057135 | ||
|
|
a25eebef9b | ||
|
|
741c4ca15a | ||
|
|
0bcdf2e4dc | ||
|
|
cd5a720211 | ||
|
|
5cb04946b0 | ||
|
|
c8953c6275 | ||
|
|
e8dc9c9454 | ||
|
|
a0c325681f | ||
|
|
8d3bf19422 | ||
|
|
4477867ef4 | ||
|
|
e696c884dc | ||
|
|
80bcaa49e6 | ||
|
|
0096c1bb02 | ||
|
|
38b37a068d | ||
|
|
0281f31df2 | ||
|
|
40b182c550 | ||
|
|
d1dedc7511 | ||
|
|
04cd9b3eb6 | ||
|
|
de6003367d | ||
|
|
a5f42eeddf | ||
|
|
a8ba041b67 | ||
|
|
e700fc6f34 | ||
|
|
af29d3d257 | ||
|
|
487701a143 | ||
|
|
f32e037c58 | ||
|
|
8bd903dd96 | ||
|
|
560c100484 | ||
|
|
52444d177b | ||
|
|
b4f7ff29ef | ||
|
|
f7c6a5bfa2 | ||
|
|
6fe14f7a6b | ||
|
|
786e5addd8 | ||
|
|
2e9a15f523 | ||
|
|
bb0d2ddc53 | ||
|
|
702fb014a5 | ||
|
|
834eab9457 | ||
|
|
a85da04601 | ||
|
|
414f1c27e4 | ||
|
|
c76e2eb900 | ||
|
|
c523e15302 | ||
|
|
2dc8de295d | ||
|
|
d645fd6327 | ||
|
|
219a7f3a07 | ||
|
|
d95e3e0055 | ||
|
|
2cc31ff425 | ||
|
|
8258fd7d9f | ||
|
|
784cca2233 | ||
|
|
436539a700 | ||
|
|
dcb3da9f28 | ||
|
|
a354c841f1 | ||
|
|
3824f064cd | ||
|
|
cba6db752b | ||
|
|
a458e26581 | ||
|
|
9d68727a84 | ||
|
|
38b9a874e0 | ||
|
|
7a680fb9f2 | ||
|
|
a5f9262adb | ||
|
|
b05e32fa8c | ||
|
|
53d8cff835 | ||
|
|
00fe97ff88 | ||
|
|
607511fd64 | ||
|
|
8663c265d8 | ||
|
|
6c5d35d6ce | ||
|
|
95532cb318 | ||
|
|
4d91bc5908 | ||
|
|
b13900402d | ||
|
|
1bb6c03bd0 | ||
|
|
1445949e31 | ||
|
|
360d3834ca | ||
|
|
aacdcad529 | ||
|
|
ad9341835f | ||
|
|
b028adb6af | ||
|
|
39f683b272 | ||
|
|
a6c46c89eb | ||
|
|
d534cf6f02 | ||
|
|
dd4326f7c4 | ||
|
|
40aecd688e | ||
|
|
63730a6e2c | ||
|
|
4d4d26aef8 | ||
|
|
de6b32d8c6 | ||
|
|
a0af7f0524 | ||
|
|
c043bd3422 | ||
|
|
18ae1d6940 | ||
|
|
d6f64f9773 | ||
|
|
db99a4cb90 | ||
|
|
108689661f | ||
|
|
d3e00dba8e | ||
|
|
fcd33e5035 | ||
|
|
af9082cd9f | ||
|
|
6a0bb18fca | ||
|
|
8aa8d87781 | ||
|
|
4998af8d7a | ||
|
|
c6aa95f3f3 | ||
|
|
481be29366 | ||
|
|
3617b6ad8c | ||
|
|
3fb8e19a38 | ||
|
|
2ea2f1b4f2 | ||
|
|
26cb8ec4f1 | ||
|
|
7fe56bea86 | ||
|
|
11b16b8a86 | ||
|
|
de020ee695 | ||
|
|
3b83487611 | ||
|
|
09bab4f162 | ||
|
|
49fcc799ca | ||
|
|
10bc803775 | ||
|
|
4f40770fc6 | ||
|
|
a4495c6ef1 | ||
|
|
67d837c4ec | ||
|
|
138825af6d | ||
|
|
c093841336 | ||
|
|
2df1da4226 | ||
|
|
2792d60e2d | ||
|
|
656a3ace07 | ||
|
|
aec8e88c14 | ||
|
|
bdd5ca140d | ||
|
|
8b3b0def03 | ||
|
|
6440ece177 | ||
|
|
bd3518637c | ||
|
|
aef2a1c484 | ||
|
|
a4b28e5737 | ||
|
|
a3bc2eb836 | ||
|
|
3059da5805 | ||
|
|
18d5a492c8 | ||
|
|
160b0ea7d9 | ||
|
|
4dd1267bea | ||
|
|
b5c4328682 | ||
|
|
571fc69ef4 | ||
|
|
f51595cfc9 | ||
|
|
d54aea0036 | ||
|
|
51bb2974bc | ||
|
|
7a859061fd | ||
|
|
cefa9fcd75 | ||
|
|
d3bacd0b73 | ||
|
|
b94a98fc90 | ||
|
|
e0b2687231 | ||
|
|
cc6179a4dd | ||
|
|
e947bac4a3 | ||
|
|
11ecbb6ca7 | ||
|
|
322789cd4c | ||
|
|
f28464dba0 | ||
|
|
8f6456b1f8 | ||
|
|
1f32786c82 | ||
|
|
829c729ee9 | ||
|
|
5d3aacb892 | ||
|
|
741e9c5ed5 | ||
|
|
1408c1b623 | ||
|
|
c256f8d09e | ||
|
|
55c018c525 | ||
|
|
3fa94b5143 | ||
|
|
5127e2f89c | ||
|
|
3175fa3aca | ||
|
|
5614174b39 | ||
|
|
39fc52fe0a | ||
|
|
81188705b1 | ||
|
|
63c4873d8a | ||
|
|
1a85dcd890 | ||
|
|
27470fc504 | ||
|
|
65d18445d3 | ||
|
|
84dd54b33a | ||
|
|
7c410d36e3 | ||
|
|
98a603a570 | ||
|
|
5876052170 | ||
|
|
f8303b4623 | ||
|
|
20005a7a22 | ||
|
|
4f0bfbab21 | ||
|
|
811442832e | ||
|
|
40811311d7 | ||
|
|
198de211f8 | ||
|
|
9f5412fa9d | ||
|
|
0dc9de81ae | ||
|
|
5b8f42ce5e | ||
|
|
5314274ed6 | ||
|
|
c831856711 | ||
|
|
1bade6d796 | ||
|
|
629a4a950e | ||
|
|
aebb1f6ec8 | ||
|
|
6e42bc55e0 | ||
|
|
1235fba7ee | ||
|
|
7a459db022 | ||
|
|
607987def5 | ||
|
|
397ec62180 | ||
|
|
9315210fbe | ||
|
|
5127990a43 | ||
|
|
40ad2b155a | ||
|
|
a0412d026c | ||
|
|
7d2134c488 | ||
|
|
d894f52b97 | ||
|
|
735f475c24 | ||
|
|
353dd73e24 | ||
|
|
49fe06498a | ||
|
|
bc95ec8084 | ||
|
|
f79906bf16 | ||
|
|
b3262fcb80 | ||
|
|
52b8f924aa | ||
|
|
52f57160aa | ||
|
|
6d4f23919c | ||
|
|
899623f71b | ||
|
|
c5d677ac7b | ||
|
|
c75270a9fc | ||
|
|
1588a379eb | ||
|
|
72d2075828 | ||
|
|
e99c682637 | ||
|
|
c815f70831 | ||
|
|
0da50eaa79 | ||
|
|
b0af84a549 | ||
|
|
b9631e8521 | ||
|
|
f664f7a201 | ||
|
|
f72b3882c3 | ||
|
|
ea47a2973c | ||
|
|
04be9ca670 | ||
|
|
6f0baf6ca9 | ||
|
|
1f5ec6b8d5 | ||
|
|
a2a91520aa | ||
|
|
fd7b5d3de7 | ||
|
|
30ea844c43 | ||
|
|
efac53b121 | ||
|
|
73c0ef59c1 | ||
|
|
7e65ab2d3b | ||
|
|
fec769f632 | ||
|
|
90e42642b6 | ||
|
|
9d9610a882 | ||
|
|
1fc81f4b66 | ||
|
|
4f0b1e847c | ||
|
|
9567ac32f2 | ||
|
|
8dd9cfa2a6 | ||
|
|
dbda8ef893 | ||
|
|
cd143c15d5 | ||
|
|
509a388ccc | ||
|
|
76c6482495 | ||
|
|
010a44f831 | ||
|
|
e6b0d644d4 | ||
|
|
02dc68c899 | ||
|
|
11ac97cd09 | ||
|
|
61f6565321 | ||
|
|
55d951f211 | ||
|
|
143ce6fcd5 | ||
|
|
e264c6ad2e | ||
|
|
036b6785f1 | ||
|
|
caf5cc90ae | ||
|
|
b05e98b1b6 | ||
|
|
31d0779377 | ||
|
|
6b056e915e | ||
|
|
9d6c0dc580 | ||
|
|
6e973e07f4 | ||
|
|
c8098b9eac | ||
|
|
ed20ce388a | ||
|
|
33e01e431d | ||
|
|
7d631e4959 | ||
|
|
29eb566448 | ||
|
|
a770d2a972 | ||
|
|
688cffb031 | ||
|
|
2cccc26541 | ||
|
|
f96f083bb5 | ||
|
|
2e078aff7d | ||
|
|
bd1f192dc4 | ||
|
|
b62f241051 | ||
|
|
95d1ac354e | ||
|
|
54728f5d57 | ||
|
|
d9356b0f86 | ||
|
|
6b68d9d90b | ||
|
|
359a8c4a81 | ||
|
|
dcb95d131b | ||
|
|
f4e37ba7c0 | ||
|
|
1cbceec0e1 | ||
|
|
5b3c5407a1 | ||
|
|
27a120c7c3 | ||
|
|
375f3e8bc1 | ||
|
|
a75b4af374 | ||
|
|
b2a4cd488d | ||
|
|
1d8d203e9e | ||
|
|
4e7fe460a5 | ||
|
|
9be14a63b1 | ||
|
|
afd3c76088 | ||
|
|
6b697506c3 | ||
|
|
3eba296157 | ||
|
|
1b51de08f5 | ||
|
|
3e37f3fa54 | ||
|
|
a18679e95d | ||
|
|
0154f81e33 | ||
|
|
366931952b | ||
|
|
606fc352aa | ||
|
|
75f817b39c | ||
|
|
0bc49bf244 | ||
|
|
930a84b459 | ||
|
|
21c89e8163 | ||
|
|
b3770cd26c | ||
|
|
0cd4d44bd3 | ||
|
|
af15e73e64 | ||
|
|
33f176b8f9 | ||
|
|
42f21972fd | ||
|
|
2d79e54c46 | ||
|
|
224408b0e8 | ||
|
|
610e447d7c | ||
|
|
c2c0e19305 | ||
|
|
e8c4b0d57c | ||
|
|
36e7684d9a | ||
|
|
795c079af0 | ||
|
|
94e1d3f0fc | ||
|
|
1df002de81 | ||
|
|
b7115659b3 | ||
|
|
258ec6b89a | ||
|
|
d1ecdfc510 | ||
|
|
a807e66d4a | ||
|
|
8f9921d00c | ||
|
|
99bc4e9a87 | ||
|
|
9289cfdde9 | ||
|
|
bedbe3caad | ||
|
|
2e329426ab | ||
|
|
4c68d03457 | ||
|
|
0911fa4fa2 | ||
|
|
c5737c5f74 | ||
|
|
106198fa20 | ||
|
|
4eb74a3c93 | ||
|
|
3f0bcc9568 | ||
|
|
f0c35fde6d | ||
|
|
8357eeb762 | ||
|
|
61da54d6ca | ||
|
|
efea47833d | ||
|
|
24ea08b6d3 | ||
|
|
2808b334ed | ||
|
|
96159cf739 | ||
|
|
577dfa4f54 | ||
|
|
66075d620e | ||
|
|
60f1d21914 | ||
|
|
b108621a59 | ||
|
|
4a4e703f16 | ||
|
|
61984730ac | ||
|
|
f196d3bab8 | ||
|
|
7da45cb49e | ||
|
|
e994305da6 | ||
|
|
2af37b484e | ||
|
|
faf41f7d96 | ||
|
|
7629e29397 | ||
|
|
1cff7fcfea | ||
|
|
694cf6e958 | ||
|
|
0e12fbb2a0 | ||
|
|
450ad45882 | ||
|
|
d674e50591 | ||
|
|
61f2f4b761 | ||
|
|
baa2f49b14 | ||
|
|
8c0bd234d8 | ||
|
|
c4fd41562f | ||
|
|
a1d1b4e49f | ||
|
|
96fb7a45f7 | ||
|
|
d5eedd2c65 | ||
|
|
fe4f907099 | ||
|
|
1b45eaf3de | ||
|
|
cfbc0a1579 | ||
|
|
db1b99d8dd | ||
|
|
65a880e9fa | ||
|
|
37b4005d3e | ||
|
|
70faa252e7 | ||
|
|
3620be8dbc | ||
|
|
21c64dd60f | ||
|
|
fb69d790ce | ||
|
|
debd066edd | ||
|
|
f58d81b1e9 | ||
|
|
8d507f161b | ||
|
|
b015f7c801 | ||
|
|
80abe952ba | ||
|
|
c12162407c | ||
|
|
7f5c3b223a | ||
|
|
2f3e4ebf39 | ||
|
|
2c14f8587e | ||
|
|
42224052e2 | ||
|
|
a8dd5aa0fc | ||
|
|
f3d0a9bc3f | ||
|
|
d629b9e36a | ||
|
|
4d54ba2200 | ||
|
|
0035ef9194 | ||
|
|
fcb20296d7 | ||
|
|
6bb9080017 | ||
|
|
bbde16dc08 | ||
|
|
ac9716f193 | ||
|
|
8a2bc1c21b | ||
|
|
942b474ad7 | ||
|
|
f3ef9b671f | ||
|
|
3538631e8e | ||
|
|
1577ab04e1 | ||
|
|
7f2dfaa5b4 | ||
|
|
fd126746f7 | ||
|
|
63f7e9feb0 | ||
|
|
5eb380e103 | ||
|
|
832e821919 | ||
|
|
197e3f144d | ||
|
|
056b5b41e2 | ||
|
|
15d40fd64a | ||
|
|
979d3da69c | ||
|
|
72984cc4a8 | ||
|
|
0a7a815124 | ||
|
|
1ce68a49c6 | ||
|
|
b1b6abf285 | ||
|
|
9dfd6970f1 | ||
|
|
3583c13339 | ||
|
|
00ab198c9f | ||
|
|
669d9a89ca | ||
|
|
9c54603726 | ||
|
|
dc09a50472 | ||
|
|
68eb7031e2 | ||
|
|
19623cac21 | ||
|
|
4ca25ca533 | ||
|
|
178c49a430 | ||
|
|
32e2cd9f06 | ||
|
|
7aa514d9ba | ||
|
|
7c2575d723 | ||
|
|
f93ea20d5e | ||
|
|
73cb6ff00d | ||
|
|
72267fa60b | ||
|
|
6b6a27e849 | ||
|
|
daea10121c | ||
|
|
999a1e514b | ||
|
|
be30960366 | ||
|
|
38e5084018 | ||
|
|
fdd9bb1af6 | ||
|
|
81546820ab | ||
|
|
84e87f0e8a | ||
|
|
901592a88e | ||
|
|
24f908d9be | ||
|
|
f62ff0ad66 | ||
|
|
8e0ecbeb8f | ||
|
|
095367f760 | ||
|
|
5d34eb12e0 | ||
|
|
d4e760efe1 | ||
|
|
75ab8e697b | ||
|
|
f4b05d46ed | ||
|
|
04c5f2c36a | ||
|
|
db50f95482 | ||
|
|
0e52a08a47 | ||
|
|
7b5d49ef60 | ||
|
|
430ba60b33 | ||
|
|
3af1f3bc63 | ||
|
|
bdcb94af81 | ||
|
|
2ea9e723c2 | ||
|
|
e19091d809 | ||
|
|
64ab59c0e0 | ||
|
|
4707b363aa | ||
|
|
1a72245c15 | ||
|
|
dea7b9050d | ||
|
|
3bd810fedc | ||
|
|
f9cbf8361d | ||
|
|
eccd4d0325 | ||
|
|
e0decf1233 | ||
|
|
100927f16c | ||
|
|
bb670f6658 | ||
|
|
d37992aaf9 | ||
|
|
9048ee533d | ||
|
|
2b1e5927ca | ||
|
|
b5e03030d1 | ||
|
|
65056bfa72 | ||
|
|
c50bb90374 | ||
|
|
ec4fc265e0 | ||
|
|
8ea41af5c4 | ||
|
|
966331dac7 | ||
|
|
cf056bace7 | ||
|
|
405a455906 | ||
|
|
3a8b431a5b | ||
|
|
3ce0c17237 | ||
|
|
61a2e0f104 | ||
|
|
7c44251216 | ||
|
|
26e70664d6 | ||
|
|
8ac27cc798 | ||
|
|
d314164fed | ||
|
|
d2cbed151b | ||
|
|
fc06ae58b2 | ||
|
|
a8768c78a2 | ||
|
|
ee8763f60d | ||
|
|
db633330fe | ||
|
|
c1ffafd663 | ||
|
|
72f35dc914 | ||
|
|
e5f82f53b9 | ||
|
|
e39e6893e0 | ||
|
|
9ab77d65f4 | ||
|
|
8ed96cad1d | ||
|
|
7795eb8239 | ||
|
|
207c7ab1e0 | ||
|
|
27af79684f | ||
|
|
6b61a8eed1 | ||
|
|
181e6eac75 | ||
|
|
fd1979857c | ||
|
|
448bc3facd | ||
|
|
97cabadb88 | ||
|
|
8e284a70b7 | ||
|
|
73f9febe06 | ||
|
|
6a6cc22e9c | ||
|
|
b293639b76 | ||
|
|
f06036be09 | ||
|
|
867571af78 | ||
|
|
f6314d3124 | ||
|
|
1e87dd7903 | ||
|
|
3b6af2f0c2 | ||
|
|
5bdff41641 | ||
|
|
67e9d105cb | ||
|
|
f1fc99f16f | ||
|
|
f89e359d53 | ||
|
|
77ec170a50 | ||
|
|
34320f5f20 | ||
|
|
a26271e46e | ||
|
|
e2e7466250 | ||
|
|
1e24cc4643 | ||
|
|
dfc23c3528 | ||
|
|
cd11a5dc27 | ||
|
|
899734296b | ||
|
|
7a3a81c152 | ||
|
|
e62a4a05ac | ||
|
|
463ca207ce | ||
|
|
da6e1b31ea | ||
|
|
8c783b1680 | ||
|
|
efce88ff12 | ||
|
|
01608b7e18 | ||
|
|
a5f0e0395a | ||
|
|
0b723174fd | ||
|
|
5d248bf0df | ||
|
|
c039ccdeb0 | ||
|
|
d88fb32a73 | ||
|
|
37ac409586 | ||
|
|
7b24e94c66 | ||
|
|
e12cd2a50c | ||
|
|
98b2ba4fc1 | ||
|
|
2f0afdccc1 | ||
|
|
79734df554 | ||
|
|
c52657fa1a | ||
|
|
9cac8409cd | ||
|
|
18703ce02d | ||
|
|
709a166bd6 | ||
|
|
8048e6297c | ||
|
|
fb0dded103 | ||
|
|
055e969e7a | ||
|
|
f10db8a30e | ||
|
|
c19af3525e | ||
|
|
7c60ccfc35 | ||
|
|
84cba33aab | ||
|
|
a52b1ec64f | ||
|
|
f30c4720ae | ||
|
|
7fc8c02688 | ||
|
|
54a7a0d534 | ||
|
|
8d73160a75 | ||
|
|
ff10602c65 | ||
|
|
ca50fe386d | ||
|
|
39f3c6e41d | ||
|
|
ba1b96e518 | ||
|
|
ef486b2cc6 | ||
|
|
06f3cb4f8e | ||
|
|
074f5ff996 | ||
|
|
8c26f32d5f |
5
Doxyfile
5
Doxyfile
@@ -22,7 +22,7 @@ PROJECT_NAME = SimGear
|
||||
# This could be handy for archiving the generated documentation or
|
||||
# if some version control system is used.
|
||||
|
||||
PROJECT_NUMBER = 0.3.7
|
||||
PROJECT_NUMBER = 0.3.10
|
||||
|
||||
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
|
||||
# base path where the generated documentation will be put.
|
||||
@@ -303,16 +303,19 @@ INPUT = \
|
||||
simgear/compiler.h \
|
||||
simgear/constants.h \
|
||||
simgear/debug \
|
||||
simgear/environment \
|
||||
simgear/ephemeris \
|
||||
simgear/io \
|
||||
simgear/magvar \
|
||||
simgear/math \
|
||||
simgear/misc \
|
||||
simgear/nasal \
|
||||
simgear/props \
|
||||
simgear/route \
|
||||
simgear/scene \
|
||||
simgear/screen \
|
||||
simgear/serial \
|
||||
simgear/structure \
|
||||
simgear/sg_inlines.h \
|
||||
simgear/sg_traits.hxx \
|
||||
simgear/sound \
|
||||
|
||||
@@ -4,13 +4,15 @@ EXTRA_DIST = \
|
||||
DoxygenMain.cxx \
|
||||
README.MSVC \
|
||||
README.zlib \
|
||||
projects \
|
||||
SimGear.dsp \
|
||||
SimGear.dsw
|
||||
|
||||
SUBDIRS = src-libs simgear
|
||||
SUBDIRS = simgear
|
||||
|
||||
dist-hook:
|
||||
(cd $(top_srcdir); $(HOME)/Projects/FlightGear-0.9/admin/am2dsp.pl)
|
||||
(cd $(top_srcdir); $(HOME)/Projects/FlightGear/admin/am2dsp.pl)
|
||||
rm -rf `find $(distdir)/projects -name CVS`
|
||||
|
||||
#
|
||||
# Rule to build RPM distribution package
|
||||
|
||||
96
NEWS
96
NEWS
@@ -1,3 +1,83 @@
|
||||
New in 0.3.10
|
||||
* April 5, 2006
|
||||
|
||||
* Add a small accessor function to expose local timezone offset.
|
||||
* Improved exception handling and made output more helpful in various places.
|
||||
* Better pbuffer runtime detection.
|
||||
* Add directory creation capability to file/path library.
|
||||
* Added a basic reference counting class to improve robustness of
|
||||
memory management in places. Use this for all scenegraph
|
||||
references, sgmaterial references, sgmatmodel references, and
|
||||
sgsoundsample references.
|
||||
* Add support for point sprites.
|
||||
* Updates to rain cone rendering.
|
||||
* Add a new vector library and integrate that with improved coordinate
|
||||
system conversion code.
|
||||
* Mutex locking and cleanup improvements in the threading abstraction
|
||||
library.
|
||||
* Add MacOS RenderTexture support.
|
||||
* Add a Nasal based io libarary that is not activated by default.
|
||||
* Added a set of MS-VC8 project files.
|
||||
|
||||
* Various platform related bug fixes.
|
||||
* Various compiler related bug/warning fixes.
|
||||
* Clean up some things that triggered valgrind warnings.
|
||||
* Fix a Nasal cmp() bug.
|
||||
* Removed ancient version of zlib from distribution.
|
||||
|
||||
|
||||
New in 0.3.9
|
||||
* November 17, 2005
|
||||
|
||||
* Add support for OpenAL 1.1 (with a separate alut library.)
|
||||
* Add support for volumetric shadows. Aircraft can cast shadows on themselves
|
||||
as well as onto the ground (by Harald Johnsen.)
|
||||
* New 3d volumetric clouds by Harald Johnsen (along with several rounds of
|
||||
followup fixes and improvements.)
|
||||
* Remove Mark Harris's old 3d clouds because they were never properly
|
||||
integrated. And we now have new 3d clouds.
|
||||
* Add support for seasonal textures (with a set of winter textures added
|
||||
to FlightGear.)
|
||||
* Updated Nasal scripting system. Adds several new syntax convenience
|
||||
features, fixes parser bugs, fixes several internal bugs.
|
||||
* Our 3d cockpit jitter problem is fixed (woohoo!)
|
||||
* Add code to support rendering to a texture.
|
||||
* Allow "tip" popups to pop themselves down after the appropriate
|
||||
timeout, even if the sim time is paused.
|
||||
* Various low model level animation fixes and additions ... color,
|
||||
transparency, 'chrome' effects, randomized spin, etc.
|
||||
* Create our own portable stdint.h implementation.
|
||||
* Fixed several memory leaks.
|
||||
* removeChildren() added to the property system.
|
||||
* Fix many cases of 'const'.
|
||||
* Fixes for cygwin, solaris/sun, Mac OS X, MSVC, gcc-3.4.x.
|
||||
|
||||
|
||||
New in 0.3.8
|
||||
* January 18, 2005
|
||||
|
||||
* Configure script does a sanity check for the existence of openal.
|
||||
* Better pthreads detection for FreeBSD.
|
||||
* Abstract out the location of gl.h, glu.h, and glut.h so we can more
|
||||
easily support MacOS which puts these in an oddball location.
|
||||
* Added two new debug output types for instrumentation and systems.
|
||||
* Add a name parameter to the waypoint class for supporting a route
|
||||
manager in the flightgear gps module.
|
||||
* Make display list usage optional.
|
||||
* Event manager: specifying a zero delay will force event execution in
|
||||
the next frame rather than entering an infinite loop.
|
||||
* gcc-4.0 fix.
|
||||
* Fixes to property tree loading and saving.
|
||||
* Make volume inaudible at startup.
|
||||
* Solaris fixes.
|
||||
* For low density cloud coverage, blend the layer to nothing as we pass
|
||||
through instead of fully engulfing the aircraft in the cloud.
|
||||
* Add several new capabilities to the texture management code for building
|
||||
normal maps and doing some simple on-the-fly effects on textures.
|
||||
* Better error message for sound problems.
|
||||
* Add support for binding a thread to a specific CPU.
|
||||
|
||||
|
||||
New in 0.3.7
|
||||
* October 12, 2004
|
||||
|
||||
@@ -33,7 +113,7 @@ New in 0.3.5
|
||||
* Support VASI/PAPI lights correctly.
|
||||
* Fixes to cloud animation.
|
||||
* Updates to sky dome coloring as well as sun/moon coloring.
|
||||
* Vary environment lighting with visibility (subtlely.)
|
||||
* Vary environment lighting with visibility (subtlety.)
|
||||
* Support control of alpha test in model animation.
|
||||
* Complete rewrite of the event manager.
|
||||
* Updates to low level socket code to make it more flexible.
|
||||
@@ -84,7 +164,7 @@ New in 0.3.2
|
||||
management, basic model and model animation management, sky
|
||||
rendering, and low level loaders for the "TerraGear" tile object format.
|
||||
* Removed support of the flat shaded and non-textured material
|
||||
property varients. You can still do these things, but extra states
|
||||
property variants. You can still do these things, but extra states
|
||||
are no longer set up automatically.
|
||||
* Removed 3d clouds from the default build ... these need a maintainer
|
||||
or better yet, a complete plib-based rewrite.
|
||||
@@ -129,7 +209,7 @@ New in 0.2.0
|
||||
* Removed efence support (in favor of valgrind.)
|
||||
|
||||
* Added a javascript interpreter.
|
||||
* SGSocket reimplimented on top of plib/net libs.
|
||||
* SGSocket reimplemented on top of plib/net libs.
|
||||
* Added a new random number generation algorithm.
|
||||
* Total rewrite of the strutils package.
|
||||
|
||||
@@ -139,7 +219,7 @@ New in 0.2.0
|
||||
* Mac OS X fixes.
|
||||
* Irix fixes.
|
||||
* Code clean ups to remove warning messages.
|
||||
* Optimizations in sg_binobj to reduce the amout of memory copying
|
||||
* Optimizations in sg_binobj to reduce the amount of memory copying
|
||||
needed when loading a binobj format file.
|
||||
* Fixed a couple places where variables could be used before they were
|
||||
initialized.
|
||||
@@ -159,7 +239,7 @@ New in 0.0.18
|
||||
* Upgrade to metakit-2.4.2-32.tar.gz (latest upstream release)
|
||||
* Added support for point objects in the scenery file format.
|
||||
* Additions to the binary file format to make it *much* more flexible.
|
||||
For each major primative type: points, triangles, fans, and strips, you
|
||||
For each major primitive type: points, triangles, fans, and strips, you
|
||||
can specify an index list of vertices, normals, colors, and texture
|
||||
coordinates. You can skip any of these you like to save on space.
|
||||
* Added support for new file features in the binary -> ascii scenery file
|
||||
@@ -210,7 +290,7 @@ New in 0.0.17pre1
|
||||
|
||||
New in 0.0.16
|
||||
* July 12, 2001
|
||||
* Various changes to the property manager implimentation to better support
|
||||
* Various changes to the property manager implementation to better support
|
||||
dumping out the desired portions of the property tree to file.
|
||||
* Don't compile the metakit demos by default (causes problems for Irix)'
|
||||
* Other various tweaks for Irix.
|
||||
@@ -253,7 +333,7 @@ New in 0.0.15
|
||||
read/write routines.
|
||||
* Added doxygen comments for all public interface code. Documentation
|
||||
can be accessed via the SimGear web page.
|
||||
* Many FG -> SG name space changes for better consistancy throughout
|
||||
* Many FG -> SG name space changes for better consistency throughout
|
||||
this package.
|
||||
* Added property aliases, repeated name tags, and a general xml
|
||||
inclusion facilities. Many other property manager clean ups
|
||||
@@ -344,4 +424,4 @@ New in 0.0.4
|
||||
|
||||
|
||||
New in 0.0.3
|
||||
* Release that conincides with FlightGear-0.7.2
|
||||
* Release that coincides with FlightGear-0.7.2
|
||||
|
||||
12
README.OpenAL
Normal file
12
README.OpenAL
Normal file
@@ -0,0 +1,12 @@
|
||||
[This file is mirrored in both the FlightGear and SimGear packages.]
|
||||
|
||||
You *must* have the development components of OpenAL installed on your system
|
||||
to build FlightGear!" You can get a copy here:
|
||||
|
||||
http://www.openal.org
|
||||
|
||||
Build notes:
|
||||
|
||||
The OpenAL developers do not make "versioned" releases so we recommend that
|
||||
you pull the latest version via anonymous CVS (follow the instructions at
|
||||
the OpenAL web site) and build/install that.
|
||||
175
README.zlib
175
README.zlib
@@ -1,173 +1,8 @@
|
||||
For your convenience and allowed by zlib's license terms:
|
||||
http://www.gzip.org/zlib/zlib_license.html a copy of the zlib source
|
||||
is bundled with SimGear in $(top_srcdir)/src-libs/. You must have
|
||||
zlib installed before you can build SimGear.
|
||||
zlib is prerequisite for compiling SimGear and FlightGear. You can fetch
|
||||
the latest version of zlib from:
|
||||
|
||||
- Most linux distributions have a zlib package. For linux
|
||||
developers, we recommend ysou install your distributions package
|
||||
rather than building from source.
|
||||
http://www.zlib.net
|
||||
|
||||
- Cygwin installs zlib automatically.
|
||||
Most modern unix distributions (and cygwin) come with a version of zlib
|
||||
already installed or available to install as a package.
|
||||
|
||||
- For developers on most other platforms, you will have to build
|
||||
zlib from source and install it yourself. For your convenience a
|
||||
tar ball of the zlib source is included with the simgear source
|
||||
distribution. Untar the zlib source, and follow the included
|
||||
build and installation instructions.
|
||||
|
||||
Once zlib is installed you can return to configuring and building
|
||||
Simgear.
|
||||
|
||||
We now send you to the official zlib README ...
|
||||
|
||||
|
||||
=============================================================================
|
||||
|
||||
|
||||
zlib 1.1.4 is a general purpose data compression library. All the code
|
||||
is thread safe. The data format used by the zlib library
|
||||
is described by RFCs (Request for Comments) 1950 to 1952 in the files
|
||||
http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate
|
||||
format) and rfc1952.txt (gzip format). These documents are also available in
|
||||
other formats from ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
|
||||
|
||||
All functions of the compression library are documented in the file zlib.h
|
||||
(volunteer to write man pages welcome, contact jloup@gzip.org). A usage
|
||||
example of the library is given in the file example.c which also tests that
|
||||
the library is working correctly. Another example is given in the file
|
||||
minigzip.c. The compression library itself is composed of all source files
|
||||
except example.c and minigzip.c.
|
||||
|
||||
To compile all files and run the test program, follow the instructions
|
||||
given at the top of Makefile. In short "make test; make install"
|
||||
should work for most machines. For Unix: "./configure; make test; make install"
|
||||
For MSDOS, use one of the special makefiles such as Makefile.msc.
|
||||
For VMS, use Make_vms.com or descrip.mms.
|
||||
|
||||
Questions about zlib should be sent to <zlib@gzip.org>, or to
|
||||
Gilles Vollant <info@winimage.com> for the Windows DLL version.
|
||||
The zlib home page is http://www.zlib.org or http://www.gzip.org/zlib/
|
||||
Before reporting a problem, please check this site to verify that
|
||||
you have the latest version of zlib; otherwise get the latest version and
|
||||
check whether the problem still exists or not.
|
||||
|
||||
PLEASE read the zlib FAQ http://www.gzip.org/zlib/zlib_faq.html
|
||||
before asking for help.
|
||||
|
||||
Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
|
||||
issue of Dr. Dobb's Journal; a copy of the article is available in
|
||||
http://dogma.net/markn/articles/zlibtool/zlibtool.htm
|
||||
|
||||
The changes made in version 1.1.4 are documented in the file ChangeLog.
|
||||
The only changes made since 1.1.3 are bug corrections:
|
||||
|
||||
- ZFREE was repeated on same allocation on some error conditions.
|
||||
This creates a security problem described in
|
||||
http://www.zlib.org/advisory-2002-03-11.txt
|
||||
- Returned incorrect error (Z_MEM_ERROR) on some invalid data
|
||||
- Avoid accesses before window for invalid distances with inflate window
|
||||
less than 32K.
|
||||
- force windowBits > 8 to avoid a bug in the encoder for a window size
|
||||
of 256 bytes. (A complete fix will be available in 1.1.5).
|
||||
|
||||
The beta version 1.1.5beta includes many more changes. A new official
|
||||
version 1.1.5 will be released as soon as extensive testing has been
|
||||
completed on it.
|
||||
|
||||
|
||||
Unsupported third party contributions are provided in directory "contrib".
|
||||
|
||||
A Java implementation of zlib is available in the Java Development Kit
|
||||
http://www.javasoft.com/products/JDK/1.1/docs/api/Package-java.util.zip.html
|
||||
See the zlib home page http://www.zlib.org for details.
|
||||
|
||||
A Perl interface to zlib written by Paul Marquess <pmarquess@bfsec.bt.co.uk>
|
||||
is in the CPAN (Comprehensive Perl Archive Network) sites
|
||||
http://www.cpan.org/modules/by-module/Compress/
|
||||
|
||||
A Python interface to zlib written by A.M. Kuchling <amk@magnet.com>
|
||||
is available in Python 1.5 and later versions, see
|
||||
http://www.python.org/doc/lib/module-zlib.html
|
||||
|
||||
A zlib binding for TCL written by Andreas Kupries <a.kupries@westend.com>
|
||||
is availlable at http://www.westend.com/~kupries/doc/trf/man/man.html
|
||||
|
||||
An experimental package to read and write files in .zip format,
|
||||
written on top of zlib by Gilles Vollant <info@winimage.com>, is
|
||||
available at http://www.winimage.com/zLibDll/unzip.html
|
||||
and also in the contrib/minizip directory of zlib.
|
||||
|
||||
|
||||
Notes for some targets:
|
||||
|
||||
- To build a Windows DLL version, include in a DLL project zlib.def, zlib.rc
|
||||
and all .c files except example.c and minigzip.c; compile with -DZLIB_DLL
|
||||
The zlib DLL support was initially done by Alessandro Iacopetti and is
|
||||
now maintained by Gilles Vollant <info@winimage.com>. Check the zlib DLL
|
||||
home page at http://www.winimage.com/zLibDll
|
||||
|
||||
From Visual Basic, you can call the DLL functions which do not take
|
||||
a structure as argument: compress, uncompress and all gz* functions.
|
||||
See contrib/visual-basic.txt for more information, or get
|
||||
http://www.tcfb.com/dowseware/cmp-z-it.zip
|
||||
|
||||
- For 64-bit Irix, deflate.c must be compiled without any optimization.
|
||||
With -O, one libpng test fails. The test works in 32 bit mode (with
|
||||
the -n32 compiler flag). The compiler bug has been reported to SGI.
|
||||
|
||||
- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1
|
||||
it works when compiled with cc.
|
||||
|
||||
- on Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1
|
||||
is necessary to get gzprintf working correctly. This is done by configure.
|
||||
|
||||
- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works
|
||||
with other compilers. Use "make test" to check your compiler.
|
||||
|
||||
- gzdopen is not supported on RISCOS, BEOS and by some Mac compilers.
|
||||
|
||||
- For Turbo C the small model is supported only with reduced performance to
|
||||
avoid any far allocation; it was tested with -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3
|
||||
|
||||
- For PalmOs, see http://www.cs.uit.no/~perm/PASTA/pilot/software.html
|
||||
Per Harald Myrvang <perm@stud.cs.uit.no>
|
||||
|
||||
|
||||
Acknowledgments:
|
||||
|
||||
The deflate format used by zlib was defined by Phil Katz. The deflate
|
||||
and zlib specifications were written by L. Peter Deutsch. Thanks to all the
|
||||
people who reported problems and suggested various improvements in zlib;
|
||||
they are too numerous to cite here.
|
||||
|
||||
Copyright notice:
|
||||
|
||||
(C) 1995-2002 Jean-loup Gailly and Mark Adler
|
||||
|
||||
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.
|
||||
|
||||
Jean-loup Gailly Mark Adler
|
||||
jloup@gzip.org madler@alumni.caltech.edu
|
||||
|
||||
If you use the zlib library in a product, we would appreciate *not*
|
||||
receiving lengthy legal documents to sign. The sources are provided
|
||||
for free but without warranty of any kind. The library has been
|
||||
entirely written by Jean-loup Gailly and Mark Adler; it does not
|
||||
include third-party code.
|
||||
|
||||
If you redistribute modified sources, we would appreciate that you include
|
||||
in the file ChangeLog history information documenting your changes.
|
||||
|
||||
1178
SimGear.dsp
1178
SimGear.dsp
File diff suppressed because it is too large
Load Diff
24
SimGear.dsw
24
SimGear.dsw
@@ -15,30 +15,6 @@ Package=<4>
|
||||
|
||||
###############################################################################
|
||||
|
||||
Project: "mklib"=".\SimGear\metakit-2.4.3\win\msvc60\mklib.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<4>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
Project: "zlib"=".\SimGear\zlib.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<4>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
Global:
|
||||
|
||||
Package=<5>
|
||||
|
||||
25
Thanks
25
Thanks
@@ -47,6 +47,18 @@ Jean-Francois Doue
|
||||
http://www.animats.com/simpleppp/ftp/public_html/topics/developers.html
|
||||
|
||||
|
||||
Melchior Franz
|
||||
METAR parser and fetcher. "material" animation (based on Jim Wilsons's
|
||||
"emission" animation). Debugging and extension of property listener
|
||||
features. Addition of removeChildren.
|
||||
|
||||
|
||||
Mathias Froehlich
|
||||
Reworked and cleaned up large parts of the infrastructure, of math
|
||||
files, animations and rendering in preparation of a transition to
|
||||
the OSG library. Added new handlers for shared and referenced objects.
|
||||
|
||||
|
||||
Bruce Finney <bfinney@gte.net>
|
||||
MSVC5 compatibility.
|
||||
|
||||
@@ -71,6 +83,10 @@ Bruce Jackson of NASA <e.b.jackson@larc.nasa.gov>
|
||||
http://dcb.larc.nasa.gov/www/DCBStaff/ebj/ebj.html
|
||||
|
||||
|
||||
Maik Justus
|
||||
Fixed an old bug in the SGPropertyNode class.
|
||||
|
||||
|
||||
Richard Kaszeta <bofh@me.umn.edu>
|
||||
Contributed screen buffer to ppm screen shot routine.
|
||||
Rich has also helped in the early development of the Flight Gear "altitude
|
||||
@@ -90,7 +106,12 @@ David Megginson <david@megginson.com>
|
||||
SimGear property manager/registry
|
||||
|
||||
|
||||
Curt Olson <curt@flightgear.org>
|
||||
Tim Moore
|
||||
Ported the (chrome) "shader" animation to OSG, and helped with porting
|
||||
the "material" animation.
|
||||
|
||||
|
||||
Curt Olson http://www.flightgear.org/~curt/
|
||||
Curt is responsible for overall project and source code management.
|
||||
He has his hands in many of the areas.
|
||||
|
||||
@@ -175,7 +196,7 @@ NOTE:
|
||||
----
|
||||
|
||||
THIS DOCUMENT WAS INITIALLY WRITTEN BY
|
||||
Curt L. Olson <curt@flightgear.org>
|
||||
Curt L. Olson <http://www.flightgear.org/~curt>
|
||||
|
||||
|
||||
05 Jul 2000 Removed non-SimGear entries (CLO)
|
||||
|
||||
36
acinclude.m4
36
acinclude.m4
@@ -3,7 +3,7 @@ dnl originally from ncftp 2.3.0
|
||||
dnl added wi_EXTRA_PDIR and wi_ANSI_C
|
||||
dnl $Id$
|
||||
dnl
|
||||
AC_DEFUN(wi_EXTRA_IDIR, [
|
||||
AC_DEFUN([wi_EXTRA_IDIR], [
|
||||
incdir="$1"
|
||||
if test -r $incdir ; then
|
||||
case "$CPPFLAGS" in
|
||||
@@ -25,7 +25,7 @@ dnl
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_EXTRA_LDIR, [
|
||||
AC_DEFUN([wi_EXTRA_LDIR], [
|
||||
mylibdir="$1"
|
||||
if test -r $mylibdir ; then
|
||||
case "$LDFLAGS" in
|
||||
@@ -47,7 +47,7 @@ dnl
|
||||
dnl __FP__
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_EXTRA_PDIR, [
|
||||
AC_DEFUN([wi_EXTRA_PDIR], [
|
||||
progdir="$1"
|
||||
if test -r $progdir ; then
|
||||
case "$PATH" in
|
||||
@@ -76,7 +76,7 @@ dnl
|
||||
dnl If you want to look for subdirectories in include/lib directories,
|
||||
dnl you pass the names in argument 3, otherwise pass a dash.
|
||||
dnl
|
||||
AC_DEFUN(wi_EXTRA_DIRS, [echo "checking for extra include and lib directories..." 1>&6
|
||||
AC_DEFUN([wi_EXTRA_DIRS], [echo "checking for extra include and lib directories..." 1>&6
|
||||
ifelse([$1], yes, [dnl
|
||||
b1=`cd .. ; pwd`
|
||||
b2=`cd ../.. ; pwd`
|
||||
@@ -111,7 +111,7 @@ done
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_HPUX_CFLAGS,
|
||||
AC_DEFUN([wi_HPUX_CFLAGS],
|
||||
[AC_MSG_CHECKING(if HP-UX ansi C compiler flags are needed)
|
||||
AC_REQUIRE([AC_PROG_CC])
|
||||
os=`uname -s | tr '[A-Z]' '[a-z]'`
|
||||
@@ -144,7 +144,7 @@ AC_MSG_RESULT($ac_cv_hpux_flags)
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_CFLAGS, [AC_REQUIRE([AC_PROG_CC])
|
||||
AC_DEFUN([wi_CFLAGS], [AC_REQUIRE([AC_PROG_CC])
|
||||
wi_HPUX_CFLAGS
|
||||
if test "$CFLAGS" = "" ; then
|
||||
CFLAGS="-O"
|
||||
@@ -165,7 +165,7 @@ wi_HPUX_CFLAGS
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_PROTOTYPES, [
|
||||
AC_DEFUN([wi_PROTOTYPES], [
|
||||
AC_MSG_CHECKING(if the compiler supports function prototypes)
|
||||
AC_TRY_COMPILE(,[extern void exit(int status);],[wi_cv_prototypes=yes
|
||||
AC_DEFINE(PROTOTYPES)],wi_cv_prototypes=no)
|
||||
@@ -174,7 +174,7 @@ AC_MSG_RESULT($wi_cv_prototypes)
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_ANSI_C, [
|
||||
AC_DEFUN([wi_ANSI_C], [
|
||||
AC_MSG_CHECKING(ANSI-style function definitions)
|
||||
AC_TRY_COMPILE(,[int blubb(int x) { return 0; }],[wi_cv_ansi_funcs=yes
|
||||
AC_DEFINE(ANSI_FUNCS)],wi_cv_ansi_funcs=no)
|
||||
@@ -183,7 +183,7 @@ AC_MSG_RESULT($wi_cv_ansi_funcs)
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_HEADER_SYS_SELECT_H, [
|
||||
AC_DEFUN([wi_HEADER_SYS_SELECT_H], [
|
||||
# See if <sys/select.h> is includable after <sys/time.h>
|
||||
if test "$ac_cv_header_sys_time_h" = no ; then
|
||||
AC_CHECK_HEADERS(sys/time.h sys/select.h)
|
||||
@@ -211,7 +211,7 @@ fi
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_LIB_RESOLV, [
|
||||
AC_DEFUN([wi_LIB_RESOLV], [
|
||||
# See if we could access two well-known sites without help of any special
|
||||
# libraries, like resolv.
|
||||
|
||||
@@ -244,7 +244,7 @@ dnl
|
||||
dnl
|
||||
dnl
|
||||
|
||||
AC_DEFUN(wi_LIB_NSL, [
|
||||
AC_DEFUN([wi_LIB_NSL], [
|
||||
AC_MSG_CHECKING(if we can use -lnsl)
|
||||
ac_save_LIBS="$LIBS";
|
||||
LIBS="$LIBS -lnsl";
|
||||
@@ -261,7 +261,7 @@ dnl
|
||||
dnl
|
||||
dnl
|
||||
|
||||
AC_DEFUN(nc_PATH_PROG_ZCAT, [
|
||||
AC_DEFUN([nc_PATH_PROG_ZCAT], [
|
||||
AC_PATH_PROG(GZCAT,gzcat)
|
||||
AC_PATH_PROG(ZCAT,zcat)
|
||||
if test "x$GZCAT" = x ; then
|
||||
@@ -287,7 +287,7 @@ fi
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_SYSV_EXTRA_DIRS, [
|
||||
AC_DEFUN([wi_SYSV_EXTRA_DIRS], [
|
||||
# Use System V because their curses extensions are required. This must
|
||||
# be done early so we use the -I and -L in the library checks also.
|
||||
# This is mostly a Solaris/SunOS hack. Note that doing this will also
|
||||
@@ -305,7 +305,7 @@ fi
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_DEFINE_UNAME, [
|
||||
AC_DEFUN([wi_DEFINE_UNAME], [
|
||||
# Get first 127 chars of all uname information. Some folks have
|
||||
# way too much stuff there, so grab only the first 127.
|
||||
unam=`uname -a 2>/dev/null | cut -c1-127`
|
||||
@@ -316,7 +316,7 @@ fi
|
||||
dnl
|
||||
dnl
|
||||
dnl
|
||||
AC_DEFUN(wi_READLINE_WITH_NCURSES, [
|
||||
AC_DEFUN([wi_READLINE_WITH_NCURSES], [
|
||||
# Readline and Ncurses could both define "backspace".
|
||||
# Warn about this if we have both things in our definitions list.
|
||||
|
||||
@@ -352,7 +352,7 @@ dnl
|
||||
|
||||
dnl AC_EXT_DAYLIGHT
|
||||
dnl Check for an external variable daylight. Stolen from w3c-libwww.
|
||||
AC_DEFUN(AC_EXT_DAYLIGHT,
|
||||
AC_DEFUN([AC_EXT_DAYLIGHT],
|
||||
[ AC_MSG_CHECKING(int daylight variable)
|
||||
AC_TRY_COMPILE([#include <time.h>], [return daylight;],
|
||||
have_daylight=yes,
|
||||
@@ -362,7 +362,7 @@ AC_MSG_RESULT($have_daylight)
|
||||
|
||||
dnl AC_EXT_TIMEZONE
|
||||
dnl Check for an external variable timezone. Stolen from tcl-8.0.
|
||||
AC_DEFUN(AC_EXT_TIMEZONE,
|
||||
AC_DEFUN([AC_EXT_TIMEZONE],
|
||||
[
|
||||
#
|
||||
# Its important to include time.h in this check, as some systems (like convex)
|
||||
@@ -395,7 +395,7 @@ fi
|
||||
|
||||
## AC_BZ_SET_COMPILER: Addition by Theodore Papadopoulo
|
||||
## Patch by Jim McKelvey: change sed -e 's/ /@/g' to sed -e 's/ /@/'
|
||||
AC_DEFUN(AC_SG_SET_COMPILER,
|
||||
AC_DEFUN([AC_SG_SET_COMPILER],
|
||||
[cxxwith=`echo $1 | sed -e 's/ /@/'`
|
||||
case "$cxxwith" in
|
||||
*:*@*) # Full initialization syntax
|
||||
|
||||
@@ -4,14 +4,13 @@ exclude_dir = threads
|
||||
include_path = .
|
||||
include_path = ..
|
||||
include_path = .\SimGear
|
||||
include_path = .\SimGear\metakit-2.4.3\include
|
||||
include_path = ..\SimGear\zlib-1.1.4
|
||||
include_path = ..\zlib-1.2.3
|
||||
include_path = "..\OpenAL 1.0 Software Development Kit\include"
|
||||
|
||||
define = _USE_MATH_DEFINES
|
||||
define = _CRT_SECURE_NO_DEPRECATE
|
||||
define = HAVE_CONFIG_H
|
||||
|
||||
add_project = .\SimGear\metakit-2.4.3\win\msvc60\mklib.dsp,mklib
|
||||
add_project = .\SimGear\zlib.dsp,zlib
|
||||
|
||||
# Rule to create simgear_config.h
|
||||
add_source_file = SOURCE=.\simgear\simgear_config.h.vc5\
|
||||
\
|
||||
|
||||
91
configure.ac
91
configure.ac
@@ -1,7 +1,5 @@
|
||||
dnl Process this file with autoget.sh to produce a working configure
|
||||
dnl script.
|
||||
dnl
|
||||
dnl $Id$
|
||||
|
||||
AC_INIT
|
||||
AC_CONFIG_SRCDIR([simgear/bucket/newbucket.cxx])
|
||||
@@ -10,7 +8,7 @@ dnl Require at least automake 2.52
|
||||
AC_PREREQ(2.52)
|
||||
|
||||
dnl Initialize the automake stuff
|
||||
AM_INIT_AUTOMAKE(SimGear, 0.3.7)
|
||||
AM_INIT_AUTOMAKE(SimGear, 0.3.10)
|
||||
|
||||
dnl Specify KAI C++ compiler and flags.
|
||||
dnl Borrowed with slight modification from blitz distribution.
|
||||
@@ -121,9 +119,17 @@ if test "x$with_plib" != "x" ; then
|
||||
EXTRA_DIRS="${EXTRA_DIRS} $with_plib"
|
||||
fi
|
||||
|
||||
# specify the osg location
|
||||
AC_ARG_WITH(osg, [ --with-osg=PREFIX Specify the prefix path to osg])
|
||||
|
||||
if test "x$with_osg" != "x" ; then
|
||||
echo "osg prefix is $with_osg"
|
||||
EXTRA_DIRS="${EXTRA_DIRS} $with_osg"
|
||||
fi
|
||||
|
||||
dnl Determine an extra directories to add to include/lib search paths
|
||||
case "${host}" in
|
||||
*-apple-darwin* | *-*-mingw32*)
|
||||
*-apple-darwin* | *-*-cygwin* | *-*-mingw32*)
|
||||
echo no EXTRA_DIRS for $host
|
||||
;;
|
||||
|
||||
@@ -165,33 +171,18 @@ dnl Checks for libraries.
|
||||
|
||||
dnl Thread related checks
|
||||
AC_CHECK_HEADER(pthread.h)
|
||||
AC_CHECK_LIB(pthread, pthread_exit)
|
||||
if test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h" = "xyes"; then
|
||||
AC_SEARCH_LIBS(pthread_exit, [pthread c_r])
|
||||
if test "x$ac_cv_header_pthread_h" = "xyes"; then
|
||||
CXXFLAGS="$CXXFLAGS -D_REENTRANT"
|
||||
CFLAGS="$CFLAGS -D_REENTRANT"
|
||||
fi
|
||||
if test "x$ac_cv_lib_pthread_pthread_exit" != "xyes" -a "x$ac_cv_header_pthread_h" = "xyes"; then
|
||||
dnl FreeBSD: System has pthread.h, but -lpthread library check
|
||||
dnl fails. See if we need -pthread instead of -lpthread and look
|
||||
dnl for the functions in libc_r.
|
||||
save_CXXFLAGS="$CXXFLAGS"
|
||||
save_CFLAGS="$CFLAGS"
|
||||
|
||||
if test "x$ac_cv_search_pthread_exit" = "x-lc_r"; then
|
||||
CXXFLAGS="-pthread $CXXFLAGS"
|
||||
CFLAGS="-pthread $FLAGS"
|
||||
save_LIBS=$LIBS
|
||||
AC_CHECK_LIB(c_r, pthread_exit)
|
||||
if test "x$ac_cv_lib_c_r_pthread_exit" != "xyes"; then
|
||||
CXXFLAGS=$save_CXXFLAGS
|
||||
CFLAGS=$save_CFLAGS
|
||||
else
|
||||
dnl This is cheating a bit. pthread_exit comes with using -pthread, not
|
||||
-lpthread
|
||||
ac_cv_lib_pthread_pthread_exit="yes"
|
||||
fi
|
||||
LIBS=$save_LIBS
|
||||
CFLAGS="-pthread $CFLAGS"
|
||||
fi
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(HAVE_THREADS, test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h" = "xyes")
|
||||
AM_CONDITIONAL(HAVE_THREADS, test "x$ac_cv_header_pthread_h" = "xyes")
|
||||
|
||||
thread_LIBS="$LIBS"
|
||||
LIBS=""
|
||||
@@ -267,34 +258,60 @@ case "${host}" in
|
||||
|
||||
esac
|
||||
|
||||
AC_SEARCH_LIBS(glutGetModifiers, [ glut glut32 freeglut ], have_glut=yes, have_glut=no)
|
||||
AM_CONDITIONAL(HAVE_GLUT, test "x$have_glut" = "xyes")
|
||||
|
||||
opengl_LIBS="$LIBS"
|
||||
LIBS="$base_LIBS"
|
||||
|
||||
dnl check for OpenAL libraries
|
||||
OPENAL_OK="no"
|
||||
case "${host}" in
|
||||
*-*-cygwin* | *-*-mingw32*)
|
||||
dnl CygWin under Windoze.
|
||||
|
||||
AC_SEARCH_LIBS(alGenBuffers, openal32)
|
||||
AC_SEARCH_LIBS(alutInit, [ openal32 ALut ] )
|
||||
INCLUDES="$INCLUDES -I/usr/local/include/"
|
||||
LIBS="$LIBS -L/usr/local/lib"
|
||||
AC_SEARCH_LIBS(alGenBuffers, [ openal32 openal ] )
|
||||
AC_SEARCH_LIBS(alutInit, [ openal32 ALut alut ] )
|
||||
LIBS="$LIBS -lwinmm -ldsound -ldxguid -lole32"
|
||||
openal_LIBS="$LIBS"
|
||||
OPENAL_OK="$ac_cv_search_alGenBuffers"
|
||||
;;
|
||||
|
||||
*-apple-darwin*)
|
||||
dnl Mac OS X
|
||||
|
||||
LIBS="$LIBS -framework IOKit -framework OpenAL"
|
||||
openal_LIBS="$LIBS"
|
||||
# not sure how to test if OpenAL exists on MacOS (does it come by default?)
|
||||
OPENAL_OK="yes"
|
||||
;;
|
||||
|
||||
*)
|
||||
dnl default unix style machines
|
||||
|
||||
save_LIBS=$LIBS
|
||||
LIBS="$LIBS $thread_LIBS"
|
||||
AC_SEARCH_LIBS(alGenBuffers, openal)
|
||||
AC_SEARCH_LIBS(alutInit, [ alut openal ] )
|
||||
OPENAL_OK="$ac_cv_search_alGenBuffers"
|
||||
openal_LIBS="$LIBS"
|
||||
LIBS=$save_LIBS
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
openal_LIBS="$LIBS"
|
||||
if test "$OPENAL_OK" == "no"; then
|
||||
echo
|
||||
echo "You *must* have the openal library installed on your system to build"
|
||||
echo "SimGear!"
|
||||
echo
|
||||
echo "Please see README.OpenAL for more details."
|
||||
echo
|
||||
echo "configure aborted."
|
||||
exit
|
||||
fi
|
||||
|
||||
LIBS="$base_LIBS"
|
||||
|
||||
AC_SUBST(base_LIBS)
|
||||
@@ -325,11 +342,11 @@ if test "x$ac_cv_header_plib_ul_h" != "xyes"; then
|
||||
exit
|
||||
fi
|
||||
|
||||
AC_MSG_CHECKING([for plib 1.6.0 or newer])
|
||||
AC_MSG_CHECKING([for plib 1.8.4 or newer])
|
||||
AC_TRY_RUN([
|
||||
#include <plib/ul.h>
|
||||
|
||||
#define MIN_PLIB_VERSION 160
|
||||
#define MIN_PLIB_VERSION 184
|
||||
|
||||
int main() {
|
||||
int major, minor, micro;
|
||||
@@ -344,7 +361,7 @@ int main() {
|
||||
],
|
||||
AC_MSG_RESULT(yes),
|
||||
[AC_MSG_RESULT(wrong version);
|
||||
AC_MSG_ERROR([Install plib 1.6.0 or later first...])],
|
||||
AC_MSG_ERROR([Install plib 1.8.4 or later first...])],
|
||||
AC_MSG_RESULT(yes)
|
||||
)
|
||||
|
||||
@@ -381,6 +398,7 @@ fi
|
||||
dnl Checks for typedefs, structures, and compiler characteristics.
|
||||
AC_C_CONST
|
||||
AC_TYPE_SIZE_T
|
||||
AC_TYPE_MODE_T
|
||||
AC_HEADER_TIME
|
||||
AC_STRUCT_TM
|
||||
|
||||
@@ -399,7 +417,6 @@ AM_CONFIG_HEADER(simgear/simgear_config.h)
|
||||
AC_CONFIG_FILES([ \
|
||||
Makefile \
|
||||
SimGear.spec \
|
||||
src-libs/Makefile \
|
||||
simgear/Makefile \
|
||||
simgear/version.h \
|
||||
simgear/compatibility/Makefile \
|
||||
@@ -417,19 +434,17 @@ AC_CONFIG_FILES([ \
|
||||
simgear/props/Makefile \
|
||||
simgear/route/Makefile \
|
||||
simgear/scene/Makefile \
|
||||
simgear/scene/fgsg/Makefile \
|
||||
simgear/scene/material/Makefile \
|
||||
simgear/scene/model/Makefile \
|
||||
simgear/scene/sky/Makefile \
|
||||
simgear/scene/sky/clouds3d/Makefile \
|
||||
simgear/scene/tgdb/Makefile \
|
||||
simgear/scene/util/Makefile \
|
||||
simgear/screen/Makefile \
|
||||
simgear/serial/Makefile \
|
||||
simgear/sound/Makefile \
|
||||
simgear/structure/Makefile \
|
||||
simgear/threads/Makefile \
|
||||
simgear/timing/Makefile \
|
||||
simgear/xgl/Makefile \
|
||||
simgear/xml/Makefile \
|
||||
])
|
||||
AC_OUTPUT
|
||||
@@ -456,7 +471,7 @@ else
|
||||
echo "Without JPEG Factory support"
|
||||
fi
|
||||
|
||||
if test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h" = "xyes"; then
|
||||
if test "x$ac_cv_header_pthread_h" = "xyes"; then
|
||||
echo "Threads: pthread lib found."
|
||||
else
|
||||
echo "Threads: no threads (pthread lib not found.)"
|
||||
|
||||
4
projects/VC7.1/.cvsignore
Executable file
4
projects/VC7.1/.cvsignore
Executable file
@@ -0,0 +1,4 @@
|
||||
Debug
|
||||
Release
|
||||
SimGear.ncb
|
||||
SimGear.suo
|
||||
21
projects/VC7.1/SimGear.sln
Executable file
21
projects/VC7.1/SimGear.sln
Executable file
@@ -0,0 +1,21 @@
|
||||
Microsoft Visual Studio Solution File, Format Version 8.00
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimGear", "SimGear.vcproj", "{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfiguration) = preSolution
|
||||
Debug = Debug
|
||||
Release = Release
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfiguration) = postSolution
|
||||
{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug.ActiveCfg = Debug|Win32
|
||||
{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Debug.Build.0 = Debug|Win32
|
||||
{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release.ActiveCfg = Release|Win32
|
||||
{22540CD3-D3CA-4C86-A773-80AEEE3ACDED}.Release.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityGlobals) = postSolution
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityAddIns) = postSolution
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
1079
projects/VC7.1/SimGear.vcproj
Executable file
1079
projects/VC7.1/SimGear.vcproj
Executable file
File diff suppressed because it is too large
Load Diff
20
projects/VC8/SimGear.sln
Executable file
20
projects/VC8/SimGear.sln
Executable file
@@ -0,0 +1,20 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 9.00
|
||||
# Visual C++ Express 2005
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SimGear", "SimGear.vcproj", "{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Release|Win32 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{952B5B5B-7FC8-4AE9-A664-333322BEEEB0}.Release|Win32.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
1348
projects/VC8/SimGear.vcproj
Executable file
1348
projects/VC8/SimGear.vcproj
Executable file
File diff suppressed because it is too large
Load Diff
@@ -7,7 +7,7 @@ endif
|
||||
# METAR_DIRS =
|
||||
METAR_DIRS = environment
|
||||
|
||||
EXTRA_DIST = simgear_config.h.vc5 version.h.in
|
||||
EXTRA_DIST = simgear_config.h.vc5 simgear_config.h-msvc71 version.h.in
|
||||
|
||||
include_HEADERS = \
|
||||
compiler.h constants.h sg_inlines.h sg_traits.hxx version.h
|
||||
@@ -32,7 +32,6 @@ SUBDIRS = \
|
||||
serial \
|
||||
sound \
|
||||
$(SGTHREAD_DIR) \
|
||||
timing \
|
||||
xgl
|
||||
timing
|
||||
|
||||
DIST_SUBDIRS = $(SUBDIRS) compatibility threads
|
||||
DIST_SUBDIRS = $(SUBDIRS) compatibility
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
*
|
||||
* Written by Curtis L. Olson, started February 1999.
|
||||
*
|
||||
* Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
* Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt/
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
@@ -45,6 +44,9 @@ SGBucket::SGBucket(const double dlon, const double dlat) {
|
||||
set_bucket(dlon, dlat);
|
||||
}
|
||||
|
||||
SGBucket::SGBucket(const SGGeod& geod) {
|
||||
set_bucket(geod);
|
||||
}
|
||||
|
||||
// create an impossible bucket if false
|
||||
SGBucket::SGBucket(const bool is_good) {
|
||||
@@ -74,11 +76,6 @@ SGBucket::SGBucket(const long int bindex) {
|
||||
}
|
||||
|
||||
|
||||
// default destructor
|
||||
SGBucket::~SGBucket() {
|
||||
}
|
||||
|
||||
|
||||
// Set the bucket params for the specified lat and lon
|
||||
void SGBucket::set_bucket( double *lonlat ) {
|
||||
set_bucket( lonlat[0], lonlat[1] );
|
||||
@@ -136,6 +133,11 @@ void SGBucket::set_bucket( double dlon, double dlat ) {
|
||||
}
|
||||
|
||||
|
||||
void SGBucket::set_bucket(const SGGeod& geod)
|
||||
{
|
||||
set_bucket(geod.getLongitudeDeg(), geod.getLatitudeDeg());
|
||||
}
|
||||
|
||||
// Build the path name for this bucket
|
||||
string SGBucket::gen_base_path() const {
|
||||
// long int index;
|
||||
@@ -208,7 +210,7 @@ double SGBucket::get_width_m() const {
|
||||
double clat_rad = clat * SGD_DEGREES_TO_RADIANS;
|
||||
double cos_lat = cos( clat_rad );
|
||||
double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
|
||||
double local_perimeter = 2.0 * local_radius * SGD_PI;
|
||||
double local_perimeter = local_radius * SGD_2PI;
|
||||
double degree_width = local_perimeter / 360.0;
|
||||
|
||||
return sg_bucket_span( get_center_lat() ) * degree_width;
|
||||
@@ -217,7 +219,7 @@ double SGBucket::get_width_m() const {
|
||||
|
||||
// return height of the tile in meters
|
||||
double SGBucket::get_height_m() const {
|
||||
double perimeter = 2.0 * SG_EQUATORIAL_RADIUS_M * SGD_PI;
|
||||
double perimeter = SG_EQUATORIAL_RADIUS_M * SGD_2PI;
|
||||
double degree_height = perimeter / 360.0;
|
||||
|
||||
return SG_BUCKET_SPAN * degree_height;
|
||||
@@ -271,16 +273,32 @@ void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
|
||||
#endif
|
||||
|
||||
// longitude difference
|
||||
double c1_lon = b1.get_center_lon();
|
||||
double c2_lon = b2.get_center_lon();
|
||||
double diff_lon = c2_lon - c1_lon;
|
||||
double span;
|
||||
if ( sg_bucket_span(c1_lat) <= sg_bucket_span(c2_lat) ) {
|
||||
double diff_lon=0.0;
|
||||
double span=0.0;
|
||||
|
||||
SGBucket tmp_bucket;
|
||||
// To handle crossing the bucket size boundary
|
||||
// we need to account for different size buckets.
|
||||
|
||||
if ( sg_bucket_span(c1_lat) <= sg_bucket_span(c2_lat) )
|
||||
{
|
||||
span = sg_bucket_span(c1_lat);
|
||||
} else {
|
||||
span = sg_bucket_span(c2_lat);
|
||||
}
|
||||
|
||||
diff_lon = b2.get_center_lon() - b1.get_center_lon();
|
||||
|
||||
if (diff_lon <0.0)
|
||||
{
|
||||
diff_lon -= b1.get_width()*0.5 + b2.get_width()*0.5 - span;
|
||||
}
|
||||
else
|
||||
{
|
||||
diff_lon += b1.get_width()*0.5 + b2.get_width()*0.5 - span;
|
||||
}
|
||||
|
||||
|
||||
#ifdef HAVE_RINT
|
||||
*dx = (int)rint( diff_lon / span );
|
||||
#else
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
*
|
||||
* Written by Curtis L. Olson, started February 1999.
|
||||
*
|
||||
* Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
* Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Library General Public
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
@@ -32,6 +31,7 @@
|
||||
|
||||
#include <simgear/compiler.h>
|
||||
#include <simgear/constants.h>
|
||||
#include <simgear/math/SGMath.hxx>
|
||||
|
||||
#ifdef SG_HAVE_STD_INCLUDES
|
||||
# include <cmath>
|
||||
@@ -115,10 +115,10 @@ class SGBucket {
|
||||
|
||||
private:
|
||||
double cx, cy; // centerpoint (lon, lat) in degrees of bucket
|
||||
int lon; // longitude index (-180 to 179)
|
||||
int lat; // latitude index (-90 to 89)
|
||||
int x; // x subdivision (0 to 7)
|
||||
int y; // y subdivision (0 to 7)
|
||||
short lon; // longitude index (-180 to 179)
|
||||
short lat; // latitude index (-90 to 89)
|
||||
char x; // x subdivision (0 to 7)
|
||||
char y; // y subdivision (0 to 7)
|
||||
|
||||
public:
|
||||
|
||||
@@ -134,6 +134,13 @@ public:
|
||||
*/
|
||||
SGBucket(const double dlon, const double dlat);
|
||||
|
||||
/**
|
||||
* Construct a bucket given a specific location.
|
||||
* @param dlon longitude specified in degrees
|
||||
* @param dlat latitude specified in degrees
|
||||
*/
|
||||
SGBucket(const SGGeod& geod);
|
||||
|
||||
/** Construct a bucket.
|
||||
* @param is_good if false, create an invalid bucket. This is
|
||||
* useful * if you are comparing cur_bucket to last_bucket and
|
||||
@@ -147,11 +154,6 @@ public:
|
||||
*/
|
||||
SGBucket(const long int bindex);
|
||||
|
||||
/**
|
||||
* Default destructor.
|
||||
*/
|
||||
~SGBucket();
|
||||
|
||||
/**
|
||||
* Reset a bucket to represent a new lat and lon
|
||||
* @param dlon longitude specified in degrees
|
||||
@@ -166,6 +168,13 @@ public:
|
||||
*/
|
||||
void set_bucket( double *lonlat );
|
||||
|
||||
/**
|
||||
* Reset a bucket to represent a new lat and lon
|
||||
* @param dlon longitude specified in degrees
|
||||
* @param dlat latitude specified in degrees
|
||||
*/
|
||||
void set_bucket(const SGGeod& geod);
|
||||
|
||||
/**
|
||||
* Create an impossible bucket.
|
||||
* This is useful if you are comparing cur_bucket to last_bucket
|
||||
@@ -253,7 +262,24 @@ public:
|
||||
* @return the height of the tile in meters.
|
||||
*/
|
||||
double get_height_m() const;
|
||||
|
||||
|
||||
/**
|
||||
* @return the center of the bucket in geodetic coordinates.
|
||||
*/
|
||||
SGGeod get_center() const
|
||||
{ return SGGeod::fromDeg(get_center_lon(), get_center_lat()); }
|
||||
|
||||
/**
|
||||
* @return the center of the bucket in geodetic coordinates.
|
||||
*/
|
||||
SGGeod get_corner(unsigned num) const
|
||||
{
|
||||
double lonFac = ((num + 1) & 2) ? 0.5 : -0.5;
|
||||
double latFac = ((num ) & 2) ? 0.5 : -0.5;
|
||||
return SGGeod::fromDeg(get_center_lon() + lonFac*get_width(),
|
||||
get_center_lat() + latFac*get_height());
|
||||
}
|
||||
|
||||
// Informational methods.
|
||||
|
||||
/**
|
||||
|
||||
@@ -11,10 +11,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
@@ -121,7 +120,7 @@
|
||||
# define STL_STRSTREAM <strstream>
|
||||
|
||||
# endif
|
||||
# elif __GNUC__ == 3
|
||||
# elif __GNUC__ >= 3
|
||||
// g++-3.0.x
|
||||
# define SG_EXPLICIT_FUNCTION_TMPL_ARGS
|
||||
# define SG_NEED_AUTO_PTR
|
||||
@@ -231,6 +230,7 @@
|
||||
|
||||
# define isnan _isnan
|
||||
# define snprintf _snprintf
|
||||
# define copysign _copysign
|
||||
|
||||
# pragma warning(disable: 4786) // identifier was truncated to '255' characters
|
||||
# pragma warning(disable: 4244) // conversion from double to float
|
||||
@@ -324,7 +324,7 @@
|
||||
#endif // Native SGI compilers
|
||||
|
||||
|
||||
#if defined ( sun )
|
||||
#if defined (__sun)
|
||||
# include <strings.h>
|
||||
# include <memory.h>
|
||||
# if defined ( __cplusplus )
|
||||
@@ -336,7 +336,9 @@
|
||||
extern void *memmove(void *, const void *, size_t);
|
||||
# endif // __cplusplus
|
||||
|
||||
# define SG_COMPILER_STR "Sun compiler version " SG_STRINGIZE(__SUNPRO_CC)
|
||||
# if !defined( __GNUC__ )
|
||||
# define SG_COMPILER_STR "Sun compiler version " SG_STRINGIZE(__SUNPRO_CC)
|
||||
# endif
|
||||
|
||||
#endif // sun
|
||||
|
||||
@@ -364,6 +366,27 @@
|
||||
|
||||
#endif // __ICC
|
||||
|
||||
//
|
||||
// Platform dependent gl.h and glut.h definitions
|
||||
//
|
||||
|
||||
#ifdef __APPLE__
|
||||
# define SG_GL_H <OpenGL/gl.h>
|
||||
# define SG_GLX_H <AGL/agl.h>
|
||||
# define SG_GLU_H <OpenGL/glu.h>
|
||||
# define SG_GLEXT_H <OpenGL/glext.h>
|
||||
# define SG_GLUT_H <GLUT/glut.h>
|
||||
|
||||
inline int (isnan)(double r) { return !(r <= 0 || r >= 0); }
|
||||
#else
|
||||
# define SG_GL_H <GL/gl.h>
|
||||
# define SG_GLX_H <GL/glx.h>
|
||||
# define SG_GLU_H <GL/glu.h>
|
||||
# define SG_GLEXT_H <GL/glext.h>
|
||||
# define SG_GLUT_H <GL/glut.h>
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// No user modifiable definitions beyond here.
|
||||
//
|
||||
@@ -445,3 +468,4 @@ inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
|
||||
#endif // SG_INCOMPLETE_FUNCTIONAL
|
||||
|
||||
#endif // _SG_COMPILER_H
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started February 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt/
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
@@ -14,10 +14,9 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -129,6 +128,12 @@
|
||||
/** Knots to Miles per second */
|
||||
#define SG_KT_TO_MPS 0.5144444444444444444
|
||||
|
||||
/** Feet per second to Knots */
|
||||
#define SG_FPS_TO_KT 0.5924838012958962841
|
||||
|
||||
/** Knots to Feet per second */
|
||||
#define SG_KT_TO_FPS 1.6878098571011956874
|
||||
|
||||
/** Miles per second to Miles per hour */
|
||||
#define SG_MPS_TO_MPH 2.2369362920544020312
|
||||
|
||||
|
||||
@@ -25,7 +25,9 @@ typedef enum {
|
||||
SG_NETWORK = 0x00004000,
|
||||
SG_ATC = 0x00008000,
|
||||
SG_NASAL = 0x00010000,
|
||||
SG_UNDEFD = 0x00020000, // For range checking
|
||||
SG_INSTR = 0x00020000,
|
||||
SG_SYSTEMS = 0x00040000,
|
||||
SG_UNDEFD = 0x00080000, // For range checking
|
||||
|
||||
SG_ALL = 0xFFFFFFFF
|
||||
} sgDebugClass;
|
||||
|
||||
@@ -14,10 +14,9 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -26,6 +25,9 @@
|
||||
logstream *global_logstream = NULL;
|
||||
|
||||
bool logbuf::logging_enabled = true;
|
||||
#ifdef _MSC_VER
|
||||
bool logbuf::has_console = true;
|
||||
#endif
|
||||
sgDebugClass logbuf::logClass = SG_NONE;
|
||||
sgDebugPriority logbuf::logPriority = SG_INFO;
|
||||
streambuf* logbuf::sbuf = NULL;
|
||||
|
||||
@@ -16,10 +16,9 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -140,6 +139,10 @@ public:
|
||||
*/
|
||||
void set_sb( streambuf* sb );
|
||||
|
||||
#ifdef _MSC_VER
|
||||
static void has_no_console() { has_console = false; }
|
||||
#endif
|
||||
|
||||
protected:
|
||||
|
||||
/** sync/flush */
|
||||
@@ -155,6 +158,9 @@ private:
|
||||
static streambuf* sbuf;
|
||||
|
||||
static bool logging_enabled;
|
||||
#ifdef _MSC_VER
|
||||
static bool has_console;
|
||||
#endif
|
||||
static sgDebugClass logClass;
|
||||
static sgDebugPriority logPriority;
|
||||
|
||||
@@ -185,7 +191,6 @@ inline logbuf::int_type
|
||||
logbuf::overflow( int c )
|
||||
{
|
||||
#ifdef _MSC_VER
|
||||
static has_console = false;
|
||||
if ( logging_enabled ) {
|
||||
if ( !has_console ) {
|
||||
AllocConsole();
|
||||
@@ -194,7 +199,7 @@ logbuf::overflow( int c )
|
||||
freopen("conout$", "w", stderr);
|
||||
has_console = true;
|
||||
}
|
||||
sbuf->sputc(c);
|
||||
return sbuf->sputc(c);
|
||||
}
|
||||
else
|
||||
return EOF == 0 ? 1: 0;
|
||||
@@ -317,6 +322,9 @@ sglog()
|
||||
# define SG_LOG(C,P,M) sglog() << loglevel(C,P) << M << endl
|
||||
#endif
|
||||
|
||||
#define SG_STRINGIFY(x) #x
|
||||
#define SG_TOSTRING(x) SG_STRINGIFY(x)
|
||||
#define SG_ORIGIN __FILE__ ":" SG_TOSTRING(__LINE__)
|
||||
|
||||
#endif // _LOGSTREAM_H
|
||||
|
||||
|
||||
@@ -2,8 +2,8 @@ includedir = @includedir@/environment
|
||||
|
||||
lib_LIBRARIES = libsgenvironment.a
|
||||
|
||||
include_HEADERS = metar.hxx
|
||||
include_HEADERS = metar.hxx visual_enviro.hxx
|
||||
|
||||
libsgenvironment_a_SOURCES = metar.cxx
|
||||
libsgenvironment_a_SOURCES = metar.cxx visual_enviro.cxx
|
||||
|
||||
INCLUDES = -I$(top_srcdir)
|
||||
|
||||
@@ -16,7 +16,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -24,8 +24,12 @@
|
||||
* @file metar.cxx
|
||||
* Interface for encoded Meteorological Aerodrome Reports (METAR).
|
||||
*/
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <time.h>
|
||||
|
||||
#include <simgear/io/sg_socket.hxx>
|
||||
#include <simgear/debug/logstream.hxx>
|
||||
@@ -59,8 +63,10 @@
|
||||
* double d = n.getDewpoint_C();
|
||||
* @endcode
|
||||
*/
|
||||
SGMetar::SGMetar(const string& m, const string& proxy, const string& port, const string& auth) :
|
||||
SGMetar::SGMetar(const string& m, const string& proxy, const string& port,
|
||||
const string& auth, const time_t time) :
|
||||
_grpcount(0),
|
||||
_x_proxy(false),
|
||||
_year(-1),
|
||||
_month(-1),
|
||||
_day(-1),
|
||||
@@ -74,13 +80,17 @@ SGMetar::SGMetar(const string& m, const string& proxy, const string& port, const
|
||||
_wind_range_to(-1),
|
||||
_temp(NaN),
|
||||
_dewp(NaN),
|
||||
_pressure(NaN)
|
||||
_pressure(NaN),
|
||||
_rain(false),
|
||||
_hail(false),
|
||||
_snow(false),
|
||||
_cavok(false)
|
||||
{
|
||||
if (m.length() == 4 && isalnum(m[0]) && isalnum(m[1]) && isalnum(m[2]) && isalnum(m[3])) {
|
||||
for (int i = 0; i < 4; i++)
|
||||
_icao[i] = toupper(m[i]);
|
||||
_icao[4] = '\0';
|
||||
_data = loadData(_icao, proxy, port, auth);
|
||||
_data = loadData(_icao, proxy, port, auth, time);
|
||||
} else {
|
||||
_data = new char[m.length() + 2]; // make room for " \0"
|
||||
strcpy(_data, m.c_str());
|
||||
@@ -92,14 +102,15 @@ SGMetar::SGMetar(const string& m, const string& proxy, const string& port, const
|
||||
_icao[0] = '\0';
|
||||
|
||||
// NOAA preample
|
||||
scanPreambleDate();
|
||||
if (!scanPreambleDate())
|
||||
useCurrentDate();
|
||||
scanPreambleTime();
|
||||
|
||||
// METAR header
|
||||
scanType();
|
||||
if (!scanId() || !scanDate()) {
|
||||
delete[] _data;
|
||||
throw sg_io_exception("metar data bogus (" + _url + ')');
|
||||
throw sg_io_exception("metar data bogus ", sg_location(_url));
|
||||
}
|
||||
scanModifier();
|
||||
|
||||
@@ -125,8 +136,9 @@ SGMetar::SGMetar(const string& m, const string& proxy, const string& port, const
|
||||
|
||||
if (_grpcount < 4) {
|
||||
delete[] _data;
|
||||
throw sg_io_exception("metar data incomplete (" + _url + ')');
|
||||
throw sg_io_exception("metar data incomplete ", sg_location(_url));
|
||||
}
|
||||
|
||||
_url = "";
|
||||
}
|
||||
|
||||
@@ -143,6 +155,20 @@ SGMetar::~SGMetar()
|
||||
}
|
||||
|
||||
|
||||
void SGMetar::useCurrentDate()
|
||||
{
|
||||
struct tm now;
|
||||
time_t now_sec = time(0);
|
||||
#if defined( _MSC_VER ) || defined ( __MINGW32__ )
|
||||
now = *gmtime(&now_sec);
|
||||
#else
|
||||
gmtime_r(&now_sec, &now);
|
||||
#endif
|
||||
_year = now.tm_year + 1900;
|
||||
_month = now.tm_mon + 1;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* If called with "KSFO" loads data from
|
||||
* @code
|
||||
@@ -157,10 +183,15 @@ SGMetar::~SGMetar()
|
||||
* @return pointer to Metar data string, allocated by new char[].
|
||||
* @see rfc2068.txt for proxy spec ("Proxy-Authorization")
|
||||
*/
|
||||
char *SGMetar::loadData(const char *id, const string& proxy, const string& port, const string& auth)
|
||||
char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
|
||||
const string& auth, time_t time)
|
||||
{
|
||||
const int buflen = 512;
|
||||
char buf[2 * buflen];
|
||||
|
||||
string host = proxy.empty() ? "weather.noaa.gov" : proxy;
|
||||
string path = "/pub/data/observations/metar/stations/";
|
||||
|
||||
path += string(id) + ".TXT";
|
||||
_url = "http://weather.noaa.gov" + path;
|
||||
|
||||
@@ -168,30 +199,31 @@ char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
|
||||
sock->set_timeout(10000);
|
||||
if (!sock->open(SG_IO_OUT)) {
|
||||
delete sock;
|
||||
throw sg_io_exception("cannot connect to " + host);
|
||||
throw sg_io_exception("cannot connect to ", sg_location(host));
|
||||
}
|
||||
|
||||
string get = "GET ";
|
||||
if (!proxy.empty())
|
||||
get += "http://weather.noaa.gov";
|
||||
get += path + " HTTP/1.0\r\n";
|
||||
|
||||
sprintf(buf, "%ld", time);
|
||||
get += path + " HTTP/1.0\015\012X-Time: " + buf + "\015\012";
|
||||
|
||||
if (!auth.empty())
|
||||
get += "Proxy-Authorization: " + auth + "\015\012";
|
||||
|
||||
get += "\015\012";
|
||||
sock->writestring(get.c_str());
|
||||
|
||||
if (!auth.empty()) {
|
||||
get = "Proxy-Authorization: " + auth + "\r\n";
|
||||
sock->writestring(get.c_str());
|
||||
}
|
||||
|
||||
sock->writestring("\r\n");
|
||||
|
||||
int i;
|
||||
const int buflen = 512;
|
||||
char buf[2 * buflen];
|
||||
|
||||
// skip HTTP header
|
||||
while ((i = sock->readline(buf, buflen)))
|
||||
while ((i = sock->readline(buf, buflen))) {
|
||||
if (i <= 2 && isspace(buf[0]) && (!buf[1] || isspace(buf[1])))
|
||||
break;
|
||||
if (!strncmp(buf, "X-MetarProxy: ", 13))
|
||||
_x_proxy = true;
|
||||
}
|
||||
if (i) {
|
||||
i = sock->readline(buf, buflen);
|
||||
if (i)
|
||||
@@ -204,7 +236,8 @@ char *SGMetar::loadData(const char *id, const string& proxy, const string& port,
|
||||
char *b = buf;
|
||||
scanBoundary(&b);
|
||||
if (*b == '<')
|
||||
throw sg_io_exception("no metar data available from " + _url);
|
||||
throw sg_io_exception("no metar data available from ",
|
||||
sg_location(_url));
|
||||
|
||||
char *metar = new char[strlen(b) + 2]; // make room for " \0"
|
||||
strcpy(metar, b);
|
||||
@@ -392,7 +425,7 @@ bool SGMetar::scanWind()
|
||||
if (gust != NaN)
|
||||
_gust_speed = gust * factor;
|
||||
_grpcount++;
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -579,56 +612,56 @@ bool SGMetar::scanRwyVisRange()
|
||||
|
||||
|
||||
static const struct Token special[] = {
|
||||
"NSW", "no significant weather",
|
||||
"VCSH", "showers in the vicinity",
|
||||
"VCTS", "thunderstorm in the vicinity",
|
||||
0, 0
|
||||
{ "NSW", "no significant weather" },
|
||||
{ "VCSH", "showers in the vicinity" },
|
||||
{ "VCTS", "thunderstorm in the vicinity" },
|
||||
{ 0, 0 }
|
||||
};
|
||||
|
||||
|
||||
static const struct Token description[] = {
|
||||
"SH", "showers of",
|
||||
"TS", "thunderstorm with",
|
||||
"BC", "patches of",
|
||||
"BL", "blowing",
|
||||
"DR", "low drifting",
|
||||
"FZ", "freezing",
|
||||
"MI", "shallow",
|
||||
"PR", "partial",
|
||||
0, 0
|
||||
{ "SH", "showers of" },
|
||||
{ "TS", "thunderstorm with" },
|
||||
{ "BC", "patches of" },
|
||||
{ "BL", "blowing" },
|
||||
{ "DR", "low drifting" },
|
||||
{ "FZ", "freezing" },
|
||||
{ "MI", "shallow" },
|
||||
{ "PR", "partial" },
|
||||
{ 0, 0 }
|
||||
};
|
||||
|
||||
|
||||
static const struct Token phenomenon[] = {
|
||||
"DZ", "drizzle",
|
||||
"GR", "hail",
|
||||
"GS", "small hail and/or snow pellets",
|
||||
"IC", "ice crystals",
|
||||
"PE", "ice pellets",
|
||||
"RA", "rain",
|
||||
"SG", "snow grains",
|
||||
"SN", "snow",
|
||||
"UP", "unknown precipitation",
|
||||
"BR", "mist",
|
||||
"DU", "widespread dust",
|
||||
"SG", "fog",
|
||||
"SGBR", "fog bank",
|
||||
"FU", "smoke",
|
||||
"HZ", "haze",
|
||||
"PY", "spray",
|
||||
"SA", "sand",
|
||||
"VA", "volcanic ash",
|
||||
"DS", "duststorm",
|
||||
"FC", "funnel cloud/tornado waterspout",
|
||||
"PO", "well-developed dust/sand whirls",
|
||||
"SQ", "squalls",
|
||||
"SS", "sandstorm",
|
||||
"UP", "unknown", // ... due to failed automatic acquisition
|
||||
0, 0
|
||||
{ "DZ", "drizzle" },
|
||||
{ "GR", "hail" },
|
||||
{ "GS", "small hail and/or snow pellets" },
|
||||
{ "IC", "ice crystals" },
|
||||
{ "PE", "ice pellets" },
|
||||
{ "RA", "rain" },
|
||||
{ "SG", "snow grains" },
|
||||
{ "SN", "snow" },
|
||||
{ "UP", "unknown precipitation" },
|
||||
{ "BR", "mist" },
|
||||
{ "DU", "widespread dust" },
|
||||
{ "FG", "fog" },
|
||||
{ "FGBR", "fog bank" },
|
||||
{ "FU", "smoke" },
|
||||
{ "HZ", "haze" },
|
||||
{ "PY", "spray" },
|
||||
{ "SA", "sand" },
|
||||
{ "VA", "volcanic ash" },
|
||||
{ "DS", "duststorm" },
|
||||
{ "FC", "funnel cloud/tornado waterspout" },
|
||||
{ "PO", "well-developed dust/sand whirls" },
|
||||
{ "SQ", "squalls" },
|
||||
{ "SS", "sandstorm" },
|
||||
{ "UP", "unknown" }, // ... due to failed automatic acquisition
|
||||
{ 0, 0 }
|
||||
};
|
||||
|
||||
|
||||
// (+|-|VC)?(NSW|MI|PR|BC|DR|BL|SH|TS|FZ)?((DZ|RA|SN|SG|IC|PE|GR|GS|UP){0,3})(BR|SG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS|DS){0,3}
|
||||
// (+|-|VC)?(NSW|MI|PR|BC|DR|BL|SH|TS|FZ)?((DZ|RA|SN|SG|IC|PE|GR|GS|UP){0,3})(BR|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS|DS){0,3}
|
||||
bool SGMetar::scanWeather()
|
||||
{
|
||||
char *m = _m;
|
||||
@@ -643,14 +676,15 @@ bool SGMetar::scanWeather()
|
||||
}
|
||||
|
||||
string pre, post;
|
||||
int intensity = 0;
|
||||
if (*m == '-')
|
||||
m++, pre = "light ";
|
||||
m++, pre = "light ", intensity = 1;
|
||||
else if (*m == '+')
|
||||
m++, pre = "heavy ";
|
||||
m++, pre = "heavy ", intensity = 3;
|
||||
else if (!strncmp(m, "VC", 2))
|
||||
m += 2, post = "in the vicinity ";
|
||||
else
|
||||
pre = "moderate ";
|
||||
pre = "moderate ", intensity = 2;
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 3; i++) {
|
||||
@@ -662,6 +696,12 @@ bool SGMetar::scanWeather()
|
||||
if (!(a = scanToken(&m, phenomenon)))
|
||||
break;
|
||||
weather += string(a->text) + " ";
|
||||
if (!strcmp(a->id, "RA"))
|
||||
_rain = intensity;
|
||||
else if (!strcmp(a->id, "HA"))
|
||||
_hail = intensity;
|
||||
else if (!strcmp(a->id, "SN"))
|
||||
_snow = intensity;
|
||||
}
|
||||
if (!weather.length())
|
||||
return false;
|
||||
@@ -677,26 +717,26 @@ bool SGMetar::scanWeather()
|
||||
|
||||
|
||||
static const struct Token cloud_types[] = {
|
||||
"AC", "altocumulus",
|
||||
"ACC", "altocumulus castellanus",
|
||||
"ACSL", "altocumulus standing lenticular",
|
||||
"AS", "altostratus",
|
||||
"CB", "cumulonimbus",
|
||||
"CBMAM", "cumulonimbus mammatus",
|
||||
"CC", "cirrocumulus",
|
||||
"CCSL", "cirrocumulus standing lenticular",
|
||||
"CI", "cirrus",
|
||||
"CS", "cirrostratus",
|
||||
"CU", "cumulus",
|
||||
"CUFRA", "cumulus fractus",
|
||||
"NS", "nimbostratus",
|
||||
"SAC", "stratoaltocumulus", // guessed
|
||||
"SC", "stratocumulus",
|
||||
"SCSL", "stratocumulus standing lenticular",
|
||||
"ST", "stratus",
|
||||
"STFRA", "stratus fractus",
|
||||
"TCU", "towering cumulus",
|
||||
0, 0
|
||||
{ "AC", "altocumulus" },
|
||||
{ "ACC", "altocumulus castellanus" },
|
||||
{ "ACSL", "altocumulus standing lenticular" },
|
||||
{ "AS", "altostratus" },
|
||||
{ "CB", "cumulonimbus" },
|
||||
{ "CBMAM", "cumulonimbus mammatus" },
|
||||
{ "CC", "cirrocumulus" },
|
||||
{ "CCSL", "cirrocumulus standing lenticular" },
|
||||
{ "CI", "cirrus" },
|
||||
{ "CS", "cirrostratus" },
|
||||
{ "CU", "cumulus" },
|
||||
{ "CUFRA", "cumulus fractus" },
|
||||
{ "NS", "nimbostratus" },
|
||||
{ "SAC", "stratoaltocumulus" }, // guessed
|
||||
{ "SC", "stratocumulus" },
|
||||
{ "SCSL", "stratocumulus standing lenticular" },
|
||||
{ "ST", "stratus" },
|
||||
{ "STFRA", "stratus fractus" },
|
||||
{ "TCU", "towering cumulus" },
|
||||
{ 0, 0 }
|
||||
};
|
||||
|
||||
|
||||
@@ -707,6 +747,14 @@ bool SGMetar::scanSkyCondition()
|
||||
int i;
|
||||
SGMetarCloud cl;
|
||||
|
||||
if (!strncmp(m, "//////", 6)) {
|
||||
m += 6;
|
||||
if (!scanBoundary(&m))
|
||||
return false;
|
||||
_m = m;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!strncmp(m, "CLR", i = 3) // clear
|
||||
|| !strncmp(m, "SKC", i = 3) // sky clear
|
||||
|| !strncmp(m, "NSC", i = 3) // no significant clouds
|
||||
@@ -714,8 +762,13 @@ bool SGMetar::scanSkyCondition()
|
||||
m += i;
|
||||
if (!scanBoundary(&m))
|
||||
return false;
|
||||
cl._coverage = 0;
|
||||
_clouds.push_back(cl);
|
||||
|
||||
if (i == 3) {
|
||||
cl._coverage = 0;
|
||||
_clouds.push_back(cl);
|
||||
} else {
|
||||
_cavok = true;
|
||||
}
|
||||
_m = m;
|
||||
return true;
|
||||
}
|
||||
@@ -791,7 +844,7 @@ bool SGMetar::scanTemperature()
|
||||
return false;
|
||||
if (!scanBoundary(&m)) {
|
||||
if (!strncmp(m, "XX", 2)) // not spec compliant!
|
||||
m += 2, sign = 0;
|
||||
m += 2, sign = 0, dew = temp;
|
||||
else {
|
||||
sign = 1;
|
||||
if (*m == 'M')
|
||||
@@ -907,19 +960,22 @@ bool SGMetar::scanRunwayReport()
|
||||
|
||||
if (!strncmp(m, "CLRD", 4)) {
|
||||
m += 4; // runway cleared
|
||||
r._deposit = "cleared";
|
||||
r._deposit_string = "cleared";
|
||||
} else {
|
||||
if (scanNumber(&m, &i, 1)) {
|
||||
r._deposit = runway_deposit[i];
|
||||
r._deposit = i;
|
||||
r._deposit_string = runway_deposit[i];
|
||||
} else if (*m == '/')
|
||||
m++;
|
||||
else
|
||||
return false;
|
||||
|
||||
if (*m == '1' || *m == '2' || *m == '5' || *m == '9') { // extent of deposit
|
||||
r._extent = *m - '0';
|
||||
r._extent_string = runway_deposit_extent[*m - '0'];
|
||||
} else if (*m != '/')
|
||||
return false;
|
||||
|
||||
m++;
|
||||
i = -1;
|
||||
if (!strncmp(m, "//", 2))
|
||||
@@ -928,7 +984,7 @@ bool SGMetar::scanRunwayReport()
|
||||
return false;
|
||||
|
||||
if (i == 0)
|
||||
r._depth = 0.5; // < 1 mm deep (let's say 0.5 :-)
|
||||
r._depth = 0.0005; // < 1 mm deep (let's say 0.5 :-)
|
||||
else if (i > 0 && i <= 90)
|
||||
r._depth = i / 1000.0; // i mm deep
|
||||
else if (i >= 92 && i <= 98)
|
||||
@@ -954,6 +1010,7 @@ bool SGMetar::scanRunwayReport()
|
||||
return false;
|
||||
|
||||
_runways[id]._deposit = r._deposit;
|
||||
_runways[id]._deposit_string = r._deposit_string;
|
||||
_runways[id]._extent = r._extent;
|
||||
_runways[id]._extent_string = r._extent_string;
|
||||
_runways[id]._depth = r._depth;
|
||||
@@ -1033,13 +1090,13 @@ bool SGMetar::scanTrendForecast()
|
||||
|
||||
// (BLU|WHT|GRN|YLO|AMB|RED)
|
||||
static const struct Token colors[] = {
|
||||
"BLU", "Blue", // 2500 ft, 8.0 km
|
||||
"WHT", "White", // 1500 ft, 5.0 km
|
||||
"GRN", "Green", // 700 ft, 3.7 km
|
||||
"YLO", "Yellow", // 300 ft, 1.6 km
|
||||
"AMB", "Amber", // 200 ft, 0.8 km
|
||||
"RED", "Red", // <200 ft, <0.8 km
|
||||
0, 0
|
||||
{ "BLU", "Blue" }, // 2500 ft, 8.0 km
|
||||
{ "WHT", "White" }, // 1500 ft, 5.0 km
|
||||
{ "GRN", "Green" }, // 700 ft, 3.7 km
|
||||
{ "YLO", "Yellow" }, // 300 ft, 1.6 km
|
||||
{ "AMB", "Amber" }, // 200 ft, 0.8 km
|
||||
{ "RED", "Red" }, // <200 ft, <0.8 km
|
||||
{ 0, 0 }
|
||||
};
|
||||
|
||||
|
||||
@@ -1137,4 +1194,24 @@ const struct Token *SGMetar::scanToken(char **str, const struct Token *list)
|
||||
return longest;
|
||||
}
|
||||
|
||||
|
||||
void SGMetarCloud::set(double alt, int cov)
|
||||
{
|
||||
_altitude = alt;
|
||||
if (cov != -1)
|
||||
_coverage = cov;
|
||||
}
|
||||
|
||||
|
||||
void SGMetarVisibility::set(double dist, int dir, int mod, int tend)
|
||||
{
|
||||
_distance = dist;
|
||||
if (dir != -1)
|
||||
_direction = dir;
|
||||
if (mod != -1)
|
||||
_modifier = mod;
|
||||
if (tend != 1)
|
||||
_tendency = tend;
|
||||
}
|
||||
|
||||
#undef NaN
|
||||
|
||||
@@ -16,7 +16,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -67,6 +67,8 @@ public:
|
||||
DECREASING
|
||||
};
|
||||
|
||||
void set(double dist, int dir = -1, int mod = -1, int tend = -1);
|
||||
|
||||
inline double getVisibility_m() const { return _distance; }
|
||||
inline double getVisibility_ft() const { return _distance == NaN ? NaN : _distance * SG_METER_TO_FEET; }
|
||||
inline double getVisibility_sm() const { return _distance == NaN ? NaN : _distance * SG_METER_TO_SM; }
|
||||
@@ -87,7 +89,8 @@ class SGMetarRunway {
|
||||
friend class SGMetar;
|
||||
public:
|
||||
SGMetarRunway() :
|
||||
_deposit(0),
|
||||
_deposit(-1),
|
||||
_deposit_string(0),
|
||||
_extent(-1),
|
||||
_extent_string(0),
|
||||
_depth(NaN),
|
||||
@@ -96,7 +99,8 @@ public:
|
||||
_comment(0),
|
||||
_wind_shear(false) {}
|
||||
|
||||
inline const char *getDeposit() const { return _deposit; }
|
||||
inline int getDeposit() const { return _deposit; }
|
||||
inline const char *getDepositString() const { return _deposit_string; }
|
||||
inline double getExtent() const { return _extent; }
|
||||
inline const char *getExtentString() const { return _extent_string; }
|
||||
inline double getDepth() const { return _depth; }
|
||||
@@ -104,13 +108,14 @@ public:
|
||||
inline const char *getFrictionString() const { return _friction_string; }
|
||||
inline const char *getComment() const { return _comment; }
|
||||
inline const bool getWindShear() const { return _wind_shear; }
|
||||
inline SGMetarVisibility getMinVisibility() const { return _min_visibility; }
|
||||
inline SGMetarVisibility getMaxVisibility() const { return _max_visibility; }
|
||||
inline const SGMetarVisibility& getMinVisibility() const { return _min_visibility; }
|
||||
inline const SGMetarVisibility& getMaxVisibility() const { return _max_visibility; }
|
||||
|
||||
protected:
|
||||
SGMetarVisibility _min_visibility;
|
||||
SGMetarVisibility _max_visibility;
|
||||
const char *_deposit;
|
||||
int _deposit;
|
||||
const char *_deposit_string;
|
||||
int _extent;
|
||||
const char *_extent_string;
|
||||
double _depth;
|
||||
@@ -131,6 +136,8 @@ public:
|
||||
_type(0),
|
||||
_type_long(0) {}
|
||||
|
||||
void set(double alt, int cov = -1);
|
||||
|
||||
inline int getCoverage() const { return _coverage; }
|
||||
inline double getAltitude_m() const { return _altitude; }
|
||||
inline double getAltitude_ft() const { return _altitude == NaN ? NaN : _altitude * SG_METER_TO_FEET; }
|
||||
@@ -147,7 +154,8 @@ protected:
|
||||
|
||||
class SGMetar {
|
||||
public:
|
||||
SGMetar(const string& m, const string& proxy = "", const string& port = "", const string &auth = "");
|
||||
SGMetar(const string& m, const string& proxy = "", const string& port = "",
|
||||
const string &auth = "", const time_t time = 0);
|
||||
~SGMetar();
|
||||
|
||||
enum ReportType {
|
||||
@@ -159,6 +167,7 @@ public:
|
||||
|
||||
inline const char *getData() const { return _data; }
|
||||
inline const char *getUnusedData() const { return _m; }
|
||||
inline const bool getProxy() const { return _x_proxy; }
|
||||
inline const char *getId() const { return _icao; }
|
||||
inline int getYear() const { return _year; }
|
||||
inline int getMonth() const { return _month; }
|
||||
@@ -181,10 +190,10 @@ public:
|
||||
inline int getWindRangeFrom() const { return _wind_range_from; }
|
||||
inline int getWindRangeTo() const { return _wind_range_to; }
|
||||
|
||||
inline SGMetarVisibility& getMinVisibility() { return _min_visibility; }
|
||||
inline SGMetarVisibility& getMaxVisibility() { return _max_visibility; }
|
||||
inline SGMetarVisibility& getVertVisibility() { return _vert_visibility; }
|
||||
inline SGMetarVisibility *getDirVisibility() { return _dir_visibility; }
|
||||
inline const SGMetarVisibility& getMinVisibility() const { return _min_visibility; }
|
||||
inline const SGMetarVisibility& getMaxVisibility() const { return _max_visibility; }
|
||||
inline const SGMetarVisibility& getVertVisibility() const { return _vert_visibility; }
|
||||
inline const SGMetarVisibility *getDirVisibility() const { return _dir_visibility; }
|
||||
|
||||
inline double getTemperature_C() const { return _temp; }
|
||||
inline double getTemperature_F() const { return _temp == NaN ? NaN : 1.8 * _temp + 32; }
|
||||
@@ -193,15 +202,21 @@ public:
|
||||
inline double getPressure_hPa() const { return _pressure == NaN ? NaN : _pressure / 100; }
|
||||
inline double getPressure_inHg() const { return _pressure == NaN ? NaN : _pressure * SG_PA_TO_INHG; }
|
||||
|
||||
inline int getRain() const { return _rain; }
|
||||
inline int getHail() const { return _hail; }
|
||||
inline int getSnow() const { return _snow; }
|
||||
inline bool getCAVOK() const { return _cavok; }
|
||||
|
||||
double getRelHumidity() const;
|
||||
|
||||
inline vector<SGMetarCloud>& getClouds() { return _clouds; }
|
||||
inline map<string, SGMetarRunway>& getRunways() { return _runways; }
|
||||
inline vector<string>& getWeather() { return _weather; }
|
||||
inline const vector<SGMetarCloud>& getClouds() const { return _clouds; }
|
||||
inline const map<string, SGMetarRunway>& getRunways() const { return _runways; }
|
||||
inline const vector<string>& getWeather() const { return _weather; }
|
||||
|
||||
protected:
|
||||
string _url;
|
||||
int _grpcount;
|
||||
bool _x_proxy;
|
||||
char *_data;
|
||||
char *_m;
|
||||
char _icao[5];
|
||||
@@ -219,6 +234,10 @@ protected:
|
||||
double _temp;
|
||||
double _dewp;
|
||||
double _pressure;
|
||||
int _rain;
|
||||
int _hail;
|
||||
int _snow;
|
||||
bool _cavok;
|
||||
|
||||
SGMetarVisibility _min_visibility;
|
||||
SGMetarVisibility _max_visibility;
|
||||
@@ -230,6 +249,7 @@ protected:
|
||||
|
||||
bool scanPreambleDate();
|
||||
bool scanPreambleTime();
|
||||
void useCurrentDate();
|
||||
|
||||
bool scanType();
|
||||
bool scanId();
|
||||
@@ -253,7 +273,8 @@ protected:
|
||||
int scanNumber(char **str, int *num, int min, int max = 0);
|
||||
bool scanBoundary(char **str);
|
||||
const struct Token *scanToken(char **str, const struct Token *list);
|
||||
char *loadData(const char *id, const string& proxy, const string& port, const string &auth);
|
||||
char *loadData(const char *id, const string& proxy, const string& port,
|
||||
const string &auth, time_t time);
|
||||
void normalizeData();
|
||||
};
|
||||
|
||||
|
||||
828
simgear/environment/visual_enviro.cxx
Normal file
828
simgear/environment/visual_enviro.cxx
Normal file
@@ -0,0 +1,828 @@
|
||||
// Visual environment helper class
|
||||
//
|
||||
// Written by Harald JOHNSEN, started April 2005.
|
||||
//
|
||||
// Copyright (C) 2005 Harald JOHNSEN - hjohnsen@evc.net
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
//
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <simgear/constants.h>
|
||||
#include <simgear/structure/SGReferenced.hxx>
|
||||
#include <simgear/structure/SGSharedPtr.hxx>
|
||||
#include <simgear/math/sg_random.h>
|
||||
#include <simgear/math/sg_geodesy.hxx>
|
||||
#include <simgear/math/point3d.hxx>
|
||||
#include <simgear/math/polar3d.hxx>
|
||||
#include <simgear/sound/soundmgr_openal.hxx>
|
||||
#include <simgear/scene/sky/cloudfield.hxx>
|
||||
#include <simgear/scene/sky/newcloud.hxx>
|
||||
#include <simgear/props/props.hxx>
|
||||
#include "visual_enviro.hxx"
|
||||
|
||||
#include <vector>
|
||||
|
||||
SG_USING_STD(vector);
|
||||
|
||||
|
||||
typedef struct {
|
||||
Point3D pt;
|
||||
int depth;
|
||||
int prev;
|
||||
} lt_tree_seg;
|
||||
|
||||
#define MAX_RAIN_SLICE 200
|
||||
static float rainpos[MAX_RAIN_SLICE];
|
||||
#define MAX_LT_TREE_SEG 400
|
||||
|
||||
#define DFL_MIN_LIGHT 0.35
|
||||
sgVec3 SGEnviro::min_light = {DFL_MIN_LIGHT, DFL_MIN_LIGHT, DFL_MIN_LIGHT};
|
||||
#define DFL_STREAK_BRIGHT_NEARMOST_LAYER 0.9
|
||||
SGfloat SGEnviro::streak_bright_nearmost_layer = DFL_STREAK_BRIGHT_NEARMOST_LAYER;
|
||||
#define DFL_STREAK_BRIGHT_FARMOST_LAYER 0.5
|
||||
SGfloat SGEnviro::streak_bright_farmost_layer = DFL_STREAK_BRIGHT_FARMOST_LAYER;
|
||||
#define DFL_STREAK_PERIOD_MAX 2.5
|
||||
SGfloat SGEnviro::streak_period_max = DFL_STREAK_PERIOD_MAX;
|
||||
#define DFL_STREAK_PERIOD_CHANGE_PER_KT 0.005
|
||||
SGfloat SGEnviro::streak_period_change_per_kt = DFL_STREAK_PERIOD_CHANGE_PER_KT;
|
||||
#define DFL_STREAK_PERIOD_MIN 1.0
|
||||
SGfloat SGEnviro::streak_period_min = DFL_STREAK_PERIOD_MIN;
|
||||
#define DFL_STREAK_LENGTH_MIN 0.03
|
||||
SGfloat SGEnviro::streak_length_min = DFL_STREAK_LENGTH_MIN;
|
||||
#define DFL_STREAK_LENGTH_CHANGE_PER_KT 0.0005
|
||||
SGfloat SGEnviro::streak_length_change_per_kt = DFL_STREAK_LENGTH_CHANGE_PER_KT;
|
||||
#define DFL_STREAK_LENGTH_MAX 0.1
|
||||
SGfloat SGEnviro::streak_length_max = DFL_STREAK_LENGTH_MAX;
|
||||
#define DFL_STREAK_COUNT_MIN 40
|
||||
int SGEnviro::streak_count_min = DFL_STREAK_COUNT_MIN;
|
||||
#define DFL_STREAK_COUNT_MAX 190
|
||||
#if (DFL_STREAK_COUNT_MAX > MAX_RAIN_SLICE)
|
||||
#error "Bad default!"
|
||||
#endif
|
||||
int SGEnviro::streak_count_max = DFL_STREAK_COUNT_MAX;
|
||||
#define DFL_CONE_BASE_RADIUS 15.0
|
||||
SGfloat SGEnviro::cone_base_radius = DFL_CONE_BASE_RADIUS;
|
||||
#define DFL_CONE_HEIGHT 30.0
|
||||
SGfloat SGEnviro::cone_height = DFL_CONE_HEIGHT;
|
||||
|
||||
|
||||
void SGEnviro::config(const SGPropertyNode* n)
|
||||
{
|
||||
if (!n)
|
||||
return;
|
||||
|
||||
const float ml = n->getFloatValue("min-light", DFL_MIN_LIGHT);
|
||||
sgSetVec3(min_light, ml, ml, ml);
|
||||
|
||||
streak_bright_nearmost_layer = n->getFloatValue(
|
||||
"streak-brightness-nearmost-layer",
|
||||
DFL_STREAK_BRIGHT_NEARMOST_LAYER);
|
||||
streak_bright_farmost_layer = n->getFloatValue(
|
||||
"streak-brightness-farmost-layer",
|
||||
DFL_STREAK_BRIGHT_FARMOST_LAYER);
|
||||
|
||||
streak_period_max = n->getFloatValue(
|
||||
"streak-period-max",
|
||||
DFL_STREAK_PERIOD_MAX);
|
||||
streak_period_min = n->getFloatValue(
|
||||
"streak-period-min",
|
||||
DFL_STREAK_PERIOD_MIN);
|
||||
streak_period_change_per_kt = n->getFloatValue(
|
||||
"streak-period-change-per-kt",
|
||||
DFL_STREAK_PERIOD_CHANGE_PER_KT);
|
||||
|
||||
streak_length_max = n->getFloatValue(
|
||||
"streak-length-max",
|
||||
DFL_STREAK_LENGTH_MAX);
|
||||
streak_length_min = n->getFloatValue(
|
||||
"streak-length-min",
|
||||
DFL_STREAK_LENGTH_MIN);
|
||||
streak_length_change_per_kt = n->getFloatValue(
|
||||
"streak-length-change-per-kt",
|
||||
DFL_STREAK_LENGTH_CHANGE_PER_KT);
|
||||
|
||||
streak_count_min = n->getIntValue(
|
||||
"streak-count-min", DFL_STREAK_COUNT_MIN);
|
||||
streak_count_max = n->getIntValue(
|
||||
"streak-count-max", DFL_STREAK_COUNT_MAX);
|
||||
if (streak_count_max > MAX_RAIN_SLICE)
|
||||
streak_count_max = MAX_RAIN_SLICE;
|
||||
|
||||
cone_base_radius = n->getFloatValue(
|
||||
"cone-base-radius", DFL_CONE_BASE_RADIUS);
|
||||
cone_height = n->getFloatValue("cone_height", DFL_CONE_HEIGHT);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A class to render lightnings.
|
||||
*/
|
||||
class SGLightning {
|
||||
public:
|
||||
/**
|
||||
* Build a new lightning.
|
||||
* The lightning has a limited life time. It will also play a thunder sounder once.
|
||||
* @param lon lon longitude in degree
|
||||
* @param lat lat latitude in degree
|
||||
* @param alt asl of top of lightning
|
||||
*/
|
||||
SGLightning(double lon, double lat, double alt);
|
||||
~SGLightning();
|
||||
void lt_Render(void);
|
||||
void lt_build(void);
|
||||
void lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize);
|
||||
|
||||
// contains all the segments of the lightning
|
||||
lt_tree_seg lt_tree[MAX_LT_TREE_SEG];
|
||||
// segment count
|
||||
int nb_tree;
|
||||
// position of lightning
|
||||
double lon, lat, alt;
|
||||
int sequence_count;
|
||||
// time to live
|
||||
double age;
|
||||
};
|
||||
|
||||
typedef vector<SGLightning *> list_of_lightning;
|
||||
static list_of_lightning lightnings;
|
||||
|
||||
SGEnviro sgEnviro;
|
||||
|
||||
SGEnviro::SGEnviro() :
|
||||
view_in_cloud(false),
|
||||
precipitation_enable_state(true),
|
||||
precipitation_density(100.0),
|
||||
precipitation_max_alt(0.0),
|
||||
turbulence_enable_state(false),
|
||||
last_cloud_turbulence(0.0),
|
||||
cloud_turbulence(0.0),
|
||||
lightning_enable_state(false),
|
||||
elapsed_time(0.0),
|
||||
dt(0.0),
|
||||
soundMgr(NULL),
|
||||
snd_active(false),
|
||||
snd_dist(0.0),
|
||||
min_time_before_lt(0.0),
|
||||
fov_width(55.0),
|
||||
fov_height(55.0)
|
||||
|
||||
{
|
||||
for(int i = 0; i < MAX_RAIN_SLICE ; i++)
|
||||
rainpos[i] = sg_random();
|
||||
radarEcho.reserve(100);
|
||||
}
|
||||
|
||||
SGEnviro::~SGEnviro(void) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
list_of_lightning::iterator iLightning;
|
||||
for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
|
||||
delete (*iLightning);
|
||||
}
|
||||
lightnings.clear();
|
||||
}
|
||||
|
||||
void SGEnviro::startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
view_in_cloud = false;
|
||||
// ask the impostor cache to do some cleanup
|
||||
if(SGNewCloud::cldCache)
|
||||
SGNewCloud::cldCache->startNewFrame();
|
||||
last_cloud_turbulence = cloud_turbulence;
|
||||
cloud_turbulence = 0.0;
|
||||
elapsed_time += delta_time;
|
||||
min_time_before_lt -= delta_time;
|
||||
dt = delta_time;
|
||||
|
||||
sgMat4 T1, LON, LAT;
|
||||
sgVec3 axis;
|
||||
|
||||
sgMakeTransMat4( T1, p );
|
||||
|
||||
sgSetVec3( axis, 0.0, 0.0, 1.0 );
|
||||
sgMakeRotMat4( LON, lon, axis );
|
||||
|
||||
sgSetVec3( axis, 0.0, 1.0, 0.0 );
|
||||
sgMakeRotMat4( LAT, 90.0 - lat, axis );
|
||||
|
||||
sgMat4 TRANSFORM;
|
||||
|
||||
sgCopyMat4( TRANSFORM, T1 );
|
||||
sgPreMultMat4( TRANSFORM, LON );
|
||||
sgPreMultMat4( TRANSFORM, LAT );
|
||||
|
||||
sgCoord pos;
|
||||
sgSetCoord( &pos, TRANSFORM );
|
||||
|
||||
sgMakeCoordMat4( transform, &pos );
|
||||
last_lon = lon;
|
||||
last_lat = lat;
|
||||
last_alt = alt;
|
||||
|
||||
radarEcho.clear();
|
||||
precipitation_max_alt = 400.0;
|
||||
}
|
||||
|
||||
void SGEnviro::endOfFrame(void) {
|
||||
}
|
||||
|
||||
double SGEnviro::get_cloud_turbulence(void) const {
|
||||
return last_cloud_turbulence;
|
||||
}
|
||||
|
||||
// this can be queried to add some turbulence for example
|
||||
bool SGEnviro::is_view_in_cloud(void) const {
|
||||
return view_in_cloud;
|
||||
}
|
||||
void SGEnviro::set_view_in_cloud(bool incloud) {
|
||||
view_in_cloud = incloud;
|
||||
}
|
||||
|
||||
int SGEnviro::get_CacheResolution(void) const {
|
||||
return SGCloudField::get_CacheResolution();
|
||||
}
|
||||
|
||||
int SGEnviro::get_clouds_CacheSize(void) const {
|
||||
return SGCloudField::get_CacheSize();
|
||||
}
|
||||
float SGEnviro::get_clouds_visibility(void) const {
|
||||
return SGCloudField::get_CloudVis();
|
||||
}
|
||||
float SGEnviro::get_clouds_density(void) const {
|
||||
return SGCloudField::get_density();
|
||||
}
|
||||
bool SGEnviro::get_clouds_enable_state(void) const {
|
||||
return SGCloudField::get_enable3dClouds();
|
||||
}
|
||||
|
||||
bool SGEnviro::get_turbulence_enable_state(void) const {
|
||||
return turbulence_enable_state;
|
||||
}
|
||||
|
||||
void SGEnviro::set_CacheResolution(int resolutionPixels) {
|
||||
SGCloudField::set_CacheResolution(resolutionPixels);
|
||||
}
|
||||
|
||||
void SGEnviro::set_clouds_CacheSize(int sizeKb) {
|
||||
SGCloudField::set_CacheSize(sizeKb);
|
||||
}
|
||||
void SGEnviro::set_clouds_visibility(float distance) {
|
||||
SGCloudField::set_CloudVis(distance);
|
||||
}
|
||||
void SGEnviro::set_clouds_density(float density) {
|
||||
SGCloudField::set_density(density);
|
||||
}
|
||||
void SGEnviro::set_clouds_enable_state(bool enable) {
|
||||
SGCloudField::set_enable3dClouds(enable);
|
||||
}
|
||||
void SGEnviro::set_turbulence_enable_state(bool enable) {
|
||||
turbulence_enable_state = enable;
|
||||
}
|
||||
// rain/snow
|
||||
float SGEnviro::get_precipitation_density(void) const {
|
||||
return precipitation_density;
|
||||
}
|
||||
bool SGEnviro::get_precipitation_enable_state(void) const {
|
||||
return precipitation_enable_state;
|
||||
}
|
||||
|
||||
void SGEnviro::set_precipitation_density(float density) {
|
||||
precipitation_density = density;
|
||||
}
|
||||
void SGEnviro::set_precipitation_enable_state(bool enable) {
|
||||
precipitation_enable_state = enable;
|
||||
}
|
||||
|
||||
// others
|
||||
bool SGEnviro::get_lightning_enable_state(void) const {
|
||||
return lightning_enable_state;
|
||||
}
|
||||
|
||||
void SGEnviro::set_lightning_enable_state(bool enable) {
|
||||
lightning_enable_state = enable;
|
||||
if( ! enable ) {
|
||||
// TODO:cleanup
|
||||
}
|
||||
}
|
||||
|
||||
void SGEnviro::setLight(sgVec4 adj_fog_color) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
sgCopyVec4( fog_color, adj_fog_color );
|
||||
if( false ) {
|
||||
// ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
|
||||
}
|
||||
}
|
||||
|
||||
void SGEnviro::callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId) {
|
||||
// send data to wx radar
|
||||
// compute turbulence
|
||||
// draw precipitation
|
||||
// draw lightning
|
||||
// compute illumination
|
||||
|
||||
// http://www.pilotfriend.com/flight_training/weather/THUNDERSTORM%20HAZARDS1.htm
|
||||
double turbulence = 0.0;
|
||||
if( dist < radius * radius * 2.25f ) {
|
||||
switch(family) {
|
||||
case SGNewCloud::CLFamilly_st:
|
||||
turbulence = 0.2;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_ci:
|
||||
case SGNewCloud::CLFamilly_cs:
|
||||
case SGNewCloud::CLFamilly_cc:
|
||||
case SGNewCloud::CLFamilly_ac:
|
||||
case SGNewCloud::CLFamilly_as:
|
||||
turbulence = 0.1;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_sc:
|
||||
turbulence = 0.3;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_ns:
|
||||
turbulence = 0.4;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_cu:
|
||||
turbulence = 0.5;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_cb:
|
||||
turbulence = 0.6;
|
||||
break;
|
||||
}
|
||||
// full turbulence inside cloud, half in the vicinity
|
||||
if( dist > radius * radius )
|
||||
turbulence *= 0.5;
|
||||
if( turbulence > cloud_turbulence )
|
||||
cloud_turbulence = turbulence;
|
||||
// we can do 'local' precipitations too
|
||||
}
|
||||
|
||||
// convert to LWC for radar (experimental)
|
||||
// http://www-das.uwyo.edu/~geerts/cwx/notes/chap08/moist_cloud.html
|
||||
double LWC = 0.0;
|
||||
switch(family) {
|
||||
case SGNewCloud::CLFamilly_st:
|
||||
LWC = 0.29;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_cu:
|
||||
LWC = 0.27;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_cb:
|
||||
LWC = 2.0;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_sc:
|
||||
LWC = 0.44;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_ci:
|
||||
LWC = 0.03;
|
||||
break;
|
||||
// no data
|
||||
case SGNewCloud::CLFamilly_cs:
|
||||
case SGNewCloud::CLFamilly_cc:
|
||||
case SGNewCloud::CLFamilly_ac:
|
||||
case SGNewCloud::CLFamilly_as:
|
||||
LWC = 0.03;
|
||||
break;
|
||||
case SGNewCloud::CLFamilly_ns:
|
||||
LWC = 0.29*2.0;
|
||||
break;
|
||||
}
|
||||
|
||||
// add to the list for the wxRadar instrument
|
||||
if( LWC > 0.0 )
|
||||
radarEcho.push_back( SGWxRadarEcho ( heading, alt, radius, dist, LWC, false, cloudId ) );
|
||||
|
||||
// NB:data valid only from cockpit view
|
||||
|
||||
// spawn a new lightning
|
||||
if(lightning_enable_state && min_time_before_lt <= 0.0 && (family == SGNewCloud::CLFamilly_cb) &&
|
||||
dist < 15000.0 * 15000.0 && sg_random() > 0.9f) {
|
||||
double lat, lon;
|
||||
Point3D orig, dest;
|
||||
orig.setlat(last_lat * SG_DEGREES_TO_RADIANS );
|
||||
orig.setlon(last_lon * SG_DEGREES_TO_RADIANS );
|
||||
orig.setelev(0.0);
|
||||
dist = sgSqrt(dist);
|
||||
dest = calc_gc_lon_lat(orig, heading, dist);
|
||||
lon = dest.lon() * SG_RADIANS_TO_DEGREES;
|
||||
lat = dest.lat() * SG_RADIANS_TO_DEGREES;
|
||||
addLightning( lon, lat, alt );
|
||||
|
||||
// reset timer
|
||||
min_time_before_lt = 5.0 + sg_random() * 30;
|
||||
// DEBUG only
|
||||
// min_time_before_lt = 5.0;
|
||||
}
|
||||
if( (alt - radius * 0.1) > precipitation_max_alt )
|
||||
switch(family) {
|
||||
case SGNewCloud::CLFamilly_st:
|
||||
case SGNewCloud::CLFamilly_cu:
|
||||
case SGNewCloud::CLFamilly_cb:
|
||||
case SGNewCloud::CLFamilly_ns:
|
||||
case SGNewCloud::CLFamilly_sc:
|
||||
precipitation_max_alt = alt - radius * 0.1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
list_of_SGWxRadarEcho *SGEnviro::get_radar_echo(void) {
|
||||
return &radarEcho;
|
||||
}
|
||||
|
||||
// precipitation rendering code
|
||||
void SGEnviro::DrawCone2(float baseRadius, float height, int slices, bool down, double rain_norm, double speed) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
sgVec3 light;
|
||||
sgAddVec3( light, fog_color, min_light );
|
||||
float da = SG_PI * 2.0f / (float) slices;
|
||||
// low number = faster
|
||||
float speedf = streak_period_max - speed * streak_period_change_per_kt;
|
||||
if( speedf < streak_period_min )
|
||||
speedf = streak_period_min;
|
||||
float lenf = streak_length_min + speed * streak_length_change_per_kt;
|
||||
if( lenf > streak_length_max )
|
||||
lenf = streak_length_max;
|
||||
float t = fmod((float) elapsed_time, speedf) / speedf;
|
||||
// t = 0.1f;
|
||||
if( !down )
|
||||
t = 1.0f - t;
|
||||
float angle = 0.0f;
|
||||
//glColor4f(1.0f, 0.7f, 0.7f, 0.9f); // XXX unneeded? overriden below
|
||||
glBegin(GL_LINES);
|
||||
if (slices > MAX_RAIN_SLICE)
|
||||
slices = MAX_RAIN_SLICE; // should never happen
|
||||
for( int i = 0 ; i < slices ; i++ ) {
|
||||
float x = cos(angle) * baseRadius;
|
||||
float y = sin(angle) * baseRadius;
|
||||
angle += da;
|
||||
sgVec3 dir = {x, -height, y};
|
||||
|
||||
// rain drops at 2 different speed to simulate depth
|
||||
float t1 = (i & 1 ? t : t + t) + rainpos[i];
|
||||
if(t1 > 1.0f) t1 -= 1.0f;
|
||||
if(t1 > 1.0f) t1 -= 1.0f;
|
||||
|
||||
// distant raindrops are more transparent
|
||||
float c = t1 * (i & 1 ?
|
||||
streak_bright_farmost_layer
|
||||
: streak_bright_nearmost_layer);
|
||||
glColor4f(c * light[0], c * light[1], c * light[2], c);
|
||||
sgVec3 p1, p2;
|
||||
sgScaleVec3(p1, dir, t1);
|
||||
// distant raindrops are shorter
|
||||
float t2 = t1 + (i & 1 ? lenf : lenf+lenf);
|
||||
sgScaleVec3(p2, dir, t2);
|
||||
|
||||
glVertex3f(p1[0], p1[1] + height, p1[2]);
|
||||
glVertex3f(p2[0], p2[1] + height, p2[2]);
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
|
||||
void SGEnviro::drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
|
||||
#if 0
|
||||
static int debug_period = 0;
|
||||
if (debug_period++ == 50) {
|
||||
debug_period = 0;
|
||||
cout << "drawRain("
|
||||
<< pitch << ", "
|
||||
<< roll << ", "
|
||||
<< heading << ", "
|
||||
<< hspeed << ", "
|
||||
<< rain_norm << ");"
|
||||
//" angle = " << angle
|
||||
//<< " raindrop(KTS) = " << raindrop_speed_kts
|
||||
<< endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glShadeModel(GL_SMOOTH);
|
||||
glEnable(GL_BLEND);
|
||||
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
|
||||
glDisable( GL_FOG );
|
||||
glDisable(GL_LIGHTING);
|
||||
|
||||
int slice_count = static_cast<int>(
|
||||
(streak_count_min + rain_norm*(streak_count_max-streak_count_min))
|
||||
* precipitation_density / 100.0);
|
||||
|
||||
// www.wonderquest.com/falling-raindrops.htm says that
|
||||
// Raindrop terminal velocity is 5 to 20mph
|
||||
// Rather than model it accurately (temp, pressure, diameter), and make it
|
||||
// smaller than terminal when closer to the precipitation cloud base,
|
||||
// we interpolate in the 5-20mph range according to rain_norm.
|
||||
double raindrop_speed_kts
|
||||
= (5.0 + rain_norm*15.0) * SG_MPH_TO_MPS * SG_MPS_TO_KT;
|
||||
|
||||
float angle = atanf(hspeed / raindrop_speed_kts) * SG_RADIANS_TO_DEGREES;
|
||||
glPushMatrix();
|
||||
// the cone rotate with hspeed
|
||||
angle = -pitch - angle;
|
||||
glRotatef(roll, 0.0, 0.0, 1.0);
|
||||
glRotatef(heading, 0.0, 1.0, 0.0);
|
||||
glRotatef(angle, 1.0, 0.0, 0.0);
|
||||
|
||||
// up cone
|
||||
DrawCone2(cone_base_radius, cone_height,
|
||||
slice_count, true, rain_norm, hspeed);
|
||||
// down cone (usually not visible)
|
||||
if(angle > 0.0 || heading != 0.0)
|
||||
DrawCone2(cone_base_radius, -cone_height,
|
||||
slice_count, false, rain_norm, hspeed);
|
||||
|
||||
glPopMatrix();
|
||||
|
||||
glEnable(GL_LIGHTING);
|
||||
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
|
||||
glEnable( GL_FOG );
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
|
||||
}
|
||||
|
||||
void SGEnviro::set_soundMgr(SGSoundMgr *mgr) {
|
||||
soundMgr = mgr;
|
||||
}
|
||||
|
||||
void SGEnviro::drawPrecipitation(double rain_norm, double snow_norm, double hail_norm, double pitch, double roll, double heading, double hspeed) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
if( precipitation_enable_state && rain_norm > 0.0)
|
||||
if( precipitation_max_alt >= last_alt )
|
||||
drawRain(pitch, roll, heading, hspeed, rain_norm);
|
||||
}
|
||||
|
||||
|
||||
SGLightning::SGLightning(double _lon, double _lat, double _alt) :
|
||||
nb_tree(0),
|
||||
lon(_lon),
|
||||
lat(_lat),
|
||||
alt(_alt),
|
||||
age(1.0 + sg_random() * 4.0)
|
||||
{
|
||||
// sequence_count = 1 + sg_random() * 5.0;
|
||||
lt_build();
|
||||
}
|
||||
|
||||
SGLightning::~SGLightning() {
|
||||
}
|
||||
|
||||
// lightning rendering code
|
||||
void SGLightning::lt_build_tree_branch(int tree_nr, Point3D &start, float energy, int nbseg, float segsize) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
|
||||
sgVec3 dir, newdir;
|
||||
int nseg = 0;
|
||||
Point3D pt = start;
|
||||
if( nbseg == 50 )
|
||||
sgSetVec3( dir, 0.0, -1.0, 0.0 );
|
||||
else {
|
||||
sgSetVec3( dir, sg_random() - 0.5f, sg_random() - 0.5f, sg_random() - 0.5f);
|
||||
sgNormaliseVec3(dir);
|
||||
}
|
||||
if( nb_tree >= MAX_LT_TREE_SEG )
|
||||
return;
|
||||
|
||||
lt_tree[nb_tree].depth = tree_nr;
|
||||
nseg = 0;
|
||||
lt_tree[nb_tree].pt = pt;
|
||||
lt_tree[nb_tree].prev = -1;
|
||||
nb_tree ++;
|
||||
|
||||
// TODO:check agl
|
||||
while(nseg < nbseg && pt.y() > 0.0) {
|
||||
int prev = nb_tree - 1;
|
||||
nseg++;
|
||||
// add a branch
|
||||
if( energy * sg_random() > 0.8f )
|
||||
lt_build_tree_branch(tree_nr + 1, pt, energy * 0.9f, nbseg == 50 ? 10 : static_cast<int>(nbseg * 0.4f), segsize * 0.7f);
|
||||
|
||||
if( nb_tree >= MAX_LT_TREE_SEG )
|
||||
return;
|
||||
sgSetVec3(newdir, (sg_random() - 0.5f), (sg_random() - 0.5f) - (nbseg == 50 ? 0.5f : 0.0), (sg_random() - 0.5f));
|
||||
sgNormaliseVec3(newdir);
|
||||
sgAddVec3( dir, newdir);
|
||||
sgNormaliseVec3(dir);
|
||||
sgVec3 scaleDir;
|
||||
sgScaleVec3( scaleDir, dir, segsize * energy * 0.5f );
|
||||
pt[PX] += scaleDir[0];
|
||||
pt[PY] += scaleDir[1];
|
||||
pt[PZ] += scaleDir[2];
|
||||
|
||||
lt_tree[nb_tree].depth = tree_nr;
|
||||
lt_tree[nb_tree].pt = pt;
|
||||
lt_tree[nb_tree].prev = prev;
|
||||
nb_tree ++;
|
||||
}
|
||||
}
|
||||
|
||||
void SGLightning::lt_build(void) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
Point3D top;
|
||||
nb_tree = 0;
|
||||
top[PX] = 0 ;
|
||||
top[PY] = alt;
|
||||
top[PZ] = 0;
|
||||
lt_build_tree_branch(0, top, 1.0, 50, top[PY] / 8.0);
|
||||
if( ! sgEnviro.soundMgr )
|
||||
return;
|
||||
Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
|
||||
Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
|
||||
double course = 0.0, dist = 0.0;
|
||||
calc_gc_course_dist( dest, start, &course, &dist );
|
||||
if( dist < 10000.0 && ! sgEnviro.snd_playing && (dist < sgEnviro.snd_dist || ! sgEnviro.snd_active) ) {
|
||||
sgEnviro.snd_timer = 0.0;
|
||||
sgEnviro.snd_wait = dist / 340;
|
||||
sgEnviro.snd_dist = dist;
|
||||
sgEnviro.snd_pos_lat = lat;
|
||||
sgEnviro.snd_pos_lon = lon;
|
||||
sgEnviro.snd_active = true;
|
||||
sgEnviro.snd_playing = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void SGLightning::lt_Render(void) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
float flash = 0.5;
|
||||
if( fmod(sgEnviro.elapsed_time*100.0, 100.0) > 50.0 )
|
||||
flash = sg_random() * 0.75f + 0.25f;
|
||||
float h = lt_tree[0].pt[PY];
|
||||
sgVec4 col={0.62f, 0.83f, 1.0f, 1.0f};
|
||||
sgVec4 c;
|
||||
|
||||
#define DRAW_SEG() \
|
||||
{glColorMaterial(GL_FRONT, GL_EMISSION); \
|
||||
glDisable(GL_LINE_SMOOTH); glBegin(GL_LINES); \
|
||||
glColor4fv(c); \
|
||||
glVertex3f(lt_tree[n].pt[PX], lt_tree[n].pt[PZ], lt_tree[n].pt[PY]); \
|
||||
glVertex3f(lt_tree[lt_tree[n].prev].pt[PX], lt_tree[lt_tree[n].prev].pt[PZ], lt_tree[lt_tree[n].prev].pt[PY]); \
|
||||
glEnd(); glEnable(GL_LINE_SMOOTH);}
|
||||
|
||||
glDepthMask( GL_FALSE );
|
||||
glEnable(GL_BLEND);
|
||||
glBlendFunc( GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
|
||||
glDisable(GL_LIGHTING);
|
||||
glDisable( GL_FOG );
|
||||
glPushMatrix();
|
||||
sgMat4 modelview, tmp;
|
||||
// OSGFIXME
|
||||
// ssgGetModelviewMatrix( modelview );
|
||||
sgCopyMat4( tmp, sgEnviro.transform );
|
||||
sgPostMultMat4( tmp, modelview );
|
||||
// OSGFIXME
|
||||
// ssgLoadModelviewMatrix( tmp );
|
||||
|
||||
Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
|
||||
Point3D dest( lon*SG_DEGREES_TO_RADIANS, lat*SG_DEGREES_TO_RADIANS, 0.0 );
|
||||
double course = 0.0, dist = 0.0;
|
||||
calc_gc_course_dist( dest, start, &course, &dist );
|
||||
double ax = 0.0, ay = 0.0;
|
||||
ax = cos(course) * dist;
|
||||
ay = sin(course) * dist;
|
||||
|
||||
glTranslatef( ax, ay, -sgEnviro.last_alt );
|
||||
|
||||
sgEnviro.radarEcho.push_back( SGWxRadarEcho ( course, 0.0, 0.0, dist, age, true, 0 ) );
|
||||
|
||||
for( int n = 0 ; n < nb_tree ; n++ ) {
|
||||
if( lt_tree[n].prev < 0 )
|
||||
continue;
|
||||
|
||||
float t1 = sgLerp(0.5, 1.0, lt_tree[n].pt[PY] / h);
|
||||
t1 *= flash;
|
||||
if( lt_tree[n].depth >= 2 ) {
|
||||
glLineWidth(3);
|
||||
sgScaleVec4(c, col, t1 * 0.6f);
|
||||
DRAW_SEG();
|
||||
} else {
|
||||
if( lt_tree[n].depth == 0 ) {
|
||||
glLineWidth(12);
|
||||
sgScaleVec4(c, col, t1 * 0.5f);
|
||||
DRAW_SEG();
|
||||
|
||||
glLineWidth(6);
|
||||
sgScaleVec4(c, col, t1);
|
||||
DRAW_SEG();
|
||||
} else {
|
||||
glLineWidth(6);
|
||||
sgScaleVec4(c, col, t1 * 0.7f);
|
||||
DRAW_SEG();
|
||||
}
|
||||
|
||||
if( lt_tree[n].depth == 0 )
|
||||
glLineWidth(3);
|
||||
else
|
||||
glLineWidth(2);
|
||||
|
||||
sgSetVec4(c, t1, t1, t1, t1);
|
||||
DRAW_SEG();
|
||||
}
|
||||
|
||||
}
|
||||
glLineWidth(1);
|
||||
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
|
||||
glPopMatrix();
|
||||
glDepthMask( GL_TRUE );
|
||||
glEnable( GL_FOG );
|
||||
glEnable(GL_LIGHTING);
|
||||
}
|
||||
|
||||
void SGEnviro::addLightning(double lon, double lat, double alt) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
if( lightnings.size() > 10)
|
||||
return;
|
||||
SGLightning *lt= new SGLightning(lon, lat, alt);
|
||||
lightnings.push_back(lt);
|
||||
}
|
||||
|
||||
void SGEnviro::drawLightning(void) {
|
||||
// OSGFIXME
|
||||
return;
|
||||
list_of_lightning::iterator iLightning;
|
||||
// play 'thunder' for lightning
|
||||
if( snd_active )
|
||||
if( !snd_playing ) {
|
||||
// wait until sound has reached us
|
||||
snd_timer += dt;
|
||||
if( snd_timer >= snd_wait ) {
|
||||
snd_playing = true;
|
||||
// compute relative position of lightning
|
||||
Point3D start( sgEnviro.last_lon*SG_DEGREES_TO_RADIANS, sgEnviro.last_lat*SG_DEGREES_TO_RADIANS, 0.0 );
|
||||
Point3D dest( snd_pos_lon*SG_DEGREES_TO_RADIANS, snd_pos_lat*SG_DEGREES_TO_RADIANS, 0.0 );
|
||||
double course = 0.0, dist = 0.0;
|
||||
calc_gc_course_dist( dest, start, &course, &dist );
|
||||
double ax = 0.0, ay = 0.0;
|
||||
ax = cos(course) * dist;
|
||||
ay = sin(course) * dist;
|
||||
SGSharedPtr<SGSoundSample> snd = soundMgr->find("thunder");
|
||||
if( snd ) {
|
||||
ALfloat pos[3]={ax, ay, -sgEnviro.last_alt };
|
||||
snd->set_source_pos(pos);
|
||||
snd->play_once();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if( !soundMgr->is_playing("thunder") ) {
|
||||
snd_active = false;
|
||||
snd_playing = false;
|
||||
}
|
||||
}
|
||||
|
||||
if( ! lightning_enable_state )
|
||||
return;
|
||||
|
||||
for( iLightning = lightnings.begin() ; iLightning != lightnings.end() ; iLightning++ ) {
|
||||
if( dt )
|
||||
if( sg_random() > 0.95f )
|
||||
(*iLightning)->lt_build();
|
||||
(*iLightning)->lt_Render();
|
||||
(*iLightning)->age -= dt;
|
||||
if( (*iLightning)->age < 0.0 ) {
|
||||
delete (*iLightning);
|
||||
lightnings.erase( iLightning );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
void SGEnviro::setFOV( float w, float h ) {
|
||||
fov_width = w;
|
||||
fov_height = h;
|
||||
}
|
||||
|
||||
void SGEnviro::getFOV( float &w, float &h ) {
|
||||
w = fov_width;
|
||||
h = fov_height;
|
||||
}
|
||||
257
simgear/environment/visual_enviro.hxx
Normal file
257
simgear/environment/visual_enviro.hxx
Normal file
@@ -0,0 +1,257 @@
|
||||
// Visual environment helper class
|
||||
//
|
||||
// Written by Harald JOHNSEN, started April 2005.
|
||||
//
|
||||
// Copyright (C) 2005 Harald JOHNSEN - hjohnsen@evc.net
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
//
|
||||
#ifndef _VISUAL_ENVIRO_HXX
|
||||
#define _VISUAL_ENVIRO_HXX
|
||||
|
||||
#include <plib/sg.h>
|
||||
|
||||
#include <simgear/compiler.h>
|
||||
#include STL_STRING
|
||||
#include <vector>
|
||||
|
||||
SG_USING_STD(vector);
|
||||
SG_USING_STD(string);
|
||||
|
||||
class SGLightning;
|
||||
class SGSoundMgr;
|
||||
|
||||
/**
|
||||
* Simulate some echo on a weather radar.
|
||||
* Container class for the wx radar instrument.
|
||||
*/
|
||||
class SGWxRadarEcho {
|
||||
public:
|
||||
SGWxRadarEcho(float _heading, float _alt, float _radius, float _dist,
|
||||
double _LWC, bool _lightning, int _cloudId ) :
|
||||
heading( _heading ),
|
||||
alt ( _alt ),
|
||||
radius ( _radius ),
|
||||
dist ( _dist ),
|
||||
LWC ( _LWC ),
|
||||
lightning ( _lightning ),
|
||||
cloudId ( _cloudId )
|
||||
{}
|
||||
|
||||
/** the heading in radian is versus north */
|
||||
float heading;
|
||||
float alt, radius, dist;
|
||||
/** reflectivity converted to liquid water content. */
|
||||
double LWC;
|
||||
/** if true then this data is for a lightning else it is for water echo. */
|
||||
bool lightning;
|
||||
/** Unique identifier of cloud */
|
||||
int cloudId;
|
||||
};
|
||||
|
||||
typedef vector<SGWxRadarEcho> list_of_SGWxRadarEcho;
|
||||
|
||||
/**
|
||||
* Visual environment helper class.
|
||||
*/
|
||||
class SGEnviro {
|
||||
friend class SGLightning;
|
||||
private:
|
||||
void DrawCone2(float baseRadius, float height, int slices, bool down, double rain_norm, double speed);
|
||||
void lt_update(void);
|
||||
|
||||
bool view_in_cloud;
|
||||
bool precipitation_enable_state;
|
||||
float precipitation_density;
|
||||
float precipitation_max_alt;
|
||||
bool turbulence_enable_state;
|
||||
double last_cloud_turbulence, cloud_turbulence;
|
||||
bool lightning_enable_state;
|
||||
double elapsed_time, dt;
|
||||
sgVec4 fog_color;
|
||||
sgMat4 transform;
|
||||
double last_lon, last_lat, last_alt;
|
||||
SGSoundMgr *soundMgr;
|
||||
bool snd_active, snd_playing;
|
||||
double snd_timer, snd_wait, snd_pos_lat, snd_pos_lon, snd_dist;
|
||||
double min_time_before_lt;
|
||||
|
||||
float fov_width, fov_height;
|
||||
|
||||
/** a list of all the radar echo. */
|
||||
list_of_SGWxRadarEcho radarEcho;
|
||||
static sgVec3 min_light;
|
||||
static SGfloat streak_bright_nearmost_layer,
|
||||
streak_bright_farmost_layer,
|
||||
streak_period_max,
|
||||
streak_period_change_per_kt,
|
||||
streak_period_min,
|
||||
streak_length_min,
|
||||
streak_length_change_per_kt,
|
||||
streak_length_max;
|
||||
static int streak_count_min, streak_count_max;
|
||||
static SGfloat cone_base_radius,
|
||||
cone_height;
|
||||
|
||||
public:
|
||||
SGEnviro();
|
||||
~SGEnviro();
|
||||
|
||||
/** Read the config from the precipitation rendering config properties.
|
||||
* @param precip_rendering_cfgNode "/sim/rendering/precipitation" in fg
|
||||
* Set from whatever info present in the
|
||||
* subnodes passed, substituting hardwired defaults for missing fields.
|
||||
* If NULL is given, do nothing.
|
||||
*/
|
||||
void config(const class SGPropertyNode* precip_rendering_cfgNode);
|
||||
|
||||
/**
|
||||
* Forward a few states used for renderings.
|
||||
*/
|
||||
void startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time);
|
||||
|
||||
void endOfFrame(void);
|
||||
|
||||
/**
|
||||
* Whenever a cloud is drawn we check his 'impact' on the environment.
|
||||
* @param heading direction of cloud in radians
|
||||
* @param alt asl of cloud in meters
|
||||
* @param radius radius of cloud in meters
|
||||
* @param family cloud family
|
||||
* @param dist squared dist to cloud in meters
|
||||
*/
|
||||
void callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId);
|
||||
|
||||
void drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm);
|
||||
/**
|
||||
* Draw rain or snow precipitation around the viewer.
|
||||
* @param rain_norm rain normalized intensity given by metar class
|
||||
* @param snow_norm snow normalized intensity given by metar class
|
||||
* @param hail_norm hail normalized intensity given by metar class
|
||||
* @param pitch pitch rotation of viewer
|
||||
* @param roll roll rotation of viewer
|
||||
* @param hspeed moving horizontal speed of viewer in kt
|
||||
*/
|
||||
void drawPrecipitation(double rain_norm, double snow_norm, double hail_norm,
|
||||
double pitch, double roll, double heading, double hspeed);
|
||||
|
||||
/**
|
||||
* Draw the lightnings spawned by cumulo nimbus.
|
||||
*/
|
||||
void drawLightning(void);
|
||||
|
||||
/**
|
||||
* Forward the fog color used by the rain rendering.
|
||||
* @param adj_fog_color color of the fog
|
||||
*/
|
||||
void setLight(sgVec4 adj_fog_color);
|
||||
|
||||
// this can be queried to add some turbulence for example
|
||||
bool is_view_in_cloud(void) const;
|
||||
void set_view_in_cloud(bool incloud);
|
||||
double get_cloud_turbulence(void) const;
|
||||
|
||||
// Clouds
|
||||
// return the size of the memory pool used by texture impostors
|
||||
int get_clouds_CacheSize(void) const;
|
||||
int get_CacheResolution(void) const;
|
||||
float get_clouds_visibility(void) const;
|
||||
float get_clouds_density(void) const;
|
||||
bool get_clouds_enable_state(void) const;
|
||||
bool get_turbulence_enable_state(void) const;
|
||||
|
||||
/**
|
||||
* Set the size of the impostor texture cache for 3D clouds.
|
||||
* @param sizeKb size of the texture pool in Kb
|
||||
*/
|
||||
void set_clouds_CacheSize(int sizeKb);
|
||||
/**
|
||||
* Set the resolution of the impostor texture for 3D clouds.
|
||||
* @param resolutionPixels size of each texture in pixels (64|128|256)
|
||||
*/
|
||||
void set_CacheResolution(int resolutionPixels);
|
||||
/**
|
||||
* Set the maximum range used when drawing clouds.
|
||||
* Clouds are blended from totaly transparent at max range to totaly opaque around the viewer
|
||||
* @param distance in meters
|
||||
*/
|
||||
void set_clouds_visibility(float distance);
|
||||
/**
|
||||
* Set the proportion of clouds that will be rendered to limit drop in FPS.
|
||||
* @param density 0..100 no clouds drawn when density == 0, all are drawn when density == 100
|
||||
*/
|
||||
void set_clouds_density(float density);
|
||||
/**
|
||||
* Enable or disable the use of 3D clouds.
|
||||
* @param enable when false we draw the 2D layers
|
||||
*/
|
||||
void set_clouds_enable_state(bool enable);
|
||||
/**
|
||||
* Enable or disable the use of proximity cloud turbulence.
|
||||
* @param enable when true the turbulence is computed based on type of cloud around the AC
|
||||
*/
|
||||
void set_turbulence_enable_state(bool enable);
|
||||
|
||||
// rain/snow
|
||||
float get_precipitation_density(void) const;
|
||||
bool get_precipitation_enable_state(void) const;
|
||||
|
||||
/**
|
||||
* Decrease the precipitation density to the given percentage.
|
||||
* (Only show the given percentage of rain streaks etc.)
|
||||
* Default precipitation density upon construction is 100.0.
|
||||
* @param density 0.0 to 100.0
|
||||
*/
|
||||
void set_precipitation_density(float density);
|
||||
/**
|
||||
* Enable or disable the rendering of precipitation around the viewer.
|
||||
* @param enable when true we will draw precipitation depending on metar data
|
||||
*/
|
||||
void set_precipitation_enable_state(bool enable);
|
||||
|
||||
// others
|
||||
bool get_lightning_enable_state(void) const;
|
||||
/**
|
||||
* Enable or disable the rendering of lightning and the thunder sound.
|
||||
* @param enable when true we will draw lightning spwaned by cumulonimbus
|
||||
*/
|
||||
void set_lightning_enable_state(bool enable);
|
||||
|
||||
/**
|
||||
* Spawn a new lighning at specified lon/lat.
|
||||
* @param lon position of the new lightning
|
||||
* @param lat position of the new lightning
|
||||
* @param alt asl of the starting point of the lightning in meters
|
||||
*/
|
||||
void addLightning(double lon, double lat, double alt);
|
||||
|
||||
/**
|
||||
* Forward the sound manager instance to be able to play samples.
|
||||
* @param mgr a running sound manager
|
||||
*/
|
||||
void set_soundMgr(SGSoundMgr *mgr);
|
||||
|
||||
void setFOV( float w, float h );
|
||||
void getFOV( float &w, float &h );
|
||||
|
||||
list_of_SGWxRadarEcho *get_radar_echo(void);
|
||||
|
||||
sgMat4 *get_transform(void) { return &transform; }
|
||||
};
|
||||
|
||||
extern SGEnviro sgEnviro;
|
||||
|
||||
#endif // _VISUAL_ENVIRO_HXX
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
@@ -27,9 +26,9 @@
|
||||
#ifndef _CELESTIALBODY_H_
|
||||
#define _CELESTIALBODY_H_
|
||||
|
||||
#ifndef __cplusplus
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#include <simgear/constants.h>
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started March 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
@@ -15,13 +15,15 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
@@ -29,7 +31,7 @@
|
||||
|
||||
|
||||
// Constructor
|
||||
SGEphemeris::SGEphemeris( const string &path ) {
|
||||
SGEphemeris::SGEphemeris( const std::string &path ) {
|
||||
our_sun = new Star;
|
||||
moon = new MoonPos;
|
||||
mercury = new Mercury;
|
||||
@@ -40,9 +42,8 @@ SGEphemeris::SGEphemeris( const string &path ) {
|
||||
uranus = new Uranus;
|
||||
neptune = new Neptune;
|
||||
nplanets = 7;
|
||||
for ( int i = 0; i < nplanets; ++i ) {
|
||||
sgdSetVec3( planets[i], 0.0, 0.0, 0.0 );
|
||||
}
|
||||
for ( int i = 0; i < nplanets; ++i )
|
||||
planets[i] = SGVec3d::zeros();
|
||||
stars = new SGStarData( SGPath(path) );
|
||||
}
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
// All the core code underneath this is written by Durk Talsma. See
|
||||
// the headers of all the other individual files for details.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
@@ -19,10 +19,9 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -30,8 +29,7 @@
|
||||
#ifndef _EPHEMERIS_HXX
|
||||
#define _EPHEMERIS_HXX
|
||||
|
||||
|
||||
#include <plib/sg.h>
|
||||
#include <string>
|
||||
|
||||
#include <simgear/ephemeris/star.hxx>
|
||||
#include <simgear/ephemeris/moonpos.hxx>
|
||||
@@ -44,11 +42,14 @@
|
||||
#include <simgear/ephemeris/neptune.hxx>
|
||||
#include <simgear/ephemeris/stardata.hxx>
|
||||
|
||||
#include <simgear/math/SGMath.hxx>
|
||||
#include <simgear/misc/sg_path.hxx>
|
||||
|
||||
|
||||
/** Ephemeris class
|
||||
*
|
||||
* Written by Durk Talsma <d.talsma@direct.a2000.nl> and Curtis Olson
|
||||
* <curt@flightgear.org>
|
||||
* <http://www.flightgear.org/~curt>
|
||||
*
|
||||
* Introduction
|
||||
*
|
||||
@@ -84,7 +85,7 @@ class SGEphemeris {
|
||||
// planets[i][1] = Declination
|
||||
// planets[i][2] = Magnitude
|
||||
int nplanets;
|
||||
sgdVec3 planets[7];
|
||||
SGVec3d planets[7];
|
||||
|
||||
SGStarData *stars;
|
||||
|
||||
@@ -96,7 +97,7 @@ public:
|
||||
* calling the constructor you need to provide a path pointing to
|
||||
* your star database file.
|
||||
* @param path path to your star database */
|
||||
SGEphemeris( const string &path );
|
||||
SGEphemeris( const std::string &path );
|
||||
|
||||
/** Destructor */
|
||||
~SGEphemeris( void );
|
||||
@@ -156,7 +157,7 @@ public:
|
||||
* the second is the declination, and the third is the magnitude.
|
||||
* @return planets array
|
||||
*/
|
||||
inline sgdVec3 *getPlanets() { return planets; }
|
||||
inline SGVec3d *getPlanets() { return planets; }
|
||||
|
||||
/** @return the numbers of defined stars. */
|
||||
inline int getNumStars() const { return stars->getNumStars(); }
|
||||
@@ -168,7 +169,7 @@ public:
|
||||
* third is the magnitude.
|
||||
* @returns star array
|
||||
*/
|
||||
inline sgdVec3 *getStars() { return stars->getStars(); }
|
||||
inline SGVec3d *getStars() { return stars->getStars(); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
@@ -172,7 +171,7 @@ void MoonPos::updatePosition(double mjd, double lst, double lat, Star *ourSun)
|
||||
// SG_LOG( SG_GENERAL, SG_INFO, "rho = " << rho );
|
||||
|
||||
if (geoRa < 0)
|
||||
geoRa += (2*SGD_PI);
|
||||
geoRa += SGD_2PI;
|
||||
|
||||
HA = lst - (3.8197186 * geoRa);
|
||||
/* SG_LOG( SG_GENERAL, SG_INFO, "t->getLst() = " << t->getLst()
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
@@ -80,7 +79,7 @@ void Star::updatePosition(double mjd)
|
||||
double
|
||||
actTime, eccAnom,
|
||||
xv, yv, v, r,
|
||||
xe, ye, ze, ecl;
|
||||
xe, ecl;
|
||||
|
||||
updateOrbElements(mjd);
|
||||
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
@@ -35,6 +34,7 @@ class Star : public CelestialBody
|
||||
private:
|
||||
|
||||
double xs, ys; // the sun's rectangular geocentric coordinates
|
||||
double ye, ze; // the sun's rectangularequatorial rectangular geocentric coordinates
|
||||
double distance; // the sun's distance to the earth
|
||||
|
||||
public:
|
||||
@@ -47,6 +47,8 @@ public:
|
||||
double getw();
|
||||
double getxs();
|
||||
double getys();
|
||||
double getye();
|
||||
double getze();
|
||||
double getDistance();
|
||||
};
|
||||
|
||||
@@ -71,6 +73,16 @@ inline double Star::getys()
|
||||
return ys;
|
||||
}
|
||||
|
||||
inline double Star::getye()
|
||||
{
|
||||
return ye;
|
||||
}
|
||||
|
||||
inline double Star::getze()
|
||||
{
|
||||
return ze;
|
||||
}
|
||||
|
||||
inline double Star::getDistance()
|
||||
{
|
||||
return distance;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started March 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
@@ -14,15 +14,18 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <simgear/debug/logstream.hxx>
|
||||
#include <simgear/misc/sg_path.hxx>
|
||||
#include <simgear/misc/sgstream.hxx>
|
||||
|
||||
#include "stardata.hxx"
|
||||
@@ -32,16 +35,9 @@
|
||||
#endif
|
||||
|
||||
// Constructor
|
||||
SGStarData::SGStarData() :
|
||||
nstars(0)
|
||||
SGStarData::SGStarData( const SGPath& path )
|
||||
{
|
||||
}
|
||||
|
||||
SGStarData::SGStarData( SGPath path ) :
|
||||
nstars(0)
|
||||
{
|
||||
data_path = SGPath( path );
|
||||
load();
|
||||
load(path);
|
||||
}
|
||||
|
||||
|
||||
@@ -50,31 +46,28 @@ SGStarData::~SGStarData() {
|
||||
}
|
||||
|
||||
|
||||
bool SGStarData::load() {
|
||||
bool SGStarData::load( const SGPath& path ) {
|
||||
|
||||
// -dw- avoid local data > 32k error by dynamic allocation of the
|
||||
// array, problem for some compilers
|
||||
stars = new sgdVec3[SG_MAX_STARS];
|
||||
_stars.clear();
|
||||
|
||||
// build the full path name to the stars data base file
|
||||
data_path.append( "stars" );
|
||||
SG_LOG( SG_ASTRO, SG_INFO, " Loading stars from " << data_path.str() );
|
||||
// build the full path name to the stars data base file
|
||||
SGPath tmp = path;
|
||||
tmp.append( "stars" );
|
||||
SG_LOG( SG_ASTRO, SG_INFO, " Loading stars from " << tmp.str() );
|
||||
|
||||
sg_gzifstream in( data_path.str() );
|
||||
sg_gzifstream in( tmp.str() );
|
||||
if ( ! in.is_open() ) {
|
||||
SG_LOG( SG_ASTRO, SG_ALERT, "Cannot open star file: "
|
||||
<< data_path.str() );
|
||||
exit(-1);
|
||||
<< tmp.str() );
|
||||
return false;
|
||||
}
|
||||
|
||||
double ra, dec, mag;
|
||||
char c;
|
||||
string name;
|
||||
|
||||
nstars = 0;
|
||||
|
||||
// read in each line of the file
|
||||
while ( ! in.eof() && nstars < SG_MAX_STARS ) {
|
||||
while ( ! in.eof() ) {
|
||||
in >> skipcomment;
|
||||
|
||||
getline( in, name, ',' );
|
||||
@@ -114,13 +107,10 @@ bool SGStarData::load() {
|
||||
in >> mag;
|
||||
|
||||
// cout << " star data = " << ra << " " << dec << " " << mag << endl;
|
||||
|
||||
sgdSetVec3( stars[nstars], ra, dec, mag );
|
||||
|
||||
++nstars;
|
||||
_stars.push_back(SGVec3d(ra, dec, mag));
|
||||
}
|
||||
|
||||
SG_LOG( SG_ASTRO, SG_INFO, " Loaded " << nstars << " stars" );
|
||||
SG_LOG( SG_ASTRO, SG_INFO, " Loaded " << _stars.size() << " stars" );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started March 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
@@ -14,10 +14,9 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -25,37 +24,28 @@
|
||||
#ifndef _SG_STARDATA_HXX
|
||||
#define _SG_STARDATA_HXX
|
||||
|
||||
#include <vector>
|
||||
#include <simgear/math/SGMath.hxx>
|
||||
|
||||
#include <plib/sg.h>
|
||||
|
||||
#include <simgear/misc/sg_path.hxx>
|
||||
|
||||
|
||||
#define SG_MAX_STARS 850
|
||||
|
||||
class SGPath;
|
||||
|
||||
class SGStarData {
|
||||
|
||||
int nstars;
|
||||
sgdVec3 *stars;
|
||||
|
||||
SGPath data_path;
|
||||
|
||||
public:
|
||||
|
||||
// Constructor
|
||||
SGStarData();
|
||||
SGStarData( SGPath path );
|
||||
SGStarData( const SGPath& path );
|
||||
|
||||
// Destructor
|
||||
~SGStarData();
|
||||
|
||||
// load the stars database
|
||||
bool load();
|
||||
bool load( const SGPath& path );
|
||||
|
||||
// stars
|
||||
inline int getNumStars() const { return nstars; }
|
||||
inline sgdVec3 *getStars() { return stars; }
|
||||
inline int getNumStars() const { return _stars.size(); }
|
||||
inline SGVec3d *getStars() { return &(_stars[0]); }
|
||||
|
||||
private:
|
||||
std::vector<SGVec3d> _stars;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -15,10 +15,9 @@
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* $Id$
|
||||
**************************************************************************/
|
||||
|
||||
@@ -1,3 +1,7 @@
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <simgear/compiler.h>
|
||||
|
||||
#include <unistd.h>
|
||||
@@ -33,14 +37,14 @@ int main( int argc, char **argv ) {
|
||||
obj.get_gbs_radius());
|
||||
cout << endl;
|
||||
|
||||
point_list nodes = obj.get_wgs84_nodes();
|
||||
std::vector<SGVec3d> nodes = obj.get_wgs84_nodes();
|
||||
cout << "# vertex list" << endl;
|
||||
for ( i = 0; i < (int)nodes.size(); ++i ) {
|
||||
printf("v %.5f %.5f %.5f\n", nodes[i].x(), nodes[i].y(), nodes[i].z() );
|
||||
}
|
||||
cout << endl;
|
||||
|
||||
point_list normals = obj.get_normals();
|
||||
std::vector<SGVec3f> normals = obj.get_normals();
|
||||
cout << "# vertex normal list" << endl;
|
||||
for ( i = 0; i < (int)normals.size(); ++i ) {
|
||||
printf("vn %.5f %.5f %.5f\n",
|
||||
@@ -48,7 +52,7 @@ int main( int argc, char **argv ) {
|
||||
}
|
||||
cout << endl;
|
||||
|
||||
point_list texcoords = obj.get_texcoords();
|
||||
std::vector<SGVec2f> texcoords = obj.get_texcoords();
|
||||
cout << "# texture coordinate list" << endl;
|
||||
for ( i = 0; i < (int)texcoords.size(); ++i ) {
|
||||
printf("vt %.5f %.5f\n",
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -16,7 +16,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -70,3 +70,9 @@ int SGIOChannel::writestring( const char *str ) {
|
||||
bool SGIOChannel::close() {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// dummy eof routine
|
||||
bool SGIOChannel::eof() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -19,7 +19,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -152,6 +152,14 @@ public:
|
||||
*/
|
||||
virtual bool close();
|
||||
|
||||
/**
|
||||
* The eof() method returns true if end of file has been reached
|
||||
* in a context where that makes sense. Otherwise it returns
|
||||
* false.
|
||||
* @return result of eof check
|
||||
*/
|
||||
virtual bool eof();
|
||||
|
||||
inline void set_type( SGChannelType t ) { type = t; }
|
||||
inline SGChannelType get_type() const { return type; }
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
// Shamelessly adapted from plib (plib.sourceforge.net) January 2001
|
||||
//
|
||||
// Original version Copyright (C) 2000 the plib team
|
||||
// Local changes Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Local changes Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
@@ -18,7 +18,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -59,7 +59,7 @@ void sgReadFloat ( gzFile fd, float *var )
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)var);
|
||||
sgEndianSwap( (uint32_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ void sgReadFloat ( gzFile fd, float *var )
|
||||
void sgWriteFloat ( gzFile fd, const float var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)&var);
|
||||
sgEndianSwap( (uint32_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(float) ) != sizeof(float) ) {
|
||||
write_error = true ;
|
||||
@@ -81,7 +81,7 @@ void sgReadDouble ( gzFile fd, double *var )
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (uint64*)var);
|
||||
sgEndianSwap( (uint64_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -89,7 +89,7 @@ void sgReadDouble ( gzFile fd, double *var )
|
||||
void sgWriteDouble ( gzFile fd, const double var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (uint64*)&var);
|
||||
sgEndianSwap( (uint64_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(double) ) != sizeof(double) ) {
|
||||
write_error = true ;
|
||||
@@ -103,7 +103,7 @@ void sgReadUInt ( gzFile fd, unsigned int *var )
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)var);
|
||||
sgEndianSwap( (uint32_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -111,7 +111,7 @@ void sgReadUInt ( gzFile fd, unsigned int *var )
|
||||
void sgWriteUInt ( gzFile fd, const unsigned int var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)&var);
|
||||
sgEndianSwap( (uint32_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned int) )
|
||||
!= sizeof(unsigned int) )
|
||||
@@ -127,7 +127,7 @@ void sgReadInt ( gzFile fd, int *var )
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)var);
|
||||
sgEndianSwap( (uint32_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -135,7 +135,7 @@ void sgReadInt ( gzFile fd, int *var )
|
||||
void sgWriteInt ( gzFile fd, const int var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)&var);
|
||||
sgEndianSwap( (uint32_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(int) ) != sizeof(int) ) {
|
||||
write_error = true ;
|
||||
@@ -143,48 +143,48 @@ void sgWriteInt ( gzFile fd, const int var )
|
||||
}
|
||||
|
||||
|
||||
void sgReadLong ( gzFile fd, long int *var )
|
||||
void sgReadLong ( gzFile fd, int32_t *var )
|
||||
{
|
||||
if ( gzread ( fd, var, sizeof(long int) ) != sizeof(long int) ) {
|
||||
if ( gzread ( fd, var, sizeof(int32_t) ) != sizeof(int32_t) ) {
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)var);
|
||||
sgEndianSwap( (uint32_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void sgWriteLong ( gzFile fd, const long int var )
|
||||
void sgWriteLong ( gzFile fd, const int32_t var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int*)&var);
|
||||
sgEndianSwap( (uint32_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(long int) )
|
||||
!= sizeof(long int) )
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(int32_t) )
|
||||
!= sizeof(int32_t) )
|
||||
{
|
||||
write_error = true ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void sgReadLongLong ( gzFile fd, int64 *var )
|
||||
void sgReadLongLong ( gzFile fd, int64_t *var )
|
||||
{
|
||||
if ( gzread ( fd, var, sizeof(int64) ) != sizeof(int64) ) {
|
||||
if ( gzread ( fd, var, sizeof(int64_t) ) != sizeof(int64_t) ) {
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (uint64*)var);
|
||||
sgEndianSwap( (uint64_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void sgWriteLongLong ( gzFile fd, const int64 var )
|
||||
void sgWriteLongLong ( gzFile fd, const int64_t var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (uint64*)&var);
|
||||
sgEndianSwap( (uint64_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(int64) )
|
||||
!= sizeof(int64) )
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(int64_t) )
|
||||
!= sizeof(int64_t) )
|
||||
{
|
||||
write_error = true ;
|
||||
}
|
||||
@@ -197,7 +197,7 @@ void sgReadUShort ( gzFile fd, unsigned short *var )
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned short int*)var);
|
||||
sgEndianSwap( (uint16_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -205,7 +205,7 @@ void sgReadUShort ( gzFile fd, unsigned short *var )
|
||||
void sgWriteUShort ( gzFile fd, const unsigned short var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned short*)&var);
|
||||
sgEndianSwap( (uint16_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(unsigned short) )
|
||||
!= sizeof(unsigned short) )
|
||||
@@ -221,7 +221,7 @@ void sgReadShort ( gzFile fd, short *var )
|
||||
read_error = true ;
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned short int*)var);
|
||||
sgEndianSwap( (uint16_t *)var);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -229,7 +229,7 @@ void sgReadShort ( gzFile fd, short *var )
|
||||
void sgWriteShort ( gzFile fd, const short var )
|
||||
{
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned short*)&var);
|
||||
sgEndianSwap( (uint16_t *)&var);
|
||||
}
|
||||
if ( gzwrite ( fd, (void *)(&var), sizeof(short) ) != sizeof(short) ) {
|
||||
write_error = true ;
|
||||
@@ -244,7 +244,7 @@ void sgReadFloat ( gzFile fd, const unsigned int n, float *var )
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned int*)var++);
|
||||
sgEndianSwap( (uint32_t *)var++);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -257,7 +257,7 @@ void sgWriteFloat ( gzFile fd, const unsigned int n, const float *var )
|
||||
float *ptr = swab;
|
||||
memcpy( swab, var, sizeof(float) * n );
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned int*)ptr++);
|
||||
sgEndianSwap( (uint32_t *)ptr++);
|
||||
}
|
||||
var = swab;
|
||||
}
|
||||
@@ -275,7 +275,7 @@ void sgReadDouble ( gzFile fd, const unsigned int n, double *var )
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (uint64*)var++);
|
||||
sgEndianSwap( (uint64_t *)var++);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -288,7 +288,7 @@ void sgWriteDouble ( gzFile fd, const unsigned int n, const double *var )
|
||||
double *ptr = swab;
|
||||
memcpy( swab, var, sizeof(double) * n );
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (uint64*)ptr++);
|
||||
sgEndianSwap( (uint64_t *)ptr++);
|
||||
}
|
||||
var = swab;
|
||||
}
|
||||
@@ -325,7 +325,7 @@ void sgReadUShort ( gzFile fd, const unsigned int n, unsigned short *var )
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned short int*)var++);
|
||||
sgEndianSwap( (uint16_t *)var++);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -338,7 +338,7 @@ void sgWriteUShort ( gzFile fd, const unsigned int n, const unsigned short *var
|
||||
unsigned short *ptr = swab;
|
||||
memcpy( swab, var, sizeof(unsigned short) * n );
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned short*)ptr++);
|
||||
sgEndianSwap( (uint16_t *)ptr++);
|
||||
}
|
||||
var = swab;
|
||||
}
|
||||
@@ -360,7 +360,7 @@ void sgReadShort ( gzFile fd, const unsigned int n, short *var )
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned short int*)var++);
|
||||
sgEndianSwap( (uint16_t *)var++);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -373,7 +373,7 @@ void sgWriteShort ( gzFile fd, const unsigned int n, const short *var )
|
||||
short *ptr = swab;
|
||||
memcpy( swab, var, sizeof(short) * n );
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned short*)ptr++);
|
||||
sgEndianSwap( (uint16_t *)ptr++);
|
||||
}
|
||||
var = swab;
|
||||
}
|
||||
@@ -394,7 +394,7 @@ void sgReadUInt ( gzFile fd, const unsigned int n, unsigned int *var )
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned int*)var++);
|
||||
sgEndianSwap( (uint32_t *)var++);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -407,7 +407,7 @@ void sgWriteUInt ( gzFile fd, const unsigned int n, const unsigned int *var )
|
||||
unsigned int *ptr = swab;
|
||||
memcpy( swab, var, sizeof(unsigned int) * n );
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned int*)ptr++);
|
||||
sgEndianSwap( (uint32_t *)ptr++);
|
||||
}
|
||||
var = swab;
|
||||
}
|
||||
@@ -429,7 +429,7 @@ void sgReadInt ( gzFile fd, const unsigned int n, int *var )
|
||||
}
|
||||
if ( sgIsBigEndian() ) {
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned int*)var++);
|
||||
sgEndianSwap( (uint32_t *)var++);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -442,7 +442,7 @@ void sgWriteInt ( gzFile fd, const unsigned int n, const int *var )
|
||||
int *ptr = swab;
|
||||
memcpy( swab, var, sizeof(int) * n );
|
||||
for ( unsigned int i = 0; i < n; ++i ) {
|
||||
sgEndianSwap( (unsigned int*)ptr++);
|
||||
sgEndianSwap( (uint32_t *)ptr++);
|
||||
}
|
||||
var = swab;
|
||||
}
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
// Shamelessly adapted from plib January 2001
|
||||
//
|
||||
// Original version Copyright (C) 2000 the plib team
|
||||
// Local changes Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Local changes Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
@@ -18,7 +18,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
//
|
||||
@@ -27,19 +27,13 @@
|
||||
#ifndef _SG_LOWLEVEL_HXX
|
||||
#define _SG_LOWLEVEL_HXX
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <zlib.h>
|
||||
|
||||
#include <plib/sg.h>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
typedef __int64 int64;
|
||||
typedef __int64 uint64;
|
||||
#else
|
||||
typedef long long int64;
|
||||
typedef unsigned long long uint64;
|
||||
#endif
|
||||
#include <simgear/compiler.h>
|
||||
#include <simgear/misc/stdint.hxx>
|
||||
|
||||
// Note that output is written in little endian form (and converted as
|
||||
// necessary for big endian machines)
|
||||
@@ -54,10 +48,10 @@ void sgReadUInt ( gzFile fd, unsigned int *var ) ;
|
||||
void sgWriteUInt ( gzFile fd, const unsigned int var ) ;
|
||||
void sgReadInt ( gzFile fd, int *var ) ;
|
||||
void sgWriteInt ( gzFile fd, const int var ) ;
|
||||
void sgReadLong ( gzFile fd, long int *var ) ;
|
||||
void sgWriteLong ( gzFile fd, const long int var ) ;
|
||||
void sgReadLongLong ( gzFile fd, int64 *var ) ;
|
||||
void sgWriteLongLong ( gzFile fd, const int64 var ) ;
|
||||
void sgReadLong ( gzFile fd, int32_t *var ) ;
|
||||
void sgWriteLong ( gzFile fd, const int32_t var ) ;
|
||||
void sgReadLongLong ( gzFile fd, int64_t *var ) ;
|
||||
void sgWriteLongLong ( gzFile fd, const int64_t var ) ;
|
||||
void sgReadUShort ( gzFile fd, unsigned short *var ) ;
|
||||
void sgWriteUShort ( gzFile fd, const unsigned short var ) ;
|
||||
void sgReadShort ( gzFile fd, short *var ) ;
|
||||
@@ -121,52 +115,4 @@ void sgClearWriteError();
|
||||
int sgReadError();
|
||||
int sgWriteError();
|
||||
|
||||
inline bool sgIsLittleEndian() {
|
||||
static const int sgEndianTest = 1;
|
||||
return (*((char *) &sgEndianTest ) != 0);
|
||||
}
|
||||
|
||||
inline bool sgIsBigEndian() {
|
||||
static const int sgEndianTest = 1;
|
||||
return (*((char *) &sgEndianTest ) == 0);
|
||||
}
|
||||
|
||||
inline void sgEndianSwap(unsigned short *x) {
|
||||
*x =
|
||||
(( *x >> 8 ) & 0x00FF ) |
|
||||
(( *x << 8 ) & 0xFF00 ) ;
|
||||
}
|
||||
|
||||
inline void sgEndianSwap(unsigned int *x) {
|
||||
*x =
|
||||
(( *x >> 24 ) & 0x000000FF ) |
|
||||
(( *x >> 8 ) & 0x0000FF00 ) |
|
||||
(( *x << 8 ) & 0x00FF0000 ) |
|
||||
(( *x << 24 ) & 0xFF000000 ) ;
|
||||
}
|
||||
|
||||
inline void sgEndianSwap(uint64 *x) {
|
||||
#ifndef _MSC_VER
|
||||
*x =
|
||||
(( *x >> 56 ) & 0x00000000000000FFULL ) |
|
||||
(( *x >> 40 ) & 0x000000000000FF00ULL ) |
|
||||
(( *x >> 24 ) & 0x0000000000FF0000ULL ) |
|
||||
(( *x >> 8 ) & 0x00000000FF000000ULL ) |
|
||||
(( *x << 8 ) & 0x000000FF00000000ULL ) |
|
||||
(( *x << 24 ) & 0x0000FF0000000000ULL ) |
|
||||
(( *x << 40 ) & 0x00FF000000000000ULL ) |
|
||||
(( *x << 56 ) & 0xFF00000000000000ULL ) ;
|
||||
#else
|
||||
*x =
|
||||
(( *x >> 56 ) & 0x00000000000000FF ) |
|
||||
(( *x >> 40 ) & 0x000000000000FF00 ) |
|
||||
(( *x >> 24 ) & 0x0000000000FF0000 ) |
|
||||
(( *x >> 8 ) & 0x00000000FF000000 ) |
|
||||
(( *x << 8 ) & 0x000000FF00000000 ) |
|
||||
(( *x << 24 ) & 0x0000FF0000000000 ) |
|
||||
(( *x << 40 ) & 0x00FF000000000000 ) |
|
||||
(( *x << 56 ) & 0xFF00000000000000 ) ;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // _SG_LOWLEVEL_HXX
|
||||
|
||||
@@ -25,22 +25,22 @@ int main() {
|
||||
|
||||
short s = 1111;
|
||||
cout << "short s = " << s << endl;
|
||||
sgEndianSwap((unsigned short *)&s);
|
||||
sgEndianSwap((uint16_t *)&s);
|
||||
cout << "short s = " << s << endl;
|
||||
sgEndianSwap((unsigned short *)&s);
|
||||
sgEndianSwap((uint16_t *)&s);
|
||||
cout << "short s = " << s << endl;
|
||||
|
||||
int i = 1111111;
|
||||
cout << "int i = " << i << endl;
|
||||
sgEndianSwap((unsigned int *)&i);
|
||||
sgEndianSwap((uint32_t *)&i);
|
||||
cout << "int i = " << i << endl;
|
||||
sgEndianSwap((unsigned int *)&i);
|
||||
sgEndianSwap((uint32_t *)&i);
|
||||
cout << "int i = " << i << endl;
|
||||
|
||||
double x = 1111111111;
|
||||
cout << "double x = " << x << endl;
|
||||
sgEndianSwap((unsigned long long *)&x);
|
||||
sgEndianSwap((uint64_t *)&x);
|
||||
cout << "double x = " << x << endl;
|
||||
sgEndianSwap((unsigned long long *)&x);
|
||||
sgEndianSwap((uint64_t *)&x);
|
||||
cout << "double x = " << x << endl;
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started January 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
@@ -16,7 +16,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
//
|
||||
@@ -36,6 +36,7 @@
|
||||
#include STL_STRING
|
||||
|
||||
#include <simgear/bucket/newbucket.hxx>
|
||||
#include <simgear/misc/sg_path.hxx>
|
||||
|
||||
#include "lowlevel.hxx"
|
||||
#include "sg_binobj.hxx"
|
||||
@@ -45,7 +46,7 @@ SG_USING_STD( string );
|
||||
SG_USING_STD( vector );
|
||||
|
||||
|
||||
enum {
|
||||
enum sgObjectTypes {
|
||||
SG_BOUNDING_SPHERE = 0,
|
||||
|
||||
SG_VERTEX_LIST = 1,
|
||||
@@ -58,20 +59,19 @@ enum {
|
||||
SG_TRIANGLE_FACES = 10,
|
||||
SG_TRIANGLE_STRIPS = 11,
|
||||
SG_TRIANGLE_FANS = 12
|
||||
} sgObjectTypes;
|
||||
};
|
||||
|
||||
enum {
|
||||
enum sgIndexTypes {
|
||||
SG_IDX_VERTICES = 0x01,
|
||||
SG_IDX_NORMALS = 0x02,
|
||||
SG_IDX_COLORS = 0x04,
|
||||
SG_IDX_TEXCOORDS = 0x08
|
||||
} sgIndexTypes;
|
||||
};
|
||||
|
||||
enum {
|
||||
enum sgPropertyTypes {
|
||||
SG_MATERIAL = 0,
|
||||
SG_INDEX_TYPES = 1
|
||||
} sgPropertyTypes;
|
||||
|
||||
};
|
||||
|
||||
|
||||
class sgSimpleBuffer {
|
||||
@@ -174,7 +174,7 @@ static void read_object( gzFile fp,
|
||||
int idx_size;
|
||||
bool do_vertices, do_normals, do_colors, do_texcoords;
|
||||
int j, k, idx;
|
||||
static sgSimpleBuffer buf( 32768 ); // 32 Kb
|
||||
sgSimpleBuffer buf( 32768 ); // 32 Kb
|
||||
char material[256];
|
||||
|
||||
// default values
|
||||
@@ -240,8 +240,8 @@ static void read_object( gzFile fp,
|
||||
if ( nbytes > buf.get_size() ) { buf.resize( nbytes ); }
|
||||
char *ptr = buf.get_ptr();
|
||||
sgReadBytes( fp, nbytes, ptr );
|
||||
int count = nbytes / (idx_size * sizeof(short));
|
||||
short *sptr = (short *)ptr;
|
||||
int count = nbytes / (idx_size * sizeof(unsigned short));
|
||||
unsigned short *sptr = (unsigned short *)ptr;
|
||||
int_list vs; vs.clear();
|
||||
int_list ns; ns.clear();
|
||||
int_list cs; cs.clear();
|
||||
@@ -249,7 +249,7 @@ static void read_object( gzFile fp,
|
||||
for ( k = 0; k < count; ++k ) {
|
||||
if ( sgIsBigEndian() ) {
|
||||
for ( idx = 0; idx < idx_size; ++idx ) {
|
||||
sgEndianSwap( (unsigned short *)&(sptr[idx]) );
|
||||
sgEndianSwap( (uint16_t *)&(sptr[idx]) );
|
||||
}
|
||||
}
|
||||
idx = 0;
|
||||
@@ -280,13 +280,13 @@ static void read_object( gzFile fp,
|
||||
|
||||
// read a binary file and populate the provided structures.
|
||||
bool SGBinObject::read_bin( const string& file ) {
|
||||
Point3D p;
|
||||
SGVec3d p;
|
||||
int i, j, k;
|
||||
unsigned int nbytes;
|
||||
static sgSimpleBuffer buf( 32768 ); // 32 Kb
|
||||
sgSimpleBuffer buf( 32768 ); // 32 Kb
|
||||
|
||||
// zero out structures
|
||||
gbs_center = Point3D( 0 );
|
||||
gbs_center = SGVec3d(0, 0, 0);
|
||||
gbs_radius = 0.0;
|
||||
|
||||
wgs84_nodes.clear();
|
||||
@@ -322,7 +322,7 @@ bool SGBinObject::read_bin( const string& file ) {
|
||||
string filegz = file + ".gz";
|
||||
if ( (fp = gzopen( filegz.c_str(), "rb" )) == NULL ) {
|
||||
SG_LOG( SG_EVENT, SG_ALERT,
|
||||
"ERROR: opening " << file << " or " << filegz << "for reading!");
|
||||
"ERROR: opening " << file << " or " << filegz << " for reading!");
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -403,17 +403,17 @@ bool SGBinObject::read_bin( const string& file ) {
|
||||
|
||||
double *dptr = (double *)ptr;
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (uint64 *)&(dptr[0]) );
|
||||
sgEndianSwap( (uint64 *)&(dptr[1]) );
|
||||
sgEndianSwap( (uint64 *)&(dptr[2]) );
|
||||
sgEndianSwap( (uint64_t *)&(dptr[0]) );
|
||||
sgEndianSwap( (uint64_t *)&(dptr[1]) );
|
||||
sgEndianSwap( (uint64_t *)&(dptr[2]) );
|
||||
}
|
||||
gbs_center = Point3D( dptr[0], dptr[1], dptr[2] );
|
||||
gbs_center = SGVec3d( dptr[0], dptr[1], dptr[2] );
|
||||
// cout << "Center = " << gbs_center << endl;
|
||||
ptr += sizeof(double) * 3;
|
||||
|
||||
float *fptr = (float *)ptr;
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int *)fptr );
|
||||
sgEndianSwap( (uint32_t *)fptr );
|
||||
}
|
||||
gbs_radius = fptr[0];
|
||||
// cout << "Bounding radius = " << gbs_radius << endl;
|
||||
@@ -443,11 +443,11 @@ bool SGBinObject::read_bin( const string& file ) {
|
||||
wgs84_nodes.reserve( count );
|
||||
for ( k = 0; k < count; ++k ) {
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int *)&(fptr[0]) );
|
||||
sgEndianSwap( (unsigned int *)&(fptr[1]) );
|
||||
sgEndianSwap( (unsigned int *)&(fptr[2]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[0]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[1]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[2]) );
|
||||
}
|
||||
wgs84_nodes.push_back( Point3D(fptr[0], fptr[1], fptr[2]) );
|
||||
wgs84_nodes.push_back( SGVec3d(fptr[0], fptr[1], fptr[2]) );
|
||||
fptr += 3;
|
||||
}
|
||||
}
|
||||
@@ -476,12 +476,13 @@ bool SGBinObject::read_bin( const string& file ) {
|
||||
colors.reserve(count);
|
||||
for ( k = 0; k < count; ++k ) {
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int *)&(fptr[0]) );
|
||||
sgEndianSwap( (unsigned int *)&(fptr[1]) );
|
||||
sgEndianSwap( (unsigned int *)&(fptr[2]) );
|
||||
sgEndianSwap( (unsigned int *)&(fptr[3]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[0]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[1]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[2]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[3]) );
|
||||
}
|
||||
colors.push_back( Point3D( fptr[0], fptr[1], fptr[2] ) );
|
||||
SGVec4f color( fptr[0], fptr[1], fptr[2], fptr[3] );
|
||||
colors.push_back( color );
|
||||
fptr += 4;
|
||||
}
|
||||
}
|
||||
@@ -508,14 +509,11 @@ bool SGBinObject::read_bin( const string& file ) {
|
||||
int count = nbytes / 3;
|
||||
normals.reserve( count );
|
||||
for ( k = 0; k < count; ++k ) {
|
||||
sgdVec3 normal;
|
||||
sgdSetVec3( normal,
|
||||
(ptr[0]) / 127.5 - 1.0,
|
||||
(ptr[1]) / 127.5 - 1.0,
|
||||
(ptr[2]) / 127.5 - 1.0 );
|
||||
sgdNormalizeVec3( normal );
|
||||
SGVec3f normal((ptr[0]) / 127.5 - 1.0,
|
||||
(ptr[1]) / 127.5 - 1.0,
|
||||
(ptr[2]) / 127.5 - 1.0);
|
||||
|
||||
normals.push_back(Point3D(normal[0], normal[1], normal[2]));
|
||||
normals.push_back(normalize(normal));
|
||||
ptr += 3;
|
||||
}
|
||||
}
|
||||
@@ -544,10 +542,10 @@ bool SGBinObject::read_bin( const string& file ) {
|
||||
texcoords.reserve(count);
|
||||
for ( k = 0; k < count; ++k ) {
|
||||
if ( sgIsBigEndian() ) {
|
||||
sgEndianSwap( (unsigned int *)&(fptr[0]) );
|
||||
sgEndianSwap( (unsigned int *)&(fptr[1]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[0]) );
|
||||
sgEndianSwap( (uint32_t *)&(fptr[1]) );
|
||||
}
|
||||
texcoords.push_back( Point3D( fptr[0], fptr[1], 0 ) );
|
||||
texcoords.push_back( SGVec2f( fptr[0], fptr[1] ) );
|
||||
fptr += 2;
|
||||
}
|
||||
}
|
||||
@@ -612,28 +610,17 @@ bool SGBinObject::read_bin( const string& file ) {
|
||||
bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
const SGBucket& b )
|
||||
{
|
||||
Point3D p;
|
||||
sgVec2 t;
|
||||
sgVec3 pt;
|
||||
sgVec4 color;
|
||||
int i, j;
|
||||
unsigned char idx_mask;
|
||||
int idx_size;
|
||||
|
||||
string dir = base + "/" + b.gen_base_path();
|
||||
string command = "mkdir -p " + dir;
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
system( (string("mkdir ") + dir).c_str() );
|
||||
#else
|
||||
system(command.c_str());
|
||||
#endif
|
||||
|
||||
string file = dir + "/" + name + ".gz";
|
||||
cout << "Output file = " << file << endl;
|
||||
SGPath file = base + "/" + b.gen_base_path() + "/" + name + ".gz";
|
||||
file.create_dir( 0755 );
|
||||
cout << "Output file = " << file.str() << endl;
|
||||
|
||||
gzFile fp;
|
||||
if ( (fp = gzopen( file.c_str(), "wb9" )) == NULL ) {
|
||||
cout << "ERROR: opening " << file << " for writing!" << endl;
|
||||
cout << "ERROR: opening " << file.str() << " for writing!" << endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -656,7 +643,7 @@ bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
// write header magic
|
||||
sgWriteUInt( fp, SG_FILE_MAGIC_NUMBER );
|
||||
time_t calendar_time = time(NULL);
|
||||
sgWriteLong( fp, (long int)calendar_time );
|
||||
sgWriteLong( fp, (int32_t)calendar_time );
|
||||
|
||||
// calculate and write number of top level objects
|
||||
string material;
|
||||
@@ -745,9 +732,8 @@ bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
sgWriteShort( fp, 1 ); // nelements
|
||||
sgWriteUInt( fp, wgs84_nodes.size() * sizeof(float) * 3 ); // nbytes
|
||||
for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
|
||||
p = wgs84_nodes[i] - gbs_center;
|
||||
sgSetVec3( pt, p.x(), p.y(), p.z() );
|
||||
sgWriteVec3( fp, pt );
|
||||
SGVec3f p = toVec3f(wgs84_nodes[i] - gbs_center);
|
||||
sgWriteVec3( fp, p.data() );
|
||||
}
|
||||
|
||||
// dump vertex color list
|
||||
@@ -756,12 +742,7 @@ bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
sgWriteShort( fp, 1 ); // nelements
|
||||
sgWriteUInt( fp, colors.size() * sizeof(float) * 4 ); // nbytes
|
||||
for ( i = 0; i < (int)colors.size(); ++i ) {
|
||||
p = colors[i];
|
||||
// Right now we have a place holder for color alpha but we
|
||||
// need to update the interface so the calling program can
|
||||
// provide the info.
|
||||
sgSetVec4( color, p.x(), p.y(), p.z(), 1.0 );
|
||||
sgWriteVec4( fp, color );
|
||||
sgWriteVec4( fp, colors[i].data() );
|
||||
}
|
||||
|
||||
// dump vertex normal list
|
||||
@@ -771,7 +752,7 @@ bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
sgWriteUInt( fp, normals.size() * 3 ); // nbytes
|
||||
char normal[3];
|
||||
for ( i = 0; i < (int)normals.size(); ++i ) {
|
||||
p = normals[i];
|
||||
SGVec3f p = normals[i];
|
||||
normal[0] = (unsigned char)((p.x() + 1.0) * 127.5);
|
||||
normal[1] = (unsigned char)((p.y() + 1.0) * 127.5);
|
||||
normal[2] = (unsigned char)((p.z() + 1.0) * 127.5);
|
||||
@@ -784,9 +765,7 @@ bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
sgWriteShort( fp, 1 ); // nelements
|
||||
sgWriteUInt( fp, texcoords.size() * sizeof(float) * 2 ); // nbytes
|
||||
for ( i = 0; i < (int)texcoords.size(); ++i ) {
|
||||
p = texcoords[i];
|
||||
sgSetVec2( t, p.x(), p.y() );
|
||||
sgWriteVec2( fp, t );
|
||||
sgWriteVec2( fp, texcoords[i].data() );
|
||||
}
|
||||
|
||||
// dump point groups if they exist
|
||||
@@ -858,7 +837,8 @@ bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
// find next group
|
||||
material = tri_materials[start];
|
||||
while ( (end < (int)tri_materials.size()) &&
|
||||
(material == tri_materials[end]) )
|
||||
(material == tri_materials[end]) &&
|
||||
3*(end-start) < 32760 )
|
||||
{
|
||||
// cout << "end = " << end << endl;
|
||||
end++;
|
||||
@@ -1048,24 +1028,15 @@ bool SGBinObject::write_bin( const string& base, const string& name,
|
||||
bool SGBinObject::write_ascii( const string& base, const string& name,
|
||||
const SGBucket& b )
|
||||
{
|
||||
Point3D p;
|
||||
int i, j;
|
||||
|
||||
string dir = base + "/" + b.gen_base_path();
|
||||
string command = "mkdir -p " + dir;
|
||||
#if defined(_MSC_VER) || defined(__MINGW32__)
|
||||
system( (string("mkdir ") + dir).c_str() );
|
||||
#else
|
||||
system(command.c_str());
|
||||
#endif
|
||||
|
||||
// string file = dir + "/" + b.gen_index_str();
|
||||
string file = dir + "/" + name;
|
||||
cout << "Output file = " << file << endl;
|
||||
SGPath file = base + "/" + b.gen_base_path() + "/" + name;
|
||||
file.create_dir( 0755 );
|
||||
cout << "Output file = " << file.str() << endl;
|
||||
|
||||
FILE *fp;
|
||||
if ( (fp = fopen( file.c_str(), "w" )) == NULL ) {
|
||||
cout << "ERROR: opening " << file << " for writing!" << endl;
|
||||
cout << "ERROR: opening " << file.str() << " for writing!" << endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1098,7 +1069,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
|
||||
// dump vertex list
|
||||
fprintf(fp, "# vertex list\n");
|
||||
for ( i = 0; i < (int)wgs84_nodes.size(); ++i ) {
|
||||
p = wgs84_nodes[i] - gbs_center;
|
||||
SGVec3d p = wgs84_nodes[i] - gbs_center;
|
||||
|
||||
fprintf(fp, "v %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
|
||||
}
|
||||
@@ -1106,7 +1077,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
|
||||
|
||||
fprintf(fp, "# vertex normal list\n");
|
||||
for ( i = 0; i < (int)normals.size(); ++i ) {
|
||||
p = normals[i];
|
||||
SGVec3f p = normals[i];
|
||||
fprintf(fp, "vn %.5f %.5f %.5f\n", p.x(), p.y(), p.z() );
|
||||
}
|
||||
fprintf(fp, "\n");
|
||||
@@ -1114,7 +1085,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
|
||||
// dump texture coordinates
|
||||
fprintf(fp, "# texture coordinate list\n");
|
||||
for ( i = 0; i < (int)texcoords.size(); ++i ) {
|
||||
p = texcoords[i];
|
||||
SGVec2f p = texcoords[i];
|
||||
fprintf(fp, "vt %.5f %.5f\n", p.x(), p.y() );
|
||||
}
|
||||
fprintf(fp, "\n");
|
||||
@@ -1140,13 +1111,13 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
|
||||
// make a list of points for the group
|
||||
point_list group_nodes;
|
||||
group_nodes.clear();
|
||||
Point3D bs_center;
|
||||
SGVec3d bs_center;
|
||||
double bs_radius = 0;
|
||||
for ( i = start; i < end; ++i ) {
|
||||
for ( j = 0; j < (int)tris_v[i].size(); ++j ) {
|
||||
group_nodes.push_back( wgs84_nodes[ tris_v[i][j] ] );
|
||||
bs_center = sgCalcCenter( group_nodes );
|
||||
bs_radius = sgCalcBoundingRadius( bs_center, group_nodes );
|
||||
group_nodes.push_back( Point3D::fromSGVec3(wgs84_nodes[ tris_v[i][j] ]) );
|
||||
bs_center = sgCalcCenter( group_nodes ).toSGVec3d();
|
||||
bs_radius = sgCalcBoundingRadius( Point3D::fromSGVec3(bs_center), group_nodes );
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1191,13 +1162,13 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
|
||||
// make a list of points for the group
|
||||
point_list group_nodes;
|
||||
group_nodes.clear();
|
||||
Point3D bs_center;
|
||||
SGVec3d bs_center;
|
||||
double bs_radius = 0;
|
||||
for ( i = start; i < end; ++i ) {
|
||||
for ( j = 0; j < (int)strips_v[i].size(); ++j ) {
|
||||
group_nodes.push_back( wgs84_nodes[ strips_v[i][j] ] );
|
||||
bs_center = sgCalcCenter( group_nodes );
|
||||
bs_radius = sgCalcBoundingRadius( bs_center, group_nodes );
|
||||
group_nodes.push_back( Point3D::fromSGVec3(wgs84_nodes[ strips_v[i][j] ]) );
|
||||
bs_center = sgCalcCenter( group_nodes ).toSGVec3d();
|
||||
bs_radius = sgCalcBoundingRadius( Point3D::fromSGVec3(bs_center), group_nodes );
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1224,7 +1195,7 @@ bool SGBinObject::write_ascii( const string& base, const string& name,
|
||||
// close the file
|
||||
fclose(fp);
|
||||
|
||||
command = "gzip --force --best " + file;
|
||||
string command = "gzip --force --best " + file.str();
|
||||
system(command.c_str());
|
||||
|
||||
return true;
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
// Written by Curtis Olson, started January 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
@@ -19,7 +19,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -89,13 +89,13 @@ typedef group_list::const_iterator const_group_list_iterator;
|
||||
class SGBinObject {
|
||||
unsigned short version;
|
||||
|
||||
Point3D gbs_center;
|
||||
SGVec3d gbs_center;
|
||||
float gbs_radius;
|
||||
|
||||
point_list wgs84_nodes; // vertex list
|
||||
point_list colors; // color list
|
||||
point_list normals; // normal list
|
||||
point_list texcoords; // texture coordinate list
|
||||
std::vector<SGVec3d> wgs84_nodes; // vertex list
|
||||
std::vector<SGVec4f> colors; // color list
|
||||
std::vector<SGVec3f> normals; // normal list
|
||||
std::vector<SGVec2f> texcoords; // texture coordinate list
|
||||
|
||||
group_list pts_v; // points vertex index
|
||||
group_list pts_n; // points normal index
|
||||
@@ -125,23 +125,51 @@ public:
|
||||
|
||||
inline unsigned short get_version() const { return version; }
|
||||
|
||||
inline const Point3D& get_gbs_center() const { return gbs_center; }
|
||||
inline void set_gbs_center( const Point3D& p ) { gbs_center = p; }
|
||||
inline Point3D get_gbs_center() const { return Point3D::fromSGVec3(gbs_center); }
|
||||
inline void set_gbs_center( const Point3D& p ) { gbs_center = p.toSGVec3d(); }
|
||||
inline const SGVec3d& get_gbs_center2() const { return gbs_center; }
|
||||
inline void set_gbs_center( const SGVec3d& p ) { gbs_center = p; }
|
||||
|
||||
inline float get_gbs_radius() const { return gbs_radius; }
|
||||
inline void set_gbs_radius( float r ) { gbs_radius = r; }
|
||||
|
||||
inline const point_list& get_wgs84_nodes() const { return wgs84_nodes; }
|
||||
inline void set_wgs84_nodes( const point_list& n ) { wgs84_nodes = n; }
|
||||
inline const std::vector<SGVec3d>& get_wgs84_nodes() const
|
||||
{ return wgs84_nodes; }
|
||||
inline void set_wgs84_nodes( const std::vector<SGVec3d>& n )
|
||||
{ wgs84_nodes = n; }
|
||||
inline void set_wgs84_nodes( const point_list& n )
|
||||
{
|
||||
wgs84_nodes.resize(n.size());
|
||||
for (unsigned i = 0; i < wgs84_nodes.size(); ++i)
|
||||
wgs84_nodes[i] = n[i].toSGVec3d();
|
||||
}
|
||||
|
||||
inline const point_list& get_colors() const { return colors; }
|
||||
inline void set_colors( const point_list& c ) { colors = c; }
|
||||
inline const std::vector<SGVec4f>& get_colors() const { return colors; }
|
||||
inline void set_colors( const std::vector<SGVec4f>& c ) { colors = c; }
|
||||
inline void set_colors( const point_list& c )
|
||||
{
|
||||
colors.resize(c.size());
|
||||
for (unsigned i = 0; i < colors.size(); ++i)
|
||||
colors[i] = SGVec4f(c[i].toSGVec3f(), 1);
|
||||
}
|
||||
|
||||
inline const point_list& get_normals() const { return normals; }
|
||||
inline void set_normals( const point_list& n ) { normals = n; }
|
||||
inline const std::vector<SGVec3f>& get_normals() const { return normals; }
|
||||
inline void set_normals( const std::vector<SGVec3f>& n ) { normals = n; }
|
||||
inline void set_normals( const point_list& n )
|
||||
{
|
||||
normals.resize(n.size());
|
||||
for (unsigned i = 0; i < normals.size(); ++i)
|
||||
normals[i] = n[i].toSGVec3f();
|
||||
}
|
||||
|
||||
inline const point_list& get_texcoords() const { return texcoords; }
|
||||
inline void set_texcoords( const point_list& t ) { texcoords = t; }
|
||||
inline const std::vector<SGVec2f>& get_texcoords() const { return texcoords; }
|
||||
inline void set_texcoords( const std::vector<SGVec2f>& t ) { texcoords = t; }
|
||||
inline void set_texcoords( const point_list& t )
|
||||
{
|
||||
texcoords.resize(t.size());
|
||||
for (unsigned i = 0; i < texcoords.size(); ++i)
|
||||
texcoords[i] = t[i].toSGVec2f();
|
||||
}
|
||||
|
||||
inline const group_list& get_pts_v() const { return pts_v; }
|
||||
inline void set_pts_v( const group_list& g ) { pts_v = g; }
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -16,7 +16,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -29,6 +29,7 @@
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#include <simgear/misc/stdint.hxx>
|
||||
#include <simgear/debug/logstream.hxx>
|
||||
|
||||
#include "sg_file.hxx"
|
||||
@@ -39,6 +40,7 @@ SG_USING_STD(string);
|
||||
SGFile::SGFile( const string &file) {
|
||||
set_type( sgFileType );
|
||||
file_name = file;
|
||||
eof_flag = true;
|
||||
}
|
||||
|
||||
|
||||
@@ -70,6 +72,7 @@ bool SGFile::open( const SGProtocolDir d ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
eof_flag = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -77,7 +80,11 @@ bool SGFile::open( const SGProtocolDir d ) {
|
||||
// read a block of data of specified size
|
||||
int SGFile::read( char *buf, int length ) {
|
||||
// read a chunk
|
||||
return ::read( fp, buf, length );
|
||||
ssize_t result = ::read( fp, buf, length );
|
||||
if ( length > 0 && result == 0 ) {
|
||||
eof_flag = true;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
@@ -87,7 +94,10 @@ int SGFile::readline( char *buf, int length ) {
|
||||
int pos = lseek( fp, 0, SEEK_CUR );
|
||||
|
||||
// read a chunk
|
||||
int result = ::read( fp, buf, length );
|
||||
ssize_t result = ::read( fp, buf, length );
|
||||
if ( length > 0 && result == 0 ) {
|
||||
eof_flag = true;
|
||||
}
|
||||
|
||||
// find the end of line and reset position
|
||||
int i;
|
||||
@@ -130,5 +140,6 @@ bool SGFile::close() {
|
||||
return false;
|
||||
}
|
||||
|
||||
eof_flag = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -18,7 +18,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -54,6 +54,7 @@ class SGFile : public SGIOChannel {
|
||||
|
||||
string file_name;
|
||||
int fp;
|
||||
bool eof_flag;
|
||||
|
||||
public:
|
||||
|
||||
@@ -89,6 +90,9 @@ public:
|
||||
|
||||
/** @return the name of the file being manipulated. */
|
||||
inline string get_file_name() const { return file_name; }
|
||||
|
||||
/** @return true of eof conditions exists */
|
||||
inline bool eof() const { return eof_flag; };
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -16,7 +16,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -19,7 +19,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
// Modified by Bernie Bright <bbright@bigpond.net.au>, May 2002.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -17,10 +17,13 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <simgear/compiler.h>
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -19,7 +19,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started November 1999.
|
||||
//
|
||||
// Copyright (C) 1999 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 1999 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -16,10 +16,13 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <simgear/compiler.h>
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
// Written by Curtis Olson, started November 2001.
|
||||
//
|
||||
// Copyright (C) 2001 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2001 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -19,7 +19,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
|
||||
@@ -1,3 +1,7 @@
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <simgear/compiler.h>
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
@@ -23,6 +23,19 @@
|
||||
//
|
||||
// Put in some bullet-proofing to handle magnetic and geographic poles.
|
||||
// 3/28/2000 EAW
|
||||
//
|
||||
// Updated coefficient arrays to use the current WMM2005 model,
|
||||
// (valid between 2005.0 and 2010.0)
|
||||
// Also removed unused variables and corrected earth radii constants
|
||||
// to the values for WGS84 and WMM2005.
|
||||
// Reference:
|
||||
// McLean, S., S. Macmillan, S. Maus, V. Lesur, A.
|
||||
// Thomson, and D. Dater, December 2004, The
|
||||
// US/UK World Magnetic Model for 2005-2010,
|
||||
// NOAA Technical Report NESDIS/NGDC-1.
|
||||
//
|
||||
// 25/10/2006 Wim Van Hoydonck -- wim.van.hoydonck@gmail.com
|
||||
//
|
||||
|
||||
// The routine uses a spherical harmonic expansion of the magnetic
|
||||
// potential up to twelfth order, together with its time variation, as
|
||||
@@ -57,10 +70,9 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -76,74 +88,72 @@
|
||||
|
||||
|
||||
static const double pi = 3.14159265358979;
|
||||
static const double a = 6378.16; /* major radius (km) IAU66 ellipsoid */
|
||||
static const double f = 1.0 / 298.25; /* inverse flattening IAU66 ellipsoid */
|
||||
static const double b = 6378.16 * (1.0 -1.0 / 298.25 );
|
||||
/* minor radius b=a*(1-f) */
|
||||
static const double r_0 = 6371.2; /* "mean radius" for spherical harmonic expansion */
|
||||
static const double a = 6378.137; /* semi-major axis (equatorial radius) of WGS84 ellipsoid */
|
||||
static const double b = 6356.7523142; /* semi-minor axis referenced to the WGS84 ellipsoid */
|
||||
static const double r_0 = 6371.2; /* standard Earth magnetic reference radius */
|
||||
|
||||
static double gnm_wmm2000[13][13] =
|
||||
static double gnm_wmm2005[13][13] =
|
||||
{
|
||||
{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},
|
||||
{-29616.0, -1722.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-2266.7, 3070.2, 1677.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{1322.4, -2291.5, 1255.9, 724.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{932.1, 786.3, 250.6, -401.5, 106.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-211.9, 351.6, 220.8, -134.5, -168.8, -13.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{73.8, 68.2, 74.1, -163.5, -3.8, 17.1, -85.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{77.4, -73.9, 2.2, 35.7, 7.3, 5.2, 8.4, -1.5, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{23.3, 7.3, -8.5, -6.6, -16.9, 8.6, 4.9, -7.8, -7.6, 0.0, 0.0, 0.0, 0.0},
|
||||
{5.7, 8.5, 2.0, -9.8, 7.6, -7.0, -2.0, 9.2, -2.2, -6.6, 0.0, 0.0, 0.0},
|
||||
{-2.2, -5.7, 1.6, -3.7, -0.6, 4.1, 2.2, 2.2, 4.6, 2.3, 0.1, 0.0, 0.0},
|
||||
{3.3, -1.1, -2.4, 2.6, -1.3, -1.7, -0.6, 0.4, 0.7, -0.3, 2.3, 4.2, 0.0},
|
||||
{-1.5, -0.2, -0.3, 0.5, 0.2, 0.9, -1.4, 0.6, -0.6, -1.0, -0.3, 0.3, 0.4},
|
||||
{-29556.8, -1671.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-2340.6, 3046.9, 1657.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{1335.4, -2305.1, 1246.7, 674.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{919.8, 798.1, 211.3, -379.4, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-227.4, 354.6, 208.7, -136.5, -168.3, -14.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{73.2, 69.7, 76.7, -151.2, -14.9, 14.6, -86.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{80.1, -74.5, -1.4, 38.5, 12.4, 9.5, 5.7, 1.8, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{24.9, 7.7, -11.6, -6.9, -18.2, 10.0, 9.2, -11.6, -5.2, 0.0, 0.0, 0.0, 0.0},
|
||||
{5.6, 9.9, 3.5, -7.0, 5.1, -10.8, -1.3, 8.8, -6.7, -9.1, 0.0, 0.0, 0.0},
|
||||
{-2.3, -6.3, 1.6, -2.6, 0.0, 3.1, 0.4, 2.1, 3.9, -0.1, -2.3, 0.0, 0.0},
|
||||
{2.8, -1.6, -1.7, 1.7, -0.1, 0.1, -0.7, 0.7, 1.8, 0.0, 1.1, 4.1, 0.0},
|
||||
{-2.4, -0.4, 0.2, 0.8, -0.3, 1.1, -0.5, 0.4, -0.3, -0.3, -0.1, -0.3, -0.1},
|
||||
};
|
||||
|
||||
static double hnm_wmm2000[13][13]=
|
||||
static double hnm_wmm2005[13][13]=
|
||||
{
|
||||
{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, 5194.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -2484.8, -467.9, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -224.7, 293.0, -486.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 273.3, -227.9, 120.9, -302.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 42.0, 173.8, -135.0, -38.6, 105.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -17.4, 61.2, 63.2, -62.9, 0.2, 43.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -62.3, -24.5, 8.9, 23.4, 15.0, -27.6, -7.8, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 12.4, -20.8, 8.4, -21.2, 15.5, 9.1, -15.5, -5.4, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -20.4, 13.9, 12.0, -6.2, -8.6, 9.4, 5.0, -8.4, 3.2, 0.0, 0.0, 0.0},
|
||||
{0.0, 0.9, -0.7, 3.9, 4.8, -5.3, -1.0, -2.4, 1.3, -2.3, -6.4, 0.0, 0.0},
|
||||
{0.0, -1.5, 0.7, -1.1, -2.3, 1.3, -0.6, -2.8, -1.6, -0.1, -1.9, 1.4, 0.0},
|
||||
{0.0, -1.0, 0.7, 2.2, -2.5, -0.2, 0.0, -0.2, 0.0, 0.2, -0.9, -0.2, 1.0},
|
||||
{0.0, 5079.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -2594.7, -516.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -199.9, 269.3, -524.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 281.5, -226.0, 145.8, -304.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 42.4, 179.8, -123.0, -19.5, 103.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -20.3, 54.7, 63.6, -63.4, -0.1, 50.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -61.5, -22.4, 7.2, 25.4, 11.0, -26.4, -5.1, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 11.2, -21.0, 9.6, -19.8, 16.1, 7.7, -12.9, -0.2, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -20.1, 12.9, 12.6, -6.7, -8.1, 8.0, 2.9, -7.9, 6.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 2.4, 0.2, 4.4, 4.8, -6.5, -1.1, -3.4, -0.8, -2.3, -7.9, 0.0, 0.0},
|
||||
{0.0, 0.3, 1.2, -0.8, -2.5, 0.9, -0.6, -2.7, -0.9, -1.3, -2.0, -1.2, 0.0},
|
||||
{0.0, -0.4, 0.3, 2.4, -2.6, 0.6, 0.3, 0.0, 0.0, 0.3, -0.9, -0.4, 0.8},
|
||||
};
|
||||
|
||||
static double gtnm_wmm2000[13][13]=
|
||||
static double gtnm_wmm2005[13][13]=
|
||||
{
|
||||
{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},
|
||||
{14.7, 11.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-13.6, -0.7, -1.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.3, -4.3, 0.9, -8.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-1.6, 0.9, -7.6, 2.2, -3.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-0.9, -0.2, -2.5, -2.7, -0.9, 1.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{1.2, 0.2, 1.7, 1.6, -0.1, -0.3, 0.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-0.4, -0.8, -0.2, 1.1, 0.4, 0.0, -0.2, -0.2, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-0.3, 0.6, -0.8, 0.3, -0.2, 0.5, 0.0, -0.6, 0.1, 0.0, 0.0, 0.0, 0.0},
|
||||
{8.0, 10.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-15.1, -7.8, -0.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.4, -2.6, -1.2, -6.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-2.5, 2.8, -7.0, 6.2, -3.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-2.8, 0.7, -3.2, -1.1, 0.1, -0.8, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{-0.7, 0.4, -0.3, 2.3, -2.1, -0.6, 1.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.2, -0.1, -0.3, 1.1, 0.6, 0.5, -0.4, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.1, 0.3, -0.4, 0.3, -0.3, 0.2, 0.4, -0.7, 0.4, 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.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},
|
||||
};
|
||||
|
||||
static double htnm_wmm2000[13][13]=
|
||||
static double htnm_wmm2005[13][13]=
|
||||
{
|
||||
{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, -20.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -21.5, -9.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 6.4, -1.3, -13.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 2.3, 0.7, 3.7, -0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 0.0, 2.1, 2.3, 3.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -0.3, -1.7, -0.9, -1.0, -0.1, 1.9, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 1.4, 0.2, 0.7, 0.4, -0.3, -0.8, -0.1, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -0.5, 0.1, -0.2, 0.0, 0.1, -0.1, 0.3, 0.2, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -20.9, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -23.2, -14.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 5.0, -7.0, -0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 2.2, 1.6, 5.8, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 0.0, 1.7, 2.1, 4.8, -1.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -0.6, -1.9, -0.4, -0.5, -0.3, 0.7, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, 0.6, 0.4, 0.2, 0.3, -0.8, -0.2, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
{0.0, -0.2, 0.1, 0.3, 0.4, 0.1, -0.2, 0.4, 0.4, 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.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
|
||||
@@ -187,8 +197,8 @@ double calc_magvar( double lat, double lon, double h, long dat, double* field )
|
||||
{
|
||||
/* output field B_r,B_th,B_phi,B_x,B_y,B_z */
|
||||
int n,m;
|
||||
/* reference dates */
|
||||
long date0_wmm2000 = yymmdd_to_julian_days(0,1,1);
|
||||
/* reference date for current model is 1 januari 2005 */
|
||||
long date0_wmm2005 = yymmdd_to_julian_days(5,1,1);
|
||||
|
||||
double yearfrac,sr,r,theta,c,s,psi,fn,fn_0,B_r,B_theta,B_phi,X,Y,Z;
|
||||
double sinpsi, cospsi, inv_s;
|
||||
@@ -273,13 +283,14 @@ double calc_magvar( double lat, double lon, double h, long dat, double* field )
|
||||
}
|
||||
}
|
||||
|
||||
/* compute gnm, hnm at dat */
|
||||
/* WMM2000 */
|
||||
yearfrac = (dat - date0_wmm2000) / 365.25;
|
||||
/* compute Gauss coefficients gnm and hnm of degree n and order m for the desired time
|
||||
achieved by adjusting the coefficients at time t0 for linear secular variation */
|
||||
/* WMM2005 */
|
||||
yearfrac = (dat - date0_wmm2005) / 365.25;
|
||||
for ( n = 1; n <= nmax; n++ ) {
|
||||
for ( m = 0; m <= nmax; m++ ) {
|
||||
gnm[n][m] = gnm_wmm2000[n][m] + yearfrac * gtnm_wmm2000[n][m];
|
||||
hnm[n][m] = hnm_wmm2000[n][m] + yearfrac * htnm_wmm2000[n][m];
|
||||
gnm[n][m] = gnm_wmm2005[n][m] + yearfrac * gtnm_wmm2005[n][m];
|
||||
hnm[n][m] = hnm_wmm2005[n][m] + yearfrac * htnm_wmm2005[n][m];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -341,7 +352,7 @@ double SGMagVarOrig( double lat, double lon, double h, long dat, double* field )
|
||||
/* output field B_r,B_th,B_phi,B_x,B_y,B_z */
|
||||
int n,m;
|
||||
/* reference dates */
|
||||
long date0_wmm2000 = yymmdd_to_julian_days(0,1,1);
|
||||
long date0_wmm2005 = yymmdd_to_julian_days(5,1,1);
|
||||
|
||||
double yearfrac,sr,r,theta,c,s,psi,fn,B_r,B_theta,B_phi,X,Y,Z;
|
||||
|
||||
@@ -398,12 +409,12 @@ double SGMagVarOrig( double lat, double lon, double h, long dat, double* field )
|
||||
}
|
||||
|
||||
/* compute gnm, hnm at dat */
|
||||
/* WMM2000 */
|
||||
yearfrac = (dat - date0_wmm2000) / 365.25;
|
||||
/* WMM2005 */
|
||||
yearfrac = (dat - date0_wmm2005) / 365.25;
|
||||
for ( n = 1; n <= nmax; n++ ) {
|
||||
for ( m = 0; m <= nmax; m++ ) {
|
||||
gnm[n][m] = gnm_wmm2000[n][m] + yearfrac * gtnm_wmm2000[n][m];
|
||||
hnm[n][m] = hnm_wmm2000[n][m] + yearfrac * htnm_wmm2000[n][m];
|
||||
gnm[n][m] = gnm_wmm2005[n][m] + yearfrac * gtnm_wmm2005[n][m];
|
||||
hnm[n][m] = hnm_wmm2005[n][m] + yearfrac * htnm_wmm2005[n][m];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -26,10 +26,9 @@
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Library General Public
|
||||
// License along with this library; if not, write to the
|
||||
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// Written by Curtis Olson, started July 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -16,7 +16,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
// Written by Curtis Olson, started July 2000.
|
||||
//
|
||||
// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org
|
||||
// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
@@ -19,7 +19,7 @@
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
// $Id$
|
||||
|
||||
@@ -28,9 +28,9 @@
|
||||
#define _MAGVAR_HXX
|
||||
|
||||
|
||||
#ifndef __cplusplus
|
||||
#ifndef __cplusplus
|
||||
# error This library requires C++
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
.deps
|
||||
Makefile
|
||||
Makefile.in
|
||||
SGMathTest
|
||||
|
||||
@@ -1,11 +1,19 @@
|
||||
includedir = @includedir@/math
|
||||
|
||||
check_PROGRAMS = SGMathTest SGGeometryTest
|
||||
TESTS = $(check_PROGRAMS)
|
||||
|
||||
SGMathTest_SOURCES = SGMathTest.cxx
|
||||
SGMathTest_LDADD = libsgmath.a $(base_LIBS)
|
||||
|
||||
SGGeometryTest_SOURCES = SGGeometryTest.cxx
|
||||
SGGeometryTest_LDADD = libsgmath.a $(base_LIBS)
|
||||
|
||||
lib_LIBRARIES = libsgmath.a
|
||||
|
||||
include_HEADERS = \
|
||||
interpolater.hxx \
|
||||
leastsqs.hxx \
|
||||
localconsts.hxx \
|
||||
point3d.hxx \
|
||||
polar3d.hxx \
|
||||
sg_geodesy.hxx \
|
||||
@@ -13,9 +21,28 @@ include_HEADERS = \
|
||||
sg_random.h \
|
||||
sg_types.hxx \
|
||||
vector.hxx \
|
||||
fastmath.hxx
|
||||
|
||||
EXTRA_DIST = linintp2.h linintp2.inl sphrintp.h sphrintp.inl
|
||||
SGBox.hxx \
|
||||
SGCMath.hxx \
|
||||
SGGeoc.hxx \
|
||||
SGGeod.hxx \
|
||||
SGGeodesy.hxx \
|
||||
SGGeometry.hxx \
|
||||
SGGeometryFwd.hxx \
|
||||
SGIntersect.hxx \
|
||||
SGLimits.hxx \
|
||||
SGLineSegment.hxx \
|
||||
SGMatrix.hxx \
|
||||
SGMath.hxx \
|
||||
SGMathFwd.hxx \
|
||||
SGMisc.hxx \
|
||||
SGPlane.hxx \
|
||||
SGQuat.hxx \
|
||||
SGRay.hxx \
|
||||
SGSphere.hxx \
|
||||
SGTriangle.hxx \
|
||||
SGVec2.hxx \
|
||||
SGVec3.hxx \
|
||||
SGVec4.hxx
|
||||
|
||||
libsgmath_a_SOURCES = \
|
||||
interpolater.cxx \
|
||||
@@ -24,6 +51,6 @@ libsgmath_a_SOURCES = \
|
||||
sg_geodesy.cxx \
|
||||
sg_random.c \
|
||||
vector.cxx \
|
||||
fastmath.cxx
|
||||
SGGeodesy.cxx
|
||||
|
||||
INCLUDES = -I$(top_srcdir)
|
||||
|
||||
107
simgear/math/SGBox.hxx
Normal file
107
simgear/math/SGBox.hxx
Normal file
@@ -0,0 +1,107 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGBox_H
|
||||
#define SGBox_H
|
||||
|
||||
template<typename T>
|
||||
class SGBox {
|
||||
public:
|
||||
SGBox() :
|
||||
_min(SGLimits<T>::max(), SGLimits<T>::max(), SGLimits<T>::max()),
|
||||
_max(-SGLimits<T>::max(), -SGLimits<T>::max(), -SGLimits<T>::max())
|
||||
{ }
|
||||
void setMin(const SGVec3<T>& min)
|
||||
{ _min = min; }
|
||||
const SGVec3<T>& getMin() const
|
||||
{ return _min; }
|
||||
|
||||
void setMax(const SGVec3<T>& max)
|
||||
{ _max = max; }
|
||||
const SGVec3<T>& getMax() const
|
||||
{ return _max; }
|
||||
|
||||
// Only works for floating point types
|
||||
SGVec3<T> getCenter() const
|
||||
{ return T(0.5)*(_min + _max); }
|
||||
|
||||
// Only valid for nonempty boxes
|
||||
SGVec3<T> getSize() const
|
||||
{ return _max - _min; }
|
||||
|
||||
T getVolume() const
|
||||
{
|
||||
if (empty())
|
||||
return 0;
|
||||
return (_max[0] - _min[0])*(_max[1] - _min[1])*(_max[2] - _min[2]);
|
||||
}
|
||||
|
||||
const bool empty() const
|
||||
{ return !valid(); }
|
||||
|
||||
bool valid() const
|
||||
{
|
||||
if (_max[0] < _min[0])
|
||||
return false;
|
||||
if (_max[1] < _min[1])
|
||||
return false;
|
||||
if (_max[2] < _min[2])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
_min[0] = SGLimits<T>::max();
|
||||
_min[1] = SGLimits<T>::max();
|
||||
_min[2] = SGLimits<T>::max();
|
||||
_max[0] = -SGLimits<T>::max();
|
||||
_max[1] = -SGLimits<T>::max();
|
||||
_max[2] = -SGLimits<T>::max();
|
||||
}
|
||||
|
||||
void expandBy(const SGVec3<T>& v)
|
||||
{ _min = min(_min, v); _max = max(_max, v); }
|
||||
|
||||
void expandBy(const SGBox<T>& b)
|
||||
{ _min = min(_min, b._min); _max = max(_max, b._max); }
|
||||
|
||||
// Note that this only works if the box is nonmepty
|
||||
unsigned getBroadestAxis() const
|
||||
{
|
||||
SGVec3d size = getSize();
|
||||
if (size[1] <= size[0] && size[2] <= size[0])
|
||||
return 0;
|
||||
else if (size[2] <= size[1])
|
||||
return 1;
|
||||
else
|
||||
return 2;
|
||||
}
|
||||
|
||||
private:
|
||||
SGVec3<T> _min;
|
||||
SGVec3<T> _max;
|
||||
};
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s, const SGBox<T>& box)
|
||||
{ return s << "min = " << box.getMin() << ", max = " << box.getMax(); }
|
||||
|
||||
#endif
|
||||
31
simgear/math/SGCMath.hxx
Normal file
31
simgear/math/SGCMath.hxx
Normal file
@@ -0,0 +1,31 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGCMath_H
|
||||
#define SGCMath_H
|
||||
|
||||
#include <simgear/compiler.h>
|
||||
|
||||
#ifdef SG_HAVE_STD_INCLUDES
|
||||
// We have cmath from the standard c++ lib available
|
||||
#include <cmath>
|
||||
#else
|
||||
// We only have math.h with the c89 double functions.
|
||||
#include <math.h>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
302
simgear/math/SGGeoc.hxx
Normal file
302
simgear/math/SGGeoc.hxx
Normal file
@@ -0,0 +1,302 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGGeoc_H
|
||||
#define SGGeoc_H
|
||||
|
||||
#include <simgear/constants.h>
|
||||
|
||||
// #define SG_GEOC_NATIVE_DEGREE
|
||||
|
||||
/// Class representing a geocentric location
|
||||
class SGGeoc {
|
||||
public:
|
||||
/// Default constructor, initializes the instance to lat = lon = lat = 0
|
||||
SGGeoc(void);
|
||||
|
||||
/// Factory from angular values in radians and radius in ft
|
||||
static SGGeoc fromRadFt(double lon, double lat, double radius);
|
||||
/// Factory from angular values in degrees and radius in ft
|
||||
static SGGeoc fromDegFt(double lon, double lat, double radius);
|
||||
/// Factory from angular values in radians and radius in m
|
||||
static SGGeoc fromRadM(double lon, double lat, double radius);
|
||||
/// Factory from angular values in degrees and radius in m
|
||||
static SGGeoc fromDegM(double lon, double lat, double radius);
|
||||
/// Factory to convert position from a cartesian position assumed to be
|
||||
/// in wgs84 measured in meters
|
||||
/// Note that this conversion is relatively expensive to compute
|
||||
static SGGeoc fromCart(const SGVec3<double>& cart);
|
||||
/// Factory to convert position from a geodetic position
|
||||
/// Note that this conversion is relatively expensive to compute
|
||||
static SGGeoc fromGeod(const SGGeod& geod);
|
||||
|
||||
/// Return the geocentric longitude in radians
|
||||
double getLongitudeRad(void) const;
|
||||
/// Set the geocentric longitude from the argument given in radians
|
||||
void setLongitudeRad(double lon);
|
||||
|
||||
/// Return the geocentric longitude in degrees
|
||||
double getLongitudeDeg(void) const;
|
||||
/// Set the geocentric longitude from the argument given in degrees
|
||||
void setLongitudeDeg(double lon);
|
||||
|
||||
/// Return the geocentric latitude in radians
|
||||
double getLatitudeRad(void) const;
|
||||
/// Set the geocentric latitude from the argument given in radians
|
||||
void setLatitudeRad(double lat);
|
||||
|
||||
/// Return the geocentric latitude in degrees
|
||||
double getLatitudeDeg(void) const;
|
||||
/// Set the geocentric latitude from the argument given in degrees
|
||||
void setLatitudeDeg(double lat);
|
||||
|
||||
/// Return the geocentric radius in meters
|
||||
double getRadiusM(void) const;
|
||||
/// Set the geocentric radius from the argument given in meters
|
||||
void setRadiusM(double radius);
|
||||
|
||||
/// Return the geocentric radius in feet
|
||||
double getRadiusFt(void) const;
|
||||
/// Set the geocentric radius from the argument given in feet
|
||||
void setRadiusFt(double radius);
|
||||
|
||||
private:
|
||||
/// This one is private since construction is not unique if you do
|
||||
/// not know the units of the arguments, use the factory methods for
|
||||
/// that purpose
|
||||
SGGeoc(double lon, double lat, double radius);
|
||||
|
||||
/// The actual data, angles in degree, radius in meters
|
||||
/// The rationale for storing the values in degrees is that most code places
|
||||
/// in flightgear/terragear use degrees as a nativ input and output value.
|
||||
/// The places where it makes sense to use radians is when we convert
|
||||
/// to other representations or compute rotation matrices. But both tasks
|
||||
/// are computionally intensive anyway and that additional 'toRadian'
|
||||
/// conversion does not hurt too much
|
||||
double _lon;
|
||||
double _lat;
|
||||
double _radius;
|
||||
};
|
||||
|
||||
inline
|
||||
SGGeoc::SGGeoc(void) :
|
||||
_lon(0), _lat(0), _radius(0)
|
||||
{
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeoc::SGGeoc(double lon, double lat, double radius) :
|
||||
_lon(lon), _lat(lat), _radius(radius)
|
||||
{
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeoc
|
||||
SGGeoc::fromRadFt(double lon, double lat, double radius)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return SGGeoc(lon*SGD_RADIANS_TO_DEGREES, lat*SGD_RADIANS_TO_DEGREES,
|
||||
radius*SG_FEET_TO_METER);
|
||||
#else
|
||||
return SGGeoc(lon, lat, radius*SG_FEET_TO_METER);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeoc
|
||||
SGGeoc::fromDegFt(double lon, double lat, double radius)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return SGGeoc(lon, lat, radius*SG_FEET_TO_METER);
|
||||
#else
|
||||
return SGGeoc(lon*SGD_DEGREES_TO_RADIANS, lat*SGD_DEGREES_TO_RADIANS,
|
||||
radius*SG_FEET_TO_METER);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeoc
|
||||
SGGeoc::fromRadM(double lon, double lat, double radius)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return SGGeoc(lon*SGD_RADIANS_TO_DEGREES, lat*SGD_RADIANS_TO_DEGREES,
|
||||
radius);
|
||||
#else
|
||||
return SGGeoc(lon, lat, radius);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeoc
|
||||
SGGeoc::fromDegM(double lon, double lat, double radius)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return SGGeoc(lon, lat, radius);
|
||||
#else
|
||||
return SGGeoc(lon*SGD_DEGREES_TO_RADIANS, lat*SGD_DEGREES_TO_RADIANS,
|
||||
radius);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeoc
|
||||
SGGeoc::fromCart(const SGVec3<double>& cart)
|
||||
{
|
||||
SGGeoc geoc;
|
||||
SGGeodesy::SGCartToGeoc(cart, geoc);
|
||||
return geoc;
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeoc
|
||||
SGGeoc::fromGeod(const SGGeod& geod)
|
||||
{
|
||||
SGVec3<double> cart;
|
||||
SGGeodesy::SGGeodToCart(geod, cart);
|
||||
SGGeoc geoc;
|
||||
SGGeodesy::SGCartToGeoc(cart, geoc);
|
||||
return geoc;
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeoc::getLongitudeRad(void) const
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return _lon*SGD_DEGREES_TO_RADIANS;
|
||||
#else
|
||||
return _lon;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeoc::setLongitudeRad(double lon)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
_lon = lon*SGD_RADIANS_TO_DEGREES;
|
||||
#else
|
||||
_lon = lon;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeoc::getLongitudeDeg(void) const
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return _lon;
|
||||
#else
|
||||
return _lon*SGD_DEGREES_TO_RADIANS;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeoc::setLongitudeDeg(double lon)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
_lon = lon;
|
||||
#else
|
||||
_lon = lon*SGD_RADIANS_TO_DEGREES;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeoc::getLatitudeRad(void) const
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return _lat*SGD_DEGREES_TO_RADIANS;
|
||||
#else
|
||||
return _lat;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeoc::setLatitudeRad(double lat)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
_lat = lat*SGD_RADIANS_TO_DEGREES;
|
||||
#else
|
||||
_lat = lat;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeoc::getLatitudeDeg(void) const
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
return _lat;
|
||||
#else
|
||||
return _lat*SGD_DEGREES_TO_RADIANS;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeoc::setLatitudeDeg(double lat)
|
||||
{
|
||||
#ifdef SG_GEOC_NATIVE_DEGREE
|
||||
_lat = lat;
|
||||
#else
|
||||
_lat = lat*SGD_RADIANS_TO_DEGREES;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeoc::getRadiusM(void) const
|
||||
{
|
||||
return _radius;
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeoc::setRadiusM(double radius)
|
||||
{
|
||||
_radius = radius;
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeoc::getRadiusFt(void) const
|
||||
{
|
||||
return _radius*SG_METER_TO_FEET;
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeoc::setRadiusFt(double radius)
|
||||
{
|
||||
_radius = radius*SG_FEET_TO_METER;
|
||||
}
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s, const SGGeoc& g)
|
||||
{
|
||||
return s << "lon = " << g.getLongitudeDeg()
|
||||
<< ", lat = " << g.getLatitudeDeg()
|
||||
<< ", radius = " << g.getRadiusM();
|
||||
}
|
||||
|
||||
#endif
|
||||
329
simgear/math/SGGeod.hxx
Normal file
329
simgear/math/SGGeod.hxx
Normal file
@@ -0,0 +1,329 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGGeod_H
|
||||
#define SGGeod_H
|
||||
|
||||
#include <simgear/constants.h>
|
||||
|
||||
// #define SG_GEOD_NATIVE_DEGREE
|
||||
|
||||
/// Class representing a geodetic location
|
||||
class SGGeod {
|
||||
public:
|
||||
/// Default constructor, initializes the instance to lat = lon = elev = 0
|
||||
SGGeod(void);
|
||||
|
||||
/// Factory from angular values in radians and elevation is 0
|
||||
static SGGeod fromRad(double lon, double lat);
|
||||
/// Factory from angular values in degrees and elevation is 0
|
||||
static SGGeod fromDeg(double lon, double lat);
|
||||
/// Factory from angular values in radians and elevation in ft
|
||||
static SGGeod fromRadFt(double lon, double lat, double elevation);
|
||||
/// Factory from angular values in degrees and elevation in ft
|
||||
static SGGeod fromDegFt(double lon, double lat, double elevation);
|
||||
/// Factory from angular values in radians and elevation in m
|
||||
static SGGeod fromRadM(double lon, double lat, double elevation);
|
||||
/// Factory from angular values in degrees and elevation in m
|
||||
static SGGeod fromDegM(double lon, double lat, double elevation);
|
||||
/// Factory to convert position from a cartesian position assumed to be
|
||||
/// in wgs84 measured in meters
|
||||
/// Note that this conversion is relatively expensive to compute
|
||||
static SGGeod fromCart(const SGVec3<double>& cart);
|
||||
/// Factory to convert position from a geocentric position
|
||||
/// Note that this conversion is relatively expensive to compute
|
||||
static SGGeod fromGeoc(const SGGeoc& geoc);
|
||||
|
||||
/// Return the geodetic longitude in radians
|
||||
double getLongitudeRad(void) const;
|
||||
/// Set the geodetic longitude from the argument given in radians
|
||||
void setLongitudeRad(double lon);
|
||||
|
||||
/// Return the geodetic longitude in degrees
|
||||
double getLongitudeDeg(void) const;
|
||||
/// Set the geodetic longitude from the argument given in degrees
|
||||
void setLongitudeDeg(double lon);
|
||||
|
||||
/// Return the geodetic latitude in radians
|
||||
double getLatitudeRad(void) const;
|
||||
/// Set the geodetic latitude from the argument given in radians
|
||||
void setLatitudeRad(double lat);
|
||||
|
||||
/// Return the geodetic latitude in degrees
|
||||
double getLatitudeDeg(void) const;
|
||||
/// Set the geodetic latitude from the argument given in degrees
|
||||
void setLatitudeDeg(double lat);
|
||||
|
||||
/// Return the geodetic elevation in meters
|
||||
double getElevationM(void) const;
|
||||
/// Set the geodetic elevation from the argument given in meters
|
||||
void setElevationM(double elevation);
|
||||
|
||||
/// Return the geodetic elevation in feet
|
||||
double getElevationFt(void) const;
|
||||
/// Set the geodetic elevation from the argument given in feet
|
||||
void setElevationFt(double elevation);
|
||||
|
||||
private:
|
||||
/// This one is private since construction is not unique if you do
|
||||
/// not know the units of the arguments. Use the factory methods for
|
||||
/// that purpose
|
||||
SGGeod(double lon, double lat, double elevation);
|
||||
|
||||
/// The actual data, angles in degree, elevation in meters
|
||||
/// The rationale for storing the values in degrees is that most code places
|
||||
/// in flightgear/terragear use degrees as a nativ input and output value.
|
||||
/// The places where it makes sense to use radians is when we convert
|
||||
/// to other representations or compute rotation matrices. But both tasks
|
||||
/// are computionally intensive anyway and that additional 'toRadian'
|
||||
/// conversion does not hurt too much
|
||||
double _lon;
|
||||
double _lat;
|
||||
double _elevation;
|
||||
};
|
||||
|
||||
inline
|
||||
SGGeod::SGGeod(void) :
|
||||
_lon(0), _lat(0), _elevation(0)
|
||||
{
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod::SGGeod(double lon, double lat, double elevation) :
|
||||
_lon(lon), _lat(lat), _elevation(elevation)
|
||||
{
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromRad(double lon, double lat)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return SGGeod(lon*SGD_RADIANS_TO_DEGREES, lat*SGD_RADIANS_TO_DEGREES, 0);
|
||||
#else
|
||||
return SGGeod(lon, lat, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromDeg(double lon, double lat)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return SGGeod(lon, lat, 0);
|
||||
#else
|
||||
return SGGeod(lon*SGD_DEGREES_TO_RADIANS, lat*SGD_DEGREES_TO_RADIANS, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromRadFt(double lon, double lat, double elevation)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return SGGeod(lon*SGD_RADIANS_TO_DEGREES, lat*SGD_RADIANS_TO_DEGREES,
|
||||
elevation*SG_FEET_TO_METER);
|
||||
#else
|
||||
return SGGeod(lon, lat, elevation*SG_FEET_TO_METER);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromDegFt(double lon, double lat, double elevation)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return SGGeod(lon, lat, elevation*SG_FEET_TO_METER);
|
||||
#else
|
||||
return SGGeod(lon*SGD_DEGREES_TO_RADIANS, lat*SGD_DEGREES_TO_RADIANS,
|
||||
elevation*SG_FEET_TO_METER);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromRadM(double lon, double lat, double elevation)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return SGGeod(lon*SGD_RADIANS_TO_DEGREES, lat*SGD_RADIANS_TO_DEGREES,
|
||||
elevation);
|
||||
#else
|
||||
return SGGeod(lon, lat, elevation);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromDegM(double lon, double lat, double elevation)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return SGGeod(lon, lat, elevation);
|
||||
#else
|
||||
return SGGeod(lon*SGD_DEGREES_TO_RADIANS, lat*SGD_DEGREES_TO_RADIANS,
|
||||
elevation);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromCart(const SGVec3<double>& cart)
|
||||
{
|
||||
SGGeod geod;
|
||||
SGGeodesy::SGCartToGeod(cart, geod);
|
||||
return geod;
|
||||
}
|
||||
|
||||
inline
|
||||
SGGeod
|
||||
SGGeod::fromGeoc(const SGGeoc& geoc)
|
||||
{
|
||||
SGVec3<double> cart;
|
||||
SGGeodesy::SGGeocToCart(geoc, cart);
|
||||
SGGeod geod;
|
||||
SGGeodesy::SGCartToGeod(cart, geod);
|
||||
return geod;
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeod::getLongitudeRad(void) const
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return _lon*SGD_DEGREES_TO_RADIANS;
|
||||
#else
|
||||
return _lon;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeod::setLongitudeRad(double lon)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
_lon = lon*SGD_RADIANS_TO_DEGREES;
|
||||
#else
|
||||
_lon = lon;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeod::getLongitudeDeg(void) const
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return _lon;
|
||||
#else
|
||||
return _lon*SGD_RADIANS_TO_DEGREES;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeod::setLongitudeDeg(double lon)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
_lon = lon;
|
||||
#else
|
||||
_lon = lon*SGD_DEGREES_TO_RADIANS;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeod::getLatitudeRad(void) const
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return _lat*SGD_DEGREES_TO_RADIANS;
|
||||
#else
|
||||
return _lat;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeod::setLatitudeRad(double lat)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
_lat = lat*SGD_RADIANS_TO_DEGREES;
|
||||
#else
|
||||
_lat = lat;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeod::getLatitudeDeg(void) const
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
return _lat;
|
||||
#else
|
||||
return _lat*SGD_RADIANS_TO_DEGREES;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeod::setLatitudeDeg(double lat)
|
||||
{
|
||||
#ifdef SG_GEOD_NATIVE_DEGREE
|
||||
_lat = lat;
|
||||
#else
|
||||
_lat = lat*SGD_DEGREES_TO_RADIANS;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeod::getElevationM(void) const
|
||||
{
|
||||
return _elevation;
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeod::setElevationM(double elevation)
|
||||
{
|
||||
_elevation = elevation;
|
||||
}
|
||||
|
||||
inline
|
||||
double
|
||||
SGGeod::getElevationFt(void) const
|
||||
{
|
||||
return _elevation*SG_METER_TO_FEET;
|
||||
}
|
||||
|
||||
inline
|
||||
void
|
||||
SGGeod::setElevationFt(double elevation)
|
||||
{
|
||||
_elevation = elevation*SG_FEET_TO_METER;
|
||||
}
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s, const SGGeod& g)
|
||||
{
|
||||
return s << "lon = " << g.getLongitudeDeg()
|
||||
<< "deg, lat = " << g.getLatitudeDeg()
|
||||
<< "deg, elev = " << g.getElevationM()
|
||||
<< "m";
|
||||
}
|
||||
|
||||
#endif
|
||||
157
simgear/math/SGGeodesy.cxx
Normal file
157
simgear/math/SGGeodesy.cxx
Normal file
@@ -0,0 +1,157 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <cmath>
|
||||
|
||||
#include "SGMath.hxx"
|
||||
|
||||
// These are hard numbers from the WGS84 standard. DON'T MODIFY
|
||||
// unless you want to change the datum.
|
||||
#define _EQURAD 6378137.0
|
||||
#define _FLATTENING 298.257223563
|
||||
|
||||
// These are derived quantities more useful to the code:
|
||||
#if 0
|
||||
#define _SQUASH (1 - 1/_FLATTENING)
|
||||
#define _STRETCH (1/_SQUASH)
|
||||
#define _POLRAD (EQURAD * _SQUASH)
|
||||
#else
|
||||
// High-precision versions of the above produced with an arbitrary
|
||||
// precision calculator (the compiler might lose a few bits in the FPU
|
||||
// operations). These are specified to 81 bits of mantissa, which is
|
||||
// higher than any FPU known to me:
|
||||
#define _SQUASH 0.9966471893352525192801545
|
||||
#define _STRETCH 1.0033640898209764189003079
|
||||
#define _POLRAD 6356752.3142451794975639668
|
||||
#endif
|
||||
|
||||
// The constants from the WGS84 standard
|
||||
const double SGGeodesy::EQURAD = _EQURAD;
|
||||
const double SGGeodesy::iFLATTENING = _FLATTENING;
|
||||
const double SGGeodesy::SQUASH = _SQUASH;
|
||||
const double SGGeodesy::STRETCH = _STRETCH;
|
||||
const double SGGeodesy::POLRAD = _POLRAD;
|
||||
|
||||
// additional derived and precomputable ones
|
||||
// for the geodetic conversion algorithm
|
||||
|
||||
#define E2 fabs(1 - _SQUASH*_SQUASH)
|
||||
static double a = _EQURAD;
|
||||
static double ra2 = 1/(_EQURAD*_EQURAD);
|
||||
static double e = sqrt(E2);
|
||||
static double e2 = E2;
|
||||
static double e4 = E2*E2;
|
||||
|
||||
#undef _EQURAD
|
||||
#undef _FLATTENING
|
||||
#undef _SQUASH
|
||||
#undef _STRETCH
|
||||
#undef _POLRAD
|
||||
#undef E2
|
||||
|
||||
void
|
||||
SGGeodesy::SGCartToGeod(const SGVec3<double>& cart, SGGeod& geod)
|
||||
{
|
||||
// according to
|
||||
// H. Vermeille,
|
||||
// Direct transformation from geocentric to geodetic ccordinates,
|
||||
// Journal of Geodesy (2002) 76:451-454
|
||||
double X = cart(0);
|
||||
double Y = cart(1);
|
||||
double Z = cart(2);
|
||||
double XXpYY = X*X+Y*Y;
|
||||
double sqrtXXpYY = sqrt(XXpYY);
|
||||
double p = XXpYY*ra2;
|
||||
double q = Z*Z*(1-e2)*ra2;
|
||||
double r = 1/6.0*(p+q-e4);
|
||||
double s = e4*p*q/(4*r*r*r);
|
||||
double t = pow(1+s+sqrt(s*(2+s)), 1/3.0);
|
||||
double u = r*(1+t+1/t);
|
||||
double v = sqrt(u*u+e4*q);
|
||||
double w = e2*(u+v-q)/(2*v);
|
||||
double k = sqrt(u+v+w*w)-w;
|
||||
double D = k*sqrtXXpYY/(k+e2);
|
||||
geod.setLongitudeRad(2*atan2(Y, X+sqrtXXpYY));
|
||||
double sqrtDDpZZ = sqrt(D*D+Z*Z);
|
||||
geod.setLatitudeRad(2*atan2(Z, D+sqrtDDpZZ));
|
||||
geod.setElevationM((k+e2-1)*sqrtDDpZZ/k);
|
||||
}
|
||||
|
||||
void
|
||||
SGGeodesy::SGGeodToCart(const SGGeod& geod, SGVec3<double>& cart)
|
||||
{
|
||||
// according to
|
||||
// H. Vermeille,
|
||||
// Direct transformation from geocentric to geodetic ccordinates,
|
||||
// Journal of Geodesy (2002) 76:451-454
|
||||
double lambda = geod.getLongitudeRad();
|
||||
double phi = geod.getLatitudeRad();
|
||||
double h = geod.getElevationM();
|
||||
double sphi = sin(phi);
|
||||
double n = a/sqrt(1-e2*sphi*sphi);
|
||||
double cphi = cos(phi);
|
||||
double slambda = sin(lambda);
|
||||
double clambda = cos(lambda);
|
||||
cart(0) = (h+n)*cphi*clambda;
|
||||
cart(1) = (h+n)*cphi*slambda;
|
||||
cart(2) = (h+n-e2*n)*sphi;
|
||||
}
|
||||
|
||||
double
|
||||
SGGeodesy::SGGeodToSeaLevelRadius(const SGGeod& geod)
|
||||
{
|
||||
// this is just a simplified version of the SGGeodToCart function above,
|
||||
// substitute h = 0, take the 2-norm of the cartesian vector and simplify
|
||||
double phi = geod.getLatitudeRad();
|
||||
double sphi = sin(phi);
|
||||
double sphi2 = sphi*sphi;
|
||||
return a*sqrt((1 + (e4 - 2*e2)*sphi2)/(1 - e2*sphi2));
|
||||
}
|
||||
|
||||
void
|
||||
SGGeodesy::SGCartToGeoc(const SGVec3<double>& cart, SGGeoc& geoc)
|
||||
{
|
||||
double minVal = SGLimits<double>::min();
|
||||
if (fabs(cart(0)) < minVal && fabs(cart(1)) < minVal)
|
||||
geoc.setLongitudeRad(0);
|
||||
else
|
||||
geoc.setLongitudeRad(atan2(cart(1), cart(0)));
|
||||
|
||||
double nxy = sqrt(cart(0)*cart(0) + cart(1)*cart(1));
|
||||
if (fabs(nxy) < minVal && fabs(cart(2)) < minVal)
|
||||
geoc.setLatitudeRad(0);
|
||||
else
|
||||
geoc.setLatitudeRad(atan2(cart(2), nxy));
|
||||
|
||||
geoc.setRadiusM(norm(cart));
|
||||
}
|
||||
|
||||
void
|
||||
SGGeodesy::SGGeocToCart(const SGGeoc& geoc, SGVec3<double>& cart)
|
||||
{
|
||||
double lat = geoc.getLatitudeRad();
|
||||
double lon = geoc.getLongitudeRad();
|
||||
double slat = sin(lat);
|
||||
double clat = cos(lat);
|
||||
double slon = sin(lon);
|
||||
double clon = cos(lon);
|
||||
cart = geoc.getRadiusM()*SGVec3<double>(clat*clon, clat*slon, slat);
|
||||
}
|
||||
50
simgear/math/SGGeodesy.hxx
Normal file
50
simgear/math/SGGeodesy.hxx
Normal file
@@ -0,0 +1,50 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGGeodesy_H
|
||||
#define SGGeodesy_H
|
||||
|
||||
class SGGeodesy {
|
||||
public:
|
||||
// Hard numbers from the WGS84 standard.
|
||||
static const double EQURAD;
|
||||
static const double iFLATTENING;
|
||||
static const double SQUASH;
|
||||
static const double STRETCH;
|
||||
static const double POLRAD;
|
||||
|
||||
/// Takes a cartesian coordinate data and returns the geodetic
|
||||
/// coordinates.
|
||||
static void SGCartToGeod(const SGVec3<double>& cart, SGGeod& geod);
|
||||
|
||||
/// Takes a geodetic coordinate data and returns the cartesian
|
||||
/// coordinates.
|
||||
static void SGGeodToCart(const SGGeod& geod, SGVec3<double>& cart);
|
||||
|
||||
/// Takes a geodetic coordinate data and returns the sea level radius.
|
||||
static double SGGeodToSeaLevelRadius(const SGGeod& geod);
|
||||
|
||||
/// Takes a cartesian coordinate data and returns the geocentric
|
||||
/// coordinates.
|
||||
static void SGCartToGeoc(const SGVec3<double>& cart, SGGeoc& geoc);
|
||||
|
||||
/// Takes a geocentric coordinate data and returns the cartesian
|
||||
/// coordinates.
|
||||
static void SGGeocToCart(const SGGeoc& geoc, SGVec3<double>& cart);
|
||||
};
|
||||
|
||||
#endif
|
||||
38
simgear/math/SGGeometry.hxx
Normal file
38
simgear/math/SGGeometry.hxx
Normal file
@@ -0,0 +1,38 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGGeometry_HXX
|
||||
#define SGGeometry_HXX
|
||||
|
||||
// Required ...
|
||||
#include "SGMath.hxx"
|
||||
|
||||
// Make sure all is defined
|
||||
#include "SGGeometryFwd.hxx"
|
||||
|
||||
// Geometric primitives we know about
|
||||
#include "SGBox.hxx"
|
||||
#include "SGSphere.hxx"
|
||||
#include "SGRay.hxx"
|
||||
#include "SGLineSegment.hxx"
|
||||
#include "SGPlane.hxx"
|
||||
#include "SGTriangle.hxx"
|
||||
|
||||
// Intersection tests
|
||||
#include "SGIntersect.hxx"
|
||||
|
||||
#endif
|
||||
51
simgear/math/SGGeometryFwd.hxx
Normal file
51
simgear/math/SGGeometryFwd.hxx
Normal file
@@ -0,0 +1,51 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGGeometryFwd_HXX
|
||||
#define SGGeometryFwd_HXX
|
||||
|
||||
template<typename T>
|
||||
class SGBox;
|
||||
typedef SGBox<float> SGBoxf;
|
||||
typedef SGBox<double> SGBoxd;
|
||||
|
||||
template<typename T>
|
||||
class SGSphere;
|
||||
typedef SGSphere<float> SGSpheref;
|
||||
typedef SGSphere<double> SGSphered;
|
||||
|
||||
template<typename T>
|
||||
class SGRay;
|
||||
typedef SGRay<float> SGRayf;
|
||||
typedef SGRay<double> SGRayd;
|
||||
|
||||
template<typename T>
|
||||
class SGLineSegment;
|
||||
typedef SGLineSegment<float> SGLineSegmentf;
|
||||
typedef SGLineSegment<double> SGLineSegmentd;
|
||||
|
||||
template<typename T>
|
||||
class SGPlane;
|
||||
typedef SGPlane<float> SGPlanef;
|
||||
typedef SGPlane<double> SGPlaned;
|
||||
|
||||
template<typename T>
|
||||
class SGTriangle;
|
||||
typedef SGTriangle<float> SGTrianglef;
|
||||
typedef SGTriangle<double> SGTriangled;
|
||||
|
||||
#endif
|
||||
442
simgear/math/SGGeometryTest.cxx
Normal file
442
simgear/math/SGGeometryTest.cxx
Normal file
@@ -0,0 +1,442 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include "SGGeometry.hxx"
|
||||
#include "sg_random.h"
|
||||
|
||||
template<typename T>
|
||||
SGVec3<T> rndVec3(void)
|
||||
{
|
||||
return SGVec3<T>(sg_random(), sg_random(), sg_random());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool
|
||||
TriangleLineIntersectionTest(void)
|
||||
{
|
||||
unsigned nTests = 100000;
|
||||
unsigned failedCount = 0;
|
||||
for (unsigned i = 0; i < nTests; ++i) {
|
||||
SGVec3<T> v0 = rndVec3<T>();
|
||||
SGVec3<T> v1 = rndVec3<T>();
|
||||
SGVec3<T> v2 = rndVec3<T>();
|
||||
|
||||
SGTriangle<T> tri(v0, v1, v2);
|
||||
|
||||
// generate random coeficients
|
||||
T u = 4*sg_random() - 2;
|
||||
T v = 4*sg_random() - 2;
|
||||
T t = 4*sg_random() - 2;
|
||||
|
||||
SGVec3<T> isectpt = v0 + u*(v1 - v0) + v*(v2 - v0);
|
||||
|
||||
SGLineSegment<T> lineSegment;
|
||||
SGVec3<T> dir = rndVec3<T>();
|
||||
|
||||
SGVec3<T> isectres;
|
||||
lineSegment.set(isectpt - t*dir, isectpt + (1 - t)*dir);
|
||||
|
||||
if (intersects(isectres, tri, lineSegment)) {
|
||||
if (0 <= u && 0 <= v && u+v <= 1 && 0 <= t && t <= 1) {
|
||||
if (!equivalent(isectres, isectpt)) {
|
||||
std::cout << "Failed line segment intersection test #" << i
|
||||
<< ": not equivalent!\nu = "
|
||||
<< u << ", v = " << v << ", t = " << t
|
||||
<< "\n" << tri << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
std::cout << "Failed line segment intersection test #" << i
|
||||
<< ": false positive!\nu = "
|
||||
<< u << ", v = " << v << ", t = " << t
|
||||
<< "\n" << tri << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (0 <= u && 0 <= v && u+v <= 1 && 0 <= t && t <= 1) {
|
||||
std::cout << "Failed line segment intersection test #" << i
|
||||
<< ": false negative!\nu = "
|
||||
<< u << ", v = " << v << ", t = " << t
|
||||
<< "\n" << tri << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
|
||||
SGRay<T> ray;
|
||||
ray.set(isectpt - t*dir, dir);
|
||||
if (intersects(isectres, tri, ray)) {
|
||||
if (0 <= u && 0 <= v && u+v <= 1 && 0 <= t) {
|
||||
if (!equivalent(isectres, isectpt)) {
|
||||
std::cout << "Failed ray intersection test #" << i
|
||||
<< ": not equivalent!\nu = "
|
||||
<< u << ", v = " << v << ", t = " << t
|
||||
<< "\n" << tri << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
std::cout << "Failed ray intersection test #" << i
|
||||
<< ": false positive!\nu = "
|
||||
<< u << ", v = " << v << ", t = " << t
|
||||
<< "\n" << tri << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (0 <= u && 0 <= v && u+v <= 1 && 0 <= t) {
|
||||
std::cout << "Failed ray intersection test #" << i
|
||||
<< ": false negative !\nu = "
|
||||
<< u << ", v = " << v << ", t = " << t
|
||||
<< "\n" << tri << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (nTests < 100*failedCount) {
|
||||
std::cout << "Failed ray intersection tests: " << failedCount
|
||||
<< " tests out of " << nTests
|
||||
<< " went wrong. Abort!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Some crude handmade test
|
||||
SGVec3<T> v0 = SGVec3<T>(0, 0, 0);
|
||||
SGVec3<T> v1 = SGVec3<T>(1, 0, 0);
|
||||
SGVec3<T> v2 = SGVec3<T>(0, 1, 0);
|
||||
|
||||
SGTriangle<T> tri(v0, v1, v2);
|
||||
|
||||
SGRay<T> ray;
|
||||
ray.set(SGVec3<T>(0, 0, 1), SGVec3<T>(0.1, 0.1, -1));
|
||||
if (!intersects(tri, ray)) {
|
||||
std::cout << "Failed test #1!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
ray.set(SGVec3<T>(0, 0, 1), SGVec3<T>(0, 0, -1));
|
||||
if (!intersects(tri, ray)) {
|
||||
std::cout << "Failed test #2!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
SGLineSegment<T> lineSegment;
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(0.1, 0.1, -1));
|
||||
if (!intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #3!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(0, 0, -1));
|
||||
if (!intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #4!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(0, 1, -1));
|
||||
if (!intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #5!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(1, 0, -1));
|
||||
if (!intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #6!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(1, 1, -1));
|
||||
if (!intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #7!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
// is exactly in the plane
|
||||
// FIXME: cannot detect that yet ??
|
||||
// lineSegment.set(SGVec3<T>(0, 0, 0), SGVec3<T>(1, 0, 0));
|
||||
// if (!intersects(tri, lineSegment)) {
|
||||
// std::cout << "Failed test #8!" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// is exactly in the plane
|
||||
// FIXME: cannot detect that yet ??
|
||||
// lineSegment.set(SGVec3<T>(-1, 0, 0), SGVec3<T>(1, 0, 0));
|
||||
// if (!intersects(tri, lineSegment)) {
|
||||
// std::cout << "Failed test #9!" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// is exactly paralell to the plane
|
||||
// FIXME: cannot detect that yet ??
|
||||
// lineSegment.set(SGVec3<T>(-1, 1, 0), SGVec3<T>(1, 1, 0));
|
||||
// if (intersects(tri, lineSegment)) {
|
||||
// std::cout << "Failed test #10!" << std::endl;
|
||||
// return false;
|
||||
// }
|
||||
|
||||
// should fail since the line segment poins slightly beyond the triangle
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(1, 1, -0.9));
|
||||
if (intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #11!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(0, -0.1, -1));
|
||||
if (intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #12!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(-0.1, -0.1, -1));
|
||||
if (intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #13!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
lineSegment.set(SGVec3<T>(0, 0, 1), SGVec3<T>(-0.1, 0, -1));
|
||||
if (intersects(tri, lineSegment)) {
|
||||
std::cout << "Failed test #14!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool
|
||||
SphereLineIntersectionTest(void)
|
||||
{
|
||||
unsigned nTests = 100000;
|
||||
unsigned failedCount = 0;
|
||||
for (unsigned i = 0; i < nTests; ++i) {
|
||||
SGVec3<T> center = rndVec3<T>();
|
||||
T radius = 2*sg_random();
|
||||
SGSphere<T> sphere(center, radius);
|
||||
|
||||
SGVec3<T> offset = normalize(rndVec3<T>());
|
||||
T t = 4*sg_random();
|
||||
|
||||
// This one is the point we use to judge if the test should fail or not
|
||||
SGVec3<T> base = center + t*offset;
|
||||
|
||||
SGVec3<T> per = perpendicular(offset);
|
||||
SGVec3<T> start = base + 4*sg_random()*per;
|
||||
SGVec3<T> end = base - 4*sg_random()*per;
|
||||
|
||||
SGLineSegment<T> lineSegment;
|
||||
lineSegment.set(start, end);
|
||||
if (intersects(sphere, lineSegment)) {
|
||||
if (radius < t) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false positive!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (t <= radius) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false negative!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
|
||||
SGRay<T> ray;
|
||||
ray.set(start, end - start);
|
||||
if (intersects(sphere, ray)) {
|
||||
if (radius < t) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false positive!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (t <= radius) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false negative!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (nTests < 100*failedCount) {
|
||||
std::cout << "Failed sphere line intersection tests: " << failedCount
|
||||
<< " tests out of " << nTests
|
||||
<< " went wrong. Abort!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
failedCount = 0;
|
||||
for (unsigned i = 0; i < nTests; ++i) {
|
||||
SGVec3<T> center = rndVec3<T>();
|
||||
T radius = 2*sg_random();
|
||||
SGSphere<T> sphere(center, radius);
|
||||
|
||||
SGVec3<T> offset = normalize(rndVec3<T>());
|
||||
T t = 4*sg_random();
|
||||
|
||||
// This one is the point we use to judge if the test should fail or not
|
||||
SGVec3<T> base = center + t*offset;
|
||||
|
||||
SGVec3<T> start = base;
|
||||
SGVec3<T> end = base + 2*sg_random()*offset;
|
||||
|
||||
SGLineSegment<T> lineSegment;
|
||||
lineSegment.set(start, end);
|
||||
if (intersects(sphere, lineSegment)) {
|
||||
if (radius < t) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false positive!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (t <= radius) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false negative!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
|
||||
SGRay<T> ray;
|
||||
ray.set(start, end - start);
|
||||
if (intersects(sphere, ray)) {
|
||||
if (radius < t) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false positive!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (t <= radius) {
|
||||
std::cout << "Failed sphere line intersection test #" << i
|
||||
<< ": false negative!\nt = " << t << "\n"
|
||||
<< sphere << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (nTests < 100*failedCount) {
|
||||
std::cout << "Failed sphere line intersection tests: " << failedCount
|
||||
<< " tests out of " << nTests
|
||||
<< " went wrong. Abort!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool
|
||||
BoxLineIntersectionTest(void)
|
||||
{
|
||||
// ok, bad test case coverage, but better than nothing ...
|
||||
|
||||
unsigned nTests = 100000;
|
||||
unsigned failedCount = 0;
|
||||
for (unsigned i = 0; i < nTests; ++i) {
|
||||
SGBox<T> box;
|
||||
box.expandBy(rndVec3<T>());
|
||||
box.expandBy(rndVec3<T>());
|
||||
|
||||
SGVec3<T> center = box.getCenter();
|
||||
|
||||
// This one is the point we use to judge if the test should fail or not
|
||||
SGVec3<T> base = rndVec3<T>();
|
||||
SGVec3<T> dir = base - center;
|
||||
|
||||
SGLineSegment<T> lineSegment;
|
||||
lineSegment.set(base, base + dir);
|
||||
if (intersects(box, lineSegment)) {
|
||||
if (!intersects(box, base)) {
|
||||
std::cout << "Failed box line intersection test #" << i
|
||||
<< ": false positive!\n"
|
||||
<< box << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (intersects(box, base)) {
|
||||
std::cout << "Failed box line intersection test #" << i
|
||||
<< ": false negative!\n"
|
||||
<< box << "\n" << lineSegment << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
|
||||
SGRay<T> ray;
|
||||
ray.set(base, dir);
|
||||
if (intersects(box, ray)) {
|
||||
if (!intersects(box, base)) {
|
||||
std::cout << "Failed box line intersection test #" << i
|
||||
<< ": false positive!\n"
|
||||
<< box << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
} else {
|
||||
if (intersects(box, base)) {
|
||||
std::cout << "Failed box line intersection test #" << i
|
||||
<< ": false negative!\n"
|
||||
<< box << "\n" << ray << std::endl;
|
||||
++failedCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (nTests < 100*failedCount) {
|
||||
std::cout << "Failed box line intersection tests: " << failedCount
|
||||
<< " tests out of " << nTests
|
||||
<< " went wrong. Abort!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
std::cout << "Testing Geometry intersection routines.\n"
|
||||
<< "Some of these tests can fail due to roundoff problems...\n"
|
||||
<< "Dont worry if only a few of them fail..." << std::endl;
|
||||
|
||||
if (!TriangleLineIntersectionTest<float>())
|
||||
return EXIT_FAILURE;
|
||||
if (!TriangleLineIntersectionTest<double>())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
if (!SphereLineIntersectionTest<float>())
|
||||
return EXIT_FAILURE;
|
||||
if (!SphereLineIntersectionTest<double>())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
if (!BoxLineIntersectionTest<float>())
|
||||
return EXIT_FAILURE;
|
||||
if (!BoxLineIntersectionTest<double>())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
std::cout << "Successfully passed all tests!" << std::endl;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
627
simgear/math/SGIntersect.hxx
Normal file
627
simgear/math/SGIntersect.hxx
Normal file
@@ -0,0 +1,627 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGIntersect_HXX
|
||||
#define SGIntersect_HXX
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGBox<T>& box, const SGSphere<T>& sphere)
|
||||
{
|
||||
if (sphere.empty())
|
||||
return false;
|
||||
// Is more or less trivially included in the next tests
|
||||
// if (box.empty())
|
||||
// return false;
|
||||
|
||||
if (sphere.getCenter().x() < box.getMin().x() - sphere.getRadius())
|
||||
return false;
|
||||
if (sphere.getCenter().y() < box.getMin().y() - sphere.getRadius())
|
||||
return false;
|
||||
if (sphere.getCenter().z() < box.getMin().z() - sphere.getRadius())
|
||||
return false;
|
||||
|
||||
if (box.getMax().x() + sphere.getRadius() < sphere.getCenter().x())
|
||||
return false;
|
||||
if (box.getMax().y() + sphere.getRadius() < sphere.getCenter().y())
|
||||
return false;
|
||||
if (box.getMax().z() + sphere.getRadius() < sphere.getCenter().z())
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGSphere<T>& sphere, const SGBox<T>& box)
|
||||
{ return intersects(box, sphere); }
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGVec3<T>& v, const SGBox<T>& box)
|
||||
{
|
||||
if (v[0] < box.getMin()[0])
|
||||
return false;
|
||||
if (box.getMax()[0] < v[0])
|
||||
return false;
|
||||
if (v[1] < box.getMin()[1])
|
||||
return false;
|
||||
if (box.getMax()[1] < v[1])
|
||||
return false;
|
||||
if (v[2] < box.getMin()[2])
|
||||
return false;
|
||||
if (box.getMax()[2] < v[2])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGBox<T>& box, const SGVec3<T>& v)
|
||||
{ return intersects(v, box); }
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGRay<T>& ray, const SGPlane<T>& plane)
|
||||
{
|
||||
// We compute the intersection point
|
||||
// x = origin + \alpha*direction
|
||||
// from the ray origin and non nomalized direction.
|
||||
// For 0 <= \alpha the ray intersects the infinite plane.
|
||||
// The intersection point x can also be written
|
||||
// x = n*dist + y
|
||||
// where n is the planes normal, dist is the distance of the plane from
|
||||
// the origin in normal direction and y is ana aproriate vector
|
||||
// perpendicular to n.
|
||||
// Equate the x values and take the scalar product with the plane normal n.
|
||||
// dot(n, origin) + \alpha*dot(n, direction) = dist
|
||||
// We can now compute alpha from the above equation.
|
||||
// \alpha = (dist - dot(n, origin))/dot(n, direction)
|
||||
|
||||
// The negative numerator for the \alpha expression
|
||||
T num = plane.getPositiveDist();
|
||||
num -= dot(plane.getNormal(), ray.getOrigin());
|
||||
|
||||
// If the numerator is zero, we have the rays origin included in the plane
|
||||
if (fabs(num) <= SGLimits<T>::min())
|
||||
return true;
|
||||
|
||||
// The denominator for the \alpha expression
|
||||
T den = dot(plane.getNormal(), ray.getDirection());
|
||||
|
||||
// If we get here, we already know that the rays origin is not included
|
||||
// in the plane. Thus if we have a zero denominator we have
|
||||
// a ray paralell to the plane. That is no intersection.
|
||||
if (fabs(den) <= SGLimits<T>::min())
|
||||
return false;
|
||||
|
||||
// We would now compute \alpha = num/den and compare with 0 and 1.
|
||||
// But to avoid that expensive division, check equation multiplied by
|
||||
// the denominator.
|
||||
T alphaDen = copysign(1, den)*num;
|
||||
if (alphaDen < 0)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGPlane<T>& plane, const SGRay<T>& ray)
|
||||
{ return intersects(ray, plane); }
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(SGVec3<T>& dst, const SGRay<T>& ray, const SGPlane<T>& plane)
|
||||
{
|
||||
// We compute the intersection point
|
||||
// x = origin + \alpha*direction
|
||||
// from the ray origin and non nomalized direction.
|
||||
// For 0 <= \alpha the ray intersects the infinite plane.
|
||||
// The intersection point x can also be written
|
||||
// x = n*dist + y
|
||||
// where n is the planes normal, dist is the distance of the plane from
|
||||
// the origin in normal direction and y is ana aproriate vector
|
||||
// perpendicular to n.
|
||||
// Equate the x values and take the scalar product with the plane normal n.
|
||||
// dot(n, origin) + \alpha*dot(n, direction) = dist
|
||||
// We can now compute alpha from the above equation.
|
||||
// \alpha = (dist - dot(n, origin))/dot(n, direction)
|
||||
|
||||
// The negative numerator for the \alpha expression
|
||||
T num = plane.getPositiveDist();
|
||||
num -= dot(plane.getNormal(), ray.getOrigin());
|
||||
|
||||
// If the numerator is zero, we have the rays origin included in the plane
|
||||
if (fabs(num) <= SGLimits<T>::min()) {
|
||||
dst = ray.getOrigin();
|
||||
return true;
|
||||
}
|
||||
|
||||
// The denominator for the \alpha expression
|
||||
T den = dot(plane.getNormal(), ray.getDirection());
|
||||
|
||||
// If we get here, we already know that the rays origin is not included
|
||||
// in the plane. Thus if we have a zero denominator we have
|
||||
// a ray paralell to the plane. That is no intersection.
|
||||
if (fabs(den) <= SGLimits<T>::min())
|
||||
return false;
|
||||
|
||||
// We would now compute \alpha = num/den and compare with 0 and 1.
|
||||
// But to avoid that expensive division, check equation multiplied by
|
||||
// the denominator.
|
||||
T alpha = num/den;
|
||||
if (alpha < 0)
|
||||
return false;
|
||||
|
||||
dst = ray.getOrigin() + alpha*ray.getDirection();
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(SGVec3<T>& dst, const SGPlane<T>& plane, const SGRay<T>& ray)
|
||||
{ return intersects(dst, ray, plane); }
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGLineSegment<T>& lineSegment, const SGPlane<T>& plane)
|
||||
{
|
||||
// We compute the intersection point
|
||||
// x = origin + \alpha*direction
|
||||
// from the line segments origin and non nomalized direction.
|
||||
// For 0 <= \alpha <= 1 the line segment intersects the infinite plane.
|
||||
// The intersection point x can also be written
|
||||
// x = n*dist + y
|
||||
// where n is the planes normal, dist is the distance of the plane from
|
||||
// the origin in normal direction and y is ana aproriate vector
|
||||
// perpendicular to n.
|
||||
// Equate the x values and take the scalar product with the plane normal n.
|
||||
// dot(n, origin) + \alpha*dot(n, direction) = dist
|
||||
// We can now compute alpha from the above equation.
|
||||
// \alpha = (dist - dot(n, origin))/dot(n, direction)
|
||||
|
||||
// The negative numerator for the \alpha expression
|
||||
T num = plane.getPositiveDist();
|
||||
num -= dot(plane.getNormal(), lineSegment.getOrigin());
|
||||
|
||||
// If the numerator is zero, we have the lines origin included in the plane
|
||||
if (fabs(num) <= SGLimits<T>::min())
|
||||
return true;
|
||||
|
||||
// The denominator for the \alpha expression
|
||||
T den = dot(plane.getNormal(), lineSegment.getDirection());
|
||||
|
||||
// If we get here, we already know that the lines origin is not included
|
||||
// in the plane. Thus if we have a zero denominator we have
|
||||
// a line paralell to the plane. That is no intersection.
|
||||
if (fabs(den) <= SGLimits<T>::min())
|
||||
return false;
|
||||
|
||||
// We would now compute \alpha = num/den and compare with 0 and 1.
|
||||
// But to avoid that expensive division, compare equations
|
||||
// multiplied by |den|. Note that copysign is usually a compiler intrinsic
|
||||
// that expands in assembler code that not even stalls the cpus pipes.
|
||||
T alphaDen = copysign(1, den)*num;
|
||||
if (alphaDen < 0)
|
||||
return false;
|
||||
if (den < alphaDen)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGPlane<T>& plane, const SGLineSegment<T>& lineSegment)
|
||||
{ return intersects(lineSegment, plane); }
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(SGVec3<T>& dst, const SGLineSegment<T>& lineSegment, const SGPlane<T>& plane)
|
||||
{
|
||||
// We compute the intersection point
|
||||
// x = origin + \alpha*direction
|
||||
// from the line segments origin and non nomalized direction.
|
||||
// For 0 <= \alpha <= 1 the line segment intersects the infinite plane.
|
||||
// The intersection point x can also be written
|
||||
// x = n*dist + y
|
||||
// where n is the planes normal, dist is the distance of the plane from
|
||||
// the origin in normal direction and y is an aproriate vector
|
||||
// perpendicular to n.
|
||||
// Equate the x values and take the scalar product with the plane normal n.
|
||||
// dot(n, origin) + \alpha*dot(n, direction) = dist
|
||||
// We can now compute alpha from the above equation.
|
||||
// \alpha = (dist - dot(n, origin))/dot(n, direction)
|
||||
|
||||
// The negative numerator for the \alpha expression
|
||||
T num = plane.getPositiveDist();
|
||||
num -= dot(plane.getNormal(), lineSegment.getOrigin());
|
||||
|
||||
// If the numerator is zero, we have the lines origin included in the plane
|
||||
if (fabs(num) <= SGLimits<T>::min()) {
|
||||
dst = lineSegment.getOrigin();
|
||||
return true;
|
||||
}
|
||||
|
||||
// The denominator for the \alpha expression
|
||||
T den = dot(plane.getNormal(), lineSegment.getDirection());
|
||||
|
||||
// If we get here, we already know that the lines origin is not included
|
||||
// in the plane. Thus if we have a zero denominator we have
|
||||
// a line paralell to the plane. That is: no intersection.
|
||||
if (fabs(den) <= SGLimits<T>::min())
|
||||
return false;
|
||||
|
||||
// We would now compute \alpha = num/den and compare with 0 and 1.
|
||||
// But to avoid that expensive division, check equation multiplied by
|
||||
// the denominator. FIXME: shall we do so? or compute like that?
|
||||
T alpha = num/den;
|
||||
if (alpha < 0)
|
||||
return false;
|
||||
if (1 < alpha)
|
||||
return false;
|
||||
|
||||
dst = lineSegment.getOrigin() + alpha*lineSegment.getDirection();
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(SGVec3<T>& dst, const SGPlane<T>& plane, const SGLineSegment<T>& lineSegment)
|
||||
{ return intersects(dst, lineSegment, plane); }
|
||||
|
||||
|
||||
// Distance of a line segment to a point
|
||||
template<typename T>
|
||||
inline T
|
||||
distSqr(const SGLineSegment<T>& lineSeg, const SGVec3<T>& p)
|
||||
{
|
||||
SGVec3<T> ps = p - lineSeg.getStart();
|
||||
|
||||
T psdotdir = dot(ps, lineSeg.getDirection());
|
||||
if (psdotdir <= 0)
|
||||
return dot(ps, ps);
|
||||
|
||||
SGVec3<T> pe = p - lineSeg.getEnd();
|
||||
if (0 <= dot(pe, lineSeg.getDirection()))
|
||||
return dot(pe, pe);
|
||||
|
||||
return dot(ps, ps) - psdotdir*psdotdir/dot(lineSeg.getDirection(), lineSeg.getDirection());
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline T
|
||||
distSqr(const SGVec3<T>& p, const SGLineSegment<T>& lineSeg)
|
||||
{ return distSqr(lineSeg, p); }
|
||||
// with sqrt
|
||||
template<typename T>
|
||||
inline T
|
||||
dist(const SGVec3<T>& p, const SGLineSegment<T>& lineSeg)
|
||||
{ return sqrt(distSqr(lineSeg, p)); }
|
||||
template<typename T>
|
||||
inline T
|
||||
dist(const SGLineSegment<T>& lineSeg, const SGVec3<T>& p)
|
||||
{ return sqrt(distSqr(lineSeg, p)); }
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGRay<T>& ray, const SGSphere<T>& sphere)
|
||||
{
|
||||
// See Tomas Akeniene - Moeller/Eric Haines: Real Time Rendering,
|
||||
// second edition, page 571
|
||||
SGVec3<T> l = sphere.getCenter() - ray.getOrigin();
|
||||
T s = dot(l, ray.getDirection());
|
||||
T l2 = dot(l, l);
|
||||
|
||||
T r2 = sphere.getRadius2();
|
||||
if (s < 0 && l2 > r2)
|
||||
return false;
|
||||
|
||||
T d2 = dot(ray.getDirection(), ray.getDirection());
|
||||
// The original test would read
|
||||
// T m2 = l2 - s*s/d2;
|
||||
// if (m2 > r2)
|
||||
// return false;
|
||||
// but to avoid the expensive division, we multiply by d2
|
||||
T m2 = d2*l2 - s*s;
|
||||
if (m2 > d2*r2)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGSphere<T>& sphere, const SGRay<T>& ray)
|
||||
{ return intersects(ray, sphere); }
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGLineSegment<T>& lineSegment, const SGSphere<T>& sphere)
|
||||
{
|
||||
// See Tomas Akeniene - Moeller/Eric Haines: Real Time Rendering,
|
||||
// second edition, page 571
|
||||
SGVec3<T> l = sphere.getCenter() - lineSegment.getStart();
|
||||
T ld = length(lineSegment.getDirection());
|
||||
T s = dot(l, lineSegment.getDirection())/ld;
|
||||
T l2 = dot(l, l);
|
||||
|
||||
T r2 = sphere.getRadius2();
|
||||
if (s < 0 && l2 > r2)
|
||||
return false;
|
||||
|
||||
T m2 = l2 - s*s;
|
||||
if (m2 > r2)
|
||||
return false;
|
||||
|
||||
T q = sqrt(r2 - m2);
|
||||
T t = s - q;
|
||||
if (ld < t)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGSphere<T>& sphere, const SGLineSegment<T>& lineSegment)
|
||||
{ return intersects(lineSegment, sphere); }
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
// FIXME do not use that default argument later. Just for development now
|
||||
intersects(SGVec3<T>& x, const SGTriangle<T>& tri, const SGRay<T>& ray, T eps = 0)
|
||||
{
|
||||
// See Tomas Akeniene - Moeller/Eric Haines: Real Time Rendering
|
||||
|
||||
// Method based on the observation that we are looking for a
|
||||
// point x that can be expressed in terms of the triangle points
|
||||
// x = v_0 + u*(v_1 - v_0) + v*(v_2 - v_0)
|
||||
// with 0 <= u, v and u + v <= 1.
|
||||
// OTOH it could be expressed in terms of the ray
|
||||
// x = o + t*d
|
||||
// Now we can compute u, v and t.
|
||||
SGVec3<T> p = cross(ray.getDirection(), tri.getEdge(1));
|
||||
|
||||
T denom = dot(p, tri.getEdge(0));
|
||||
T signDenom = copysign(1, denom);
|
||||
|
||||
SGVec3<T> s = ray.getOrigin() - tri.getBaseVertex();
|
||||
SGVec3<T> q = cross(s, tri.getEdge(0));
|
||||
// Now t would read
|
||||
// t = 1/denom*dot(q, tri.getEdge(1));
|
||||
// To avoid an expensive division we multiply by |denom|
|
||||
T tDenom = signDenom*dot(q, tri.getEdge(1));
|
||||
if (tDenom < 0)
|
||||
return false;
|
||||
// For line segment we would test against
|
||||
// if (1 < t)
|
||||
// return false;
|
||||
// with the original t. The multiplied test would read
|
||||
// if (absDenom < tDenom)
|
||||
// return false;
|
||||
|
||||
T absDenom = fabs(denom);
|
||||
T absDenomEps = absDenom*eps;
|
||||
|
||||
// T u = 1/denom*dot(p, s);
|
||||
T u = signDenom*dot(p, s);
|
||||
if (u < -absDenomEps)
|
||||
return false;
|
||||
// T v = 1/denom*dot(q, d);
|
||||
// if (v < -eps)
|
||||
// return false;
|
||||
T v = signDenom*dot(q, ray.getDirection());
|
||||
if (v < -absDenomEps)
|
||||
return false;
|
||||
|
||||
if (u + v > absDenom + absDenomEps)
|
||||
return false;
|
||||
|
||||
// return if paralell ??? FIXME what if paralell and in plane?
|
||||
// may be we are ok below than anyway??
|
||||
if (absDenom <= SGLimits<T>::min())
|
||||
return false;
|
||||
|
||||
x = ray.getOrigin();
|
||||
// if we have survived here it could only happen with denom == 0
|
||||
// that the point is already in plane. Then return the origin ...
|
||||
if (SGLimitsd::min() < absDenom)
|
||||
x += (tDenom/absDenom)*ray.getDirection();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGTriangle<T>& tri, const SGRay<T>& ray, T eps = 0)
|
||||
{
|
||||
// FIXME: for now just wrap the other method. When that has prooven
|
||||
// well optimized, implement that special case
|
||||
SGVec3<T> dummy;
|
||||
return intersects(dummy, tri, ray, eps);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
// FIXME do not use that default argument later. Just for development now
|
||||
intersects(SGVec3<T>& x, const SGTriangle<T>& tri, const SGLineSegment<T>& lineSegment, T eps = 0)
|
||||
{
|
||||
// See Tomas Akeniene - Moeller/Eric Haines: Real Time Rendering
|
||||
|
||||
// Method based on the observation that we are looking for a
|
||||
// point x that can be expressed in terms of the triangle points
|
||||
// x = v_0 + u*(v_1 - v_0) + v*(v_2 - v_0)
|
||||
// with 0 <= u, v and u + v <= 1.
|
||||
// OTOH it could be expressed in terms of the lineSegment
|
||||
// x = o + t*d
|
||||
// Now we can compute u, v and t.
|
||||
SGVec3<T> p = cross(lineSegment.getDirection(), tri.getEdge(1));
|
||||
|
||||
T denom = dot(p, tri.getEdge(0));
|
||||
T signDenom = copysign(1, denom);
|
||||
|
||||
SGVec3<T> s = lineSegment.getStart() - tri.getBaseVertex();
|
||||
SGVec3<T> q = cross(s, tri.getEdge(0));
|
||||
// Now t would read
|
||||
// t = 1/denom*dot(q, tri.getEdge(1));
|
||||
// To avoid an expensive division we multiply by |denom|
|
||||
T tDenom = signDenom*dot(q, tri.getEdge(1));
|
||||
if (tDenom < 0)
|
||||
return false;
|
||||
// For line segment we would test against
|
||||
// if (1 < t)
|
||||
// return false;
|
||||
// with the original t. The multiplied test reads
|
||||
T absDenom = fabs(denom);
|
||||
if (absDenom < tDenom)
|
||||
return false;
|
||||
|
||||
// take the CPU accuracy in account
|
||||
T absDenomEps = absDenom*eps;
|
||||
|
||||
// T u = 1/denom*dot(p, s);
|
||||
T u = signDenom*dot(p, s);
|
||||
if (u < -absDenomEps)
|
||||
return false;
|
||||
// T v = 1/denom*dot(q, d);
|
||||
// if (v < -eps)
|
||||
// return false;
|
||||
T v = signDenom*dot(q, lineSegment.getDirection());
|
||||
if (v < -absDenomEps)
|
||||
return false;
|
||||
|
||||
if (u + v > absDenom + absDenomEps)
|
||||
return false;
|
||||
|
||||
// return if paralell ??? FIXME what if paralell and in plane?
|
||||
// may be we are ok below than anyway??
|
||||
if (absDenom <= SGLimits<T>::min())
|
||||
return false;
|
||||
|
||||
x = lineSegment.getStart();
|
||||
// if we have survived here it could only happen with denom == 0
|
||||
// that the point is already in plane. Then return the origin ...
|
||||
if (SGLimitsd::min() < absDenom)
|
||||
x += (tDenom/absDenom)*lineSegment.getDirection();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGTriangle<T>& tri, const SGLineSegment<T>& lineSegment, T eps = 0)
|
||||
{
|
||||
// FIXME: for now just wrap the othr method. When that has prooven
|
||||
// well optimized, implement that special case
|
||||
SGVec3<T> dummy;
|
||||
return intersects(dummy, tri, lineSegment, eps);
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGVec3<T>& v, const SGSphere<T>& sphere)
|
||||
{
|
||||
if (sphere.empty())
|
||||
return false;
|
||||
return distSqr(v, sphere.getCenter()) <= sphere.getRadius2();
|
||||
}
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGSphere<T>& sphere, const SGVec3<T>& v)
|
||||
{ return intersects(v, sphere); }
|
||||
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGBox<T>& box, const SGLineSegment<T>& lineSegment)
|
||||
{
|
||||
// See Tomas Akeniene - Moeller/Eric Haines: Real Time Rendering
|
||||
|
||||
SGVec3<T> c = lineSegment.getCenter() - box.getCenter();
|
||||
SGVec3<T> w = 0.5*lineSegment.getDirection();
|
||||
SGVec3<T> v(fabs(w.x()), fabs(w.y()), fabs(w.z()));
|
||||
SGVec3<T> h = 0.5*box.getSize();
|
||||
|
||||
if (fabs(c[0]) > v[0] + h[0])
|
||||
return false;
|
||||
if (fabs(c[1]) > v[1] + h[1])
|
||||
return false;
|
||||
if (fabs(c[2]) > v[2] + h[2])
|
||||
return false;
|
||||
|
||||
if (fabs(c[1]*w[2] - c[2]*w[1]) > h[1]*v[2] + h[2]*v[1])
|
||||
return false;
|
||||
if (fabs(c[0]*w[2] - c[2]*w[0]) > h[0]*v[2] + h[2]*v[0])
|
||||
return false;
|
||||
if (fabs(c[0]*w[1] - c[1]*w[0]) > h[0]*v[1] + h[1]*v[0])
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGLineSegment<T>& lineSegment, const SGBox<T>& box)
|
||||
{ return intersects(box, lineSegment); }
|
||||
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGBox<T>& box, const SGRay<T>& ray)
|
||||
{
|
||||
// See Tomas Akeniene - Moeller/Eric Haines: Real Time Rendering
|
||||
|
||||
for (unsigned i = 0; i < 3; ++i) {
|
||||
T cMin = box.getMin()[i];
|
||||
T cMax = box.getMax()[i];
|
||||
|
||||
T cOrigin = ray.getOrigin()[i];
|
||||
|
||||
T cDir = ray.getDirection()[i];
|
||||
if (fabs(cDir) <= SGLimits<T>::min()) {
|
||||
if (cOrigin < cMin)
|
||||
return false;
|
||||
if (cMax < cOrigin)
|
||||
return false;
|
||||
}
|
||||
|
||||
T nearr = - SGLimits<T>::max();
|
||||
T farr = SGLimits<T>::max();
|
||||
|
||||
T T1 = (cMin - cOrigin) / cDir;
|
||||
T T2 = (cMax - cOrigin) / cDir;
|
||||
if (T1 > T2) std::swap (T1, T2);/* since T1 intersection with near plane */
|
||||
if (T1 > nearr) nearr = T1; /* want largest Tnear */
|
||||
if (T2 < farr) farr = T2; /* want smallest Tfarr */
|
||||
if (nearr > farr) // farr box is missed
|
||||
return false;
|
||||
if (farr < 0) // box is behind ray
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
// make it symmetric
|
||||
template<typename T>
|
||||
inline bool
|
||||
intersects(const SGRay<T>& ray, const SGBox<T>& box)
|
||||
{ return intersects(box, ray); }
|
||||
|
||||
#endif
|
||||
29
simgear/math/SGLimits.hxx
Normal file
29
simgear/math/SGLimits.hxx
Normal file
@@ -0,0 +1,29 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGLimits_H
|
||||
#define SGLimits_H
|
||||
|
||||
#include <limits>
|
||||
|
||||
/// Helper class for epsilon and so on
|
||||
/// This is the possible place to hook in for machines not
|
||||
/// providing numeric_limits ...
|
||||
template<typename T>
|
||||
class SGLimits : public std::numeric_limits<T> {};
|
||||
|
||||
#endif
|
||||
62
simgear/math/SGLineSegment.hxx
Normal file
62
simgear/math/SGLineSegment.hxx
Normal file
@@ -0,0 +1,62 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGLineSegment_H
|
||||
#define SGLineSegment_H
|
||||
|
||||
template<typename T>
|
||||
class SGLineSegment {
|
||||
public:
|
||||
SGLineSegment()
|
||||
{ }
|
||||
SGLineSegment(const SGVec3<T>& start, const SGVec3<T>& end) :
|
||||
_start(start),
|
||||
_direction(end - start)
|
||||
{ }
|
||||
|
||||
void set(const SGVec3<T>& start, const SGVec3<T>& end)
|
||||
{ _start = start; _direction = end - start; }
|
||||
|
||||
const SGVec3<T>& getStart() const
|
||||
{ return _start; }
|
||||
SGVec3<T> getEnd() const
|
||||
{ return _start + _direction; }
|
||||
const SGVec3<T>& getDirection() const
|
||||
{ return _direction; }
|
||||
SGVec3<T> getNormalizedDirection() const
|
||||
{ return normalize(getDirection()); }
|
||||
|
||||
SGVec3<T> getCenter() const
|
||||
{ return _start + T(0.5)*_direction; }
|
||||
|
||||
private:
|
||||
SGVec3<T> _start;
|
||||
SGVec3<T> _direction;
|
||||
};
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s,
|
||||
const SGLineSegment<T>& lineSegment)
|
||||
{
|
||||
return s << "line segment: start = " << lineSegment.getStart()
|
||||
<< ", end = " << lineSegment.getEnd();
|
||||
}
|
||||
|
||||
#endif
|
||||
44
simgear/math/SGMath.hxx
Normal file
44
simgear/math/SGMath.hxx
Normal file
@@ -0,0 +1,44 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGMath_H
|
||||
#define SGMath_H
|
||||
|
||||
/// Just include them all
|
||||
|
||||
#include <iosfwd>
|
||||
// FIXME, make it compile on IRIX
|
||||
#include <osg/GL>
|
||||
#undef GLUT_APIENTRY_DEFINED // GL/glut.h undef APIENTRY when this symbol is defined. osg/GL defines it (?).
|
||||
// This probably would work if we didn't use plib/pu.h that include GL/glut.h
|
||||
// on its side.
|
||||
|
||||
#include "SGMathFwd.hxx"
|
||||
|
||||
#include "SGCMath.hxx"
|
||||
#include "SGLimits.hxx"
|
||||
#include "SGMisc.hxx"
|
||||
#include "SGGeodesy.hxx"
|
||||
#include "SGVec2.hxx"
|
||||
#include "SGVec3.hxx"
|
||||
#include "SGVec4.hxx"
|
||||
#include "SGGeoc.hxx"
|
||||
#include "SGGeod.hxx"
|
||||
#include "SGQuat.hxx"
|
||||
#include "SGMatrix.hxx"
|
||||
|
||||
#endif
|
||||
56
simgear/math/SGMathFwd.hxx
Normal file
56
simgear/math/SGMathFwd.hxx
Normal file
@@ -0,0 +1,56 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGMathFwd_H
|
||||
#define SGMathFwd_H
|
||||
|
||||
// All forward declarations in case they only need to be declared
|
||||
|
||||
class SGGeoc;
|
||||
class SGGeod;
|
||||
|
||||
template<typename T>
|
||||
class SGLimits;
|
||||
template<typename T>
|
||||
class SGMatrix;
|
||||
template<typename T>
|
||||
class SGMisc;
|
||||
template<typename T>
|
||||
class SGQuat;
|
||||
template<typename T>
|
||||
class SGVec2;
|
||||
template<typename T>
|
||||
class SGVec3;
|
||||
template<typename T>
|
||||
class SGVec4;
|
||||
|
||||
typedef SGLimits<float> SGLimitsf;
|
||||
typedef SGLimits<double> SGLimitsd;
|
||||
typedef SGMatrix<float> SGMatrixf;
|
||||
typedef SGMatrix<double> SGMatrixd;
|
||||
typedef SGMisc<float> SGMiscf;
|
||||
typedef SGMisc<double> SGMiscd;
|
||||
typedef SGQuat<float> SGQuatf;
|
||||
typedef SGQuat<double> SGQuatd;
|
||||
typedef SGVec2<float> SGVec2f;
|
||||
typedef SGVec2<double> SGVec2d;
|
||||
typedef SGVec3<float> SGVec3f;
|
||||
typedef SGVec3<double> SGVec3d;
|
||||
typedef SGVec4<float> SGVec4f;
|
||||
typedef SGVec4<double> SGVec4d;
|
||||
|
||||
#endif
|
||||
366
simgear/math/SGMathTest.cxx
Normal file
366
simgear/math/SGMathTest.cxx
Normal file
@@ -0,0 +1,366 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <simgear_config.h>
|
||||
#endif
|
||||
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include <plib/sg.h>
|
||||
|
||||
#include "SGMath.hxx"
|
||||
|
||||
template<typename T>
|
||||
bool
|
||||
Vec3Test(void)
|
||||
{
|
||||
SGVec3<T> v1, v2, v3;
|
||||
|
||||
// Check if the equivalent function works
|
||||
v1 = SGVec3<T>(1, 2, 3);
|
||||
v2 = SGVec3<T>(3, 2, 1);
|
||||
if (equivalent(v1, v2))
|
||||
return false;
|
||||
|
||||
// Check the unary minus operator
|
||||
v3 = SGVec3<T>(-1, -2, -3);
|
||||
if (!equivalent(-v1, v3))
|
||||
return false;
|
||||
|
||||
// Check the unary plus operator
|
||||
v3 = SGVec3<T>(1, 2, 3);
|
||||
if (!equivalent(+v1, v3))
|
||||
return false;
|
||||
|
||||
// Check the addition operator
|
||||
v3 = SGVec3<T>(4, 4, 4);
|
||||
if (!equivalent(v1 + v2, v3))
|
||||
return false;
|
||||
|
||||
// Check the subtraction operator
|
||||
v3 = SGVec3<T>(-2, 0, 2);
|
||||
if (!equivalent(v1 - v2, v3))
|
||||
return false;
|
||||
|
||||
// Check the scaler multiplication operator
|
||||
v3 = SGVec3<T>(2, 4, 6);
|
||||
if (!equivalent(2*v1, v3))
|
||||
return false;
|
||||
|
||||
// Check the dot product
|
||||
if (fabs(dot(v1, v2) - 10) > 10*SGLimits<T>::epsilon())
|
||||
return false;
|
||||
|
||||
// Check the cross product
|
||||
v3 = SGVec3<T>(-4, 8, -4);
|
||||
if (!equivalent(cross(v1, v2), v3))
|
||||
return false;
|
||||
|
||||
// Check the euclidean length
|
||||
if (fabs(14 - length(v1)*length(v1)) > 14*SGLimits<T>::epsilon())
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool
|
||||
QuatTest(void)
|
||||
{
|
||||
const SGVec3<T> e1(1, 0, 0);
|
||||
const SGVec3<T> e2(0, 1, 0);
|
||||
const SGVec3<T> e3(0, 0, 1);
|
||||
SGVec3<T> v1, v2;
|
||||
SGQuat<T> q1, q2, q3, q4;
|
||||
// Check a rotation around the x axis
|
||||
q1 = SGQuat<T>::fromAngleAxis(SGMisc<T>::pi(), e1);
|
||||
v1 = SGVec3<T>(1, 2, 3);
|
||||
v2 = SGVec3<T>(1, -2, -3);
|
||||
if (!equivalent(q1.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
// Check a rotation around the x axis
|
||||
q1 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e1);
|
||||
v2 = SGVec3<T>(1, 3, -2);
|
||||
if (!equivalent(q1.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
// Check a rotation around the y axis
|
||||
q1 = SGQuat<T>::fromAngleAxis(SGMisc<T>::pi(), e2);
|
||||
v2 = SGVec3<T>(-1, 2, -3);
|
||||
if (!equivalent(q1.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
// Check a rotation around the y axis
|
||||
q1 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e2);
|
||||
v2 = SGVec3<T>(-3, 2, 1);
|
||||
if (!equivalent(q1.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
// Check a rotation around the z axis
|
||||
q1 = SGQuat<T>::fromAngleAxis(SGMisc<T>::pi(), e3);
|
||||
v2 = SGVec3<T>(-1, -2, 3);
|
||||
if (!equivalent(q1.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
// Check a rotation around the z axis
|
||||
q1 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e3);
|
||||
v2 = SGVec3<T>(2, -1, 3);
|
||||
if (!equivalent(q1.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
// Now check some successive transforms
|
||||
// We can reuse the prevously tested stuff
|
||||
q1 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e1);
|
||||
q2 = SGQuat<T>::fromAngleAxis(0.5*SGMisc<T>::pi(), e2);
|
||||
q3 = q1*q2;
|
||||
v2 = q2.transform(q1.transform(v1));
|
||||
if (!equivalent(q3.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
/// Test from Euler angles
|
||||
float x = 0.2*SGMisc<T>::pi();
|
||||
float y = 0.3*SGMisc<T>::pi();
|
||||
float z = 0.4*SGMisc<T>::pi();
|
||||
q1 = SGQuat<T>::fromAngleAxis(z, e3);
|
||||
q2 = SGQuat<T>::fromAngleAxis(y, e2);
|
||||
q3 = SGQuat<T>::fromAngleAxis(x, e1);
|
||||
v2 = q3.transform(q2.transform(q1.transform(v1)));
|
||||
q4 = SGQuat<T>::fromEulerRad(z, y, x);
|
||||
if (!equivalent(q4.transform(v1), v2))
|
||||
return false;
|
||||
|
||||
/// Test angle axis forward and back transform
|
||||
q1 = SGQuat<T>::fromAngleAxis(0.2*SGMisc<T>::pi(), e1);
|
||||
q2 = SGQuat<T>::fromAngleAxis(0.7*SGMisc<T>::pi(), e2);
|
||||
q3 = q1*q2;
|
||||
SGVec3<T> angleAxis;
|
||||
q1.getAngleAxis(angleAxis);
|
||||
q4 = SGQuat<T>::fromAngleAxis(angleAxis);
|
||||
if (!equivalent(q1, q4))
|
||||
return false;
|
||||
q2.getAngleAxis(angleAxis);
|
||||
q4 = SGQuat<T>::fromAngleAxis(angleAxis);
|
||||
if (!equivalent(q2, q4))
|
||||
return false;
|
||||
q3.getAngleAxis(angleAxis);
|
||||
q4 = SGQuat<T>::fromAngleAxis(angleAxis);
|
||||
if (!equivalent(q3, q4))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool
|
||||
MatrixTest(void)
|
||||
{
|
||||
// Create some test matrix
|
||||
SGVec3<T> v0(2, 7, 17);
|
||||
SGQuat<T> q0 = SGQuat<T>::fromAngleAxis(SGMisc<T>::pi(), normalize(v0));
|
||||
SGMatrix<T> m0;
|
||||
m0.postMultTranslate(v0);
|
||||
m0.postMultRotate(q0);
|
||||
|
||||
// Check the tqo forms of the inverse for that kind of special matrix
|
||||
SGMatrix<T> m1, m2;
|
||||
invert(m1, m0);
|
||||
m2 = transNeg(m0);
|
||||
if (!equivalent(m1, m2))
|
||||
return false;
|
||||
|
||||
// Check matrix multiplication and inversion
|
||||
if (!equivalent(m0*m1, SGMatrix<T>::unit()))
|
||||
return false;
|
||||
if (!equivalent(m1*m0, SGMatrix<T>::unit()))
|
||||
return false;
|
||||
if (!equivalent(m0*m2, SGMatrix<T>::unit()))
|
||||
return false;
|
||||
if (!equivalent(m2*m0, SGMatrix<T>::unit()))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
GeodesyTest(void)
|
||||
{
|
||||
// We know that the values are on the order of 1
|
||||
double epsDeg = 10*SGLimits<double>::epsilon();
|
||||
// For the altitude values we need to tolerate relative errors in the order
|
||||
// of the radius
|
||||
double epsM = 1e6*SGLimits<double>::epsilon();
|
||||
|
||||
SGVec3<double> cart0, cart1;
|
||||
SGGeod geod0, geod1;
|
||||
SGGeoc geoc0;
|
||||
|
||||
// create some geodetic position
|
||||
geod0 = SGGeod::fromDegM(30, 20, 17);
|
||||
|
||||
// Test the conversion routines to cartesian coordinates
|
||||
cart0 = SGVec3<double>::fromGeod(geod0);
|
||||
geod1 = SGGeod::fromCart(cart0);
|
||||
if (epsDeg < fabs(geod0.getLongitudeDeg() - geod1.getLongitudeDeg()) ||
|
||||
epsDeg < fabs(geod0.getLatitudeDeg() - geod1.getLatitudeDeg()) ||
|
||||
epsM < fabs(geod0.getElevationM() - geod1.getElevationM()))
|
||||
return false;
|
||||
|
||||
// Test the conversion routines to radial coordinates
|
||||
geoc0 = SGGeoc::fromCart(cart0);
|
||||
cart1 = SGVec3<double>::fromGeoc(geoc0);
|
||||
if (!equivalent(cart0, cart1))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
sgInterfaceTest(void)
|
||||
{
|
||||
SGVec3f v3f = SGVec3f::e2();
|
||||
SGVec4f v4f = SGVec4f::e2();
|
||||
SGQuatf qf = SGQuatf::fromEulerRad(1.2, 1.3, -0.4);
|
||||
SGMatrixf mf;
|
||||
mf.postMultTranslate(v3f);
|
||||
mf.postMultRotate(qf);
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGVec3f tv3f;
|
||||
sgVec3 sv3f;
|
||||
sgCopyVec3(sv3f, v3f.sg());
|
||||
sgCopyVec3(tv3f.sg(), sv3f);
|
||||
if (tv3f != v3f)
|
||||
return false;
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGVec4f tv4f;
|
||||
sgVec4 sv4f;
|
||||
sgCopyVec4(sv4f, v4f.sg());
|
||||
sgCopyVec4(tv4f.sg(), sv4f);
|
||||
if (tv4f != v4f)
|
||||
return false;
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGQuatf tqf;
|
||||
sgQuat sqf;
|
||||
sgCopyQuat(sqf, qf.sg());
|
||||
sgCopyQuat(tqf.sg(), sqf);
|
||||
if (tqf != qf)
|
||||
return false;
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGMatrixf tmf;
|
||||
sgMat4 smf;
|
||||
sgCopyMat4(smf, mf.sg());
|
||||
sgCopyMat4(tmf.sg(), smf);
|
||||
if (tmf != mf)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
sgdInterfaceTest(void)
|
||||
{
|
||||
SGVec3d v3d = SGVec3d::e2();
|
||||
SGVec4d v4d = SGVec4d::e2();
|
||||
SGQuatd qd = SGQuatd::fromEulerRad(1.2, 1.3, -0.4);
|
||||
SGMatrixd md;
|
||||
md.postMultTranslate(v3d);
|
||||
md.postMultRotate(qd);
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGVec3d tv3d;
|
||||
sgdVec3 sv3d;
|
||||
sgdCopyVec3(sv3d, v3d.sg());
|
||||
sgdCopyVec3(tv3d.sg(), sv3d);
|
||||
if (tv3d != v3d)
|
||||
return false;
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGVec4d tv4d;
|
||||
sgdVec4 sv4d;
|
||||
sgdCopyVec4(sv4d, v4d.sg());
|
||||
sgdCopyVec4(tv4d.sg(), sv4d);
|
||||
if (tv4d != v4d)
|
||||
return false;
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGQuatd tqd;
|
||||
sgdQuat sqd;
|
||||
sgdCopyQuat(sqd, qd.sg());
|
||||
sgdCopyQuat(tqd.sg(), sqd);
|
||||
if (tqd != qd)
|
||||
return false;
|
||||
|
||||
// Copy to and from plibs types check if result is equal,
|
||||
// test for exact equality
|
||||
SGMatrixd tmd;
|
||||
sgdMat4 smd;
|
||||
sgdCopyMat4(smd, md.sg());
|
||||
sgdCopyMat4(tmd.sg(), smd);
|
||||
if (tmd != md)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
// Do vector tests
|
||||
if (!Vec3Test<float>())
|
||||
return EXIT_FAILURE;
|
||||
if (!Vec3Test<double>())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
// Do quaternion tests
|
||||
if (!QuatTest<float>())
|
||||
return EXIT_FAILURE;
|
||||
if (!QuatTest<double>())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
// Do matrix tests
|
||||
if (!MatrixTest<float>())
|
||||
return EXIT_FAILURE;
|
||||
if (!MatrixTest<double>())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
// Check geodetic/geocentric/cartesian conversions
|
||||
if (!GeodesyTest())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
// Check interaction with sg*/sgd*
|
||||
if (!sgInterfaceTest())
|
||||
return EXIT_FAILURE;
|
||||
if (!sgdInterfaceTest())
|
||||
return EXIT_FAILURE;
|
||||
|
||||
std::cout << "Successfully passed all tests!" << std::endl;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
612
simgear/math/SGMatrix.hxx
Normal file
612
simgear/math/SGMatrix.hxx
Normal file
@@ -0,0 +1,612 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGMatrix_H
|
||||
#define SGMatrix_H
|
||||
|
||||
/// Expression templates for poor programmers ... :)
|
||||
template<typename T>
|
||||
struct TransNegRef;
|
||||
|
||||
/// 3D Matrix Class
|
||||
template<typename T>
|
||||
class SGMatrix {
|
||||
public:
|
||||
enum { nCols = 4, nRows = 4, nEnts = 16 };
|
||||
typedef T value_type;
|
||||
|
||||
/// Default constructor. Does not initialize at all.
|
||||
/// If you need them zero initialized, use SGMatrix::zeros()
|
||||
SGMatrix(void)
|
||||
{
|
||||
/// Initialize with nans in the debug build, that will guarantee to have
|
||||
/// a fast uninitialized default constructor in the release but shows up
|
||||
/// uninitialized values in the debug build very fast ...
|
||||
#ifndef NDEBUG
|
||||
for (unsigned i = 0; i < nEnts; ++i)
|
||||
_data.flat[i] = SGLimits<T>::quiet_NaN();
|
||||
#endif
|
||||
}
|
||||
/// Constructor. Initialize by the content of a plain array,
|
||||
/// make sure it has at least 16 elements
|
||||
explicit SGMatrix(const T* data)
|
||||
{ for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] = data[i]; }
|
||||
|
||||
/// Constructor, build up a SGMatrix from given elements
|
||||
SGMatrix(T m00, T m01, T m02, T m03,
|
||||
T m10, T m11, T m12, T m13,
|
||||
T m20, T m21, T m22, T m23,
|
||||
T m30, T m31, T m32, T m33)
|
||||
{
|
||||
_data.flat[0] = m00; _data.flat[1] = m10;
|
||||
_data.flat[2] = m20; _data.flat[3] = m30;
|
||||
_data.flat[4] = m01; _data.flat[5] = m11;
|
||||
_data.flat[6] = m21; _data.flat[7] = m31;
|
||||
_data.flat[8] = m02; _data.flat[9] = m12;
|
||||
_data.flat[10] = m22; _data.flat[11] = m32;
|
||||
_data.flat[12] = m03; _data.flat[13] = m13;
|
||||
_data.flat[14] = m23; _data.flat[15] = m33;
|
||||
}
|
||||
|
||||
/// Constructor, build up a SGMatrix from a translation
|
||||
template<typename S>
|
||||
SGMatrix(const SGVec3<S>& trans)
|
||||
{ set(trans); }
|
||||
|
||||
/// Constructor, build up a SGMatrix from a rotation and a translation
|
||||
template<typename S>
|
||||
SGMatrix(const SGQuat<S>& quat)
|
||||
{ set(quat); }
|
||||
|
||||
/// Copy constructor for a transposed negated matrix
|
||||
SGMatrix(const TransNegRef<T>& tm)
|
||||
{ set(tm); }
|
||||
|
||||
/// Set from a tranlation
|
||||
template<typename S>
|
||||
void set(const SGVec3<S>& trans)
|
||||
{
|
||||
_data.flat[0] = 1; _data.flat[4] = 0;
|
||||
_data.flat[8] = 0; _data.flat[12] = T(trans(0));
|
||||
_data.flat[1] = 0; _data.flat[5] = 1;
|
||||
_data.flat[9] = 0; _data.flat[13] = T(trans(1));
|
||||
_data.flat[2] = 0; _data.flat[6] = 0;
|
||||
_data.flat[10] = 1; _data.flat[14] = T(trans(2));
|
||||
_data.flat[3] = 0; _data.flat[7] = 0;
|
||||
_data.flat[11] = 0; _data.flat[15] = 1;
|
||||
}
|
||||
|
||||
/// Set from a scale/rotation and tranlation
|
||||
template<typename S>
|
||||
void set(const SGQuat<S>& quat)
|
||||
{
|
||||
T w = quat.w(); T x = quat.x(); T y = quat.y(); T z = quat.z();
|
||||
T xx = x*x; T yy = y*y; T zz = z*z;
|
||||
T wx = w*x; T wy = w*y; T wz = w*z;
|
||||
T xy = x*y; T xz = x*z; T yz = y*z;
|
||||
_data.flat[0] = 1-2*(yy+zz); _data.flat[1] = 2*(xy-wz);
|
||||
_data.flat[2] = 2*(xz+wy); _data.flat[3] = 0;
|
||||
_data.flat[4] = 2*(xy+wz); _data.flat[5] = 1-2*(xx+zz);
|
||||
_data.flat[6] = 2*(yz-wx); _data.flat[7] = 0;
|
||||
_data.flat[8] = 2*(xz-wy); _data.flat[9] = 2*(yz+wx);
|
||||
_data.flat[10] = 1-2*(xx+yy); _data.flat[11] = 0;
|
||||
_data.flat[12] = 0; _data.flat[13] = 0;
|
||||
_data.flat[14] = 0; _data.flat[15] = 1;
|
||||
}
|
||||
|
||||
/// set from a transposed negated matrix
|
||||
void set(const TransNegRef<T>& tm)
|
||||
{
|
||||
const SGMatrix& m = tm.m;
|
||||
_data.flat[0] = m(0,0);
|
||||
_data.flat[1] = m(0,1);
|
||||
_data.flat[2] = m(0,2);
|
||||
_data.flat[3] = m(3,0);
|
||||
|
||||
_data.flat[4] = m(1,0);
|
||||
_data.flat[5] = m(1,1);
|
||||
_data.flat[6] = m(1,2);
|
||||
_data.flat[7] = m(3,1);
|
||||
|
||||
_data.flat[8] = m(2,0);
|
||||
_data.flat[9] = m(2,1);
|
||||
_data.flat[10] = m(2,2);
|
||||
_data.flat[11] = m(3,2);
|
||||
|
||||
// Well, this one is ugly here, as that xform method on the current
|
||||
// object needs the above data to be already set ...
|
||||
SGVec3<T> t = xformVec(SGVec3<T>(m(0,3), m(1,3), m(2,3)));
|
||||
_data.flat[12] = -t(0);
|
||||
_data.flat[13] = -t(1);
|
||||
_data.flat[14] = -t(2);
|
||||
_data.flat[15] = m(3,3);
|
||||
}
|
||||
|
||||
/// Access by index, the index is unchecked
|
||||
const T& operator()(unsigned i, unsigned j) const
|
||||
{ return _data.flat[i + 4*j]; }
|
||||
/// Access by index, the index is unchecked
|
||||
T& operator()(unsigned i, unsigned j)
|
||||
{ return _data.flat[i + 4*j]; }
|
||||
|
||||
/// Access raw data by index, the index is unchecked
|
||||
const T& operator[](unsigned i) const
|
||||
{ return _data.flat[i]; }
|
||||
/// Access by index, the index is unchecked
|
||||
T& operator[](unsigned i)
|
||||
{ return _data.flat[i]; }
|
||||
|
||||
/// Get the data pointer
|
||||
const T* data(void) const
|
||||
{ return _data.flat; }
|
||||
/// Get the data pointer
|
||||
T* data(void)
|
||||
{ return _data.flat; }
|
||||
|
||||
/// Readonly interface function to ssg's sgMat4/sgdMat4
|
||||
const T (&sg(void) const)[4][4]
|
||||
{ return _data.carray; }
|
||||
/// Interface function to ssg's sgMat4/sgdMat4
|
||||
T (&sg(void))[4][4]
|
||||
{ return _data.carray; }
|
||||
|
||||
/// Inplace addition
|
||||
SGMatrix& operator+=(const SGMatrix& m)
|
||||
{ for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] += m._data.flat[i]; return *this; }
|
||||
/// Inplace subtraction
|
||||
SGMatrix& operator-=(const SGMatrix& m)
|
||||
{ for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] -= m._data.flat[i]; return *this; }
|
||||
/// Inplace scalar multiplication
|
||||
template<typename S>
|
||||
SGMatrix& operator*=(S s)
|
||||
{ for (unsigned i = 0; i < nEnts; ++i) _data.flat[i] *= s; return *this; }
|
||||
/// Inplace scalar multiplication by 1/s
|
||||
template<typename S>
|
||||
SGMatrix& operator/=(S s)
|
||||
{ return operator*=(1/T(s)); }
|
||||
/// Inplace matrix multiplication, post multiply
|
||||
SGMatrix& operator*=(const SGMatrix<T>& m2);
|
||||
|
||||
template<typename S>
|
||||
SGMatrix& preMultTranslate(const SGVec3<S>& t)
|
||||
{
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nCols-1; ++i)
|
||||
(*this)(i,3) += T(t(i));
|
||||
return *this;
|
||||
}
|
||||
template<typename S>
|
||||
SGMatrix& postMultTranslate(const SGVec3<S>& t)
|
||||
{
|
||||
SGVec4<T> col3((*this)(0,3), (*this)(1,3), (*this)(2,3), (*this)(3,3));
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nCols-1; ++i) {
|
||||
SGVec4<T> tmp((*this)(0,3), (*this)(1,3), (*this)(2,3), (*this)(3,3));
|
||||
col3 += T(t(i))*tmp;
|
||||
}
|
||||
(*this)(0,3) = col3(0); (*this)(1,3) = col3(1);
|
||||
(*this)(2,3) = col3(2); (*this)(3,3) = col3(3);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SGMatrix& preMultRotate(const SGQuat<T>& r)
|
||||
{
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nCols; ++i) {
|
||||
SGVec3<T> col((*this)(0,i), (*this)(1,i), (*this)(2,i));
|
||||
col = r.transform(col);
|
||||
(*this)(0,i) = col(0); (*this)(1,i) = col(1); (*this)(2,i) = col(2);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
SGMatrix& postMultRotate(const SGQuat<T>& r)
|
||||
{
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nCols; ++i) {
|
||||
SGVec3<T> col((*this)(i,0), (*this)(i,1), (*this)(i,2));
|
||||
col = r.backTransform(col);
|
||||
(*this)(i,0) = col(0); (*this)(i,1) = col(1); (*this)(i,2) = col(2);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
SGVec3<T> xformPt(const SGVec3<T>& pt) const
|
||||
{
|
||||
SGVec3<T> tpt;
|
||||
tpt(0) = (*this)(0,3);
|
||||
tpt(1) = (*this)(1,3);
|
||||
tpt(2) = (*this)(2,3);
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nCols-1; ++i) {
|
||||
T tmp = pt(i);
|
||||
tpt(0) += tmp*(*this)(0,i);
|
||||
tpt(1) += tmp*(*this)(1,i);
|
||||
tpt(2) += tmp*(*this)(2,i);
|
||||
}
|
||||
return tpt;
|
||||
}
|
||||
SGVec3<T> xformVec(const SGVec3<T>& v) const
|
||||
{
|
||||
SGVec3<T> tv;
|
||||
T tmp = v(0);
|
||||
tv(0) = tmp*(*this)(0,0);
|
||||
tv(1) = tmp*(*this)(1,0);
|
||||
tv(2) = tmp*(*this)(2,0);
|
||||
for (unsigned i = 1; i < SGMatrix<T>::nCols-1; ++i) {
|
||||
T tmp = v(i);
|
||||
tv(0) += tmp*(*this)(0,i);
|
||||
tv(1) += tmp*(*this)(1,i);
|
||||
tv(2) += tmp*(*this)(2,i);
|
||||
}
|
||||
return tv;
|
||||
}
|
||||
|
||||
/// Return an all zero matrix
|
||||
static SGMatrix zeros(void)
|
||||
{ return SGMatrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); }
|
||||
|
||||
/// Return a unit matrix
|
||||
static SGMatrix unit(void)
|
||||
{ return SGMatrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
|
||||
|
||||
private:
|
||||
/// Required to make that alias safe.
|
||||
union Data {
|
||||
T flat[16];
|
||||
T carray[4][4];
|
||||
};
|
||||
|
||||
/// The actual data, the matrix is stored in column major order,
|
||||
/// that matches the storage format of OpenGL
|
||||
Data _data;
|
||||
};
|
||||
|
||||
/// Class to distinguish between a matrix and the matrix with a transposed
|
||||
/// rotational part and a negated translational part
|
||||
template<typename T>
|
||||
struct TransNegRef {
|
||||
TransNegRef(const SGMatrix<T>& _m) : m(_m) {}
|
||||
const SGMatrix<T>& m;
|
||||
};
|
||||
|
||||
/// Unary +, do nothing ...
|
||||
template<typename T>
|
||||
inline
|
||||
const SGMatrix<T>&
|
||||
operator+(const SGMatrix<T>& m)
|
||||
{ return m; }
|
||||
|
||||
/// Unary -, do nearly nothing
|
||||
template<typename T>
|
||||
inline
|
||||
SGMatrix<T>
|
||||
operator-(const SGMatrix<T>& m)
|
||||
{
|
||||
SGMatrix<T> ret;
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
|
||||
ret[i] = -m[i];
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// Binary +
|
||||
template<typename T>
|
||||
inline
|
||||
SGMatrix<T>
|
||||
operator+(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
|
||||
{
|
||||
SGMatrix<T> ret;
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
|
||||
ret[i] = m1[i] + m2[i];
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// Binary -
|
||||
template<typename T>
|
||||
inline
|
||||
SGMatrix<T>
|
||||
operator-(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
|
||||
{
|
||||
SGMatrix<T> ret;
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
|
||||
ret[i] = m1[i] - m2[i];
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// Scalar multiplication
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGMatrix<T>
|
||||
operator*(S s, const SGMatrix<T>& m)
|
||||
{
|
||||
SGMatrix<T> ret;
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
|
||||
ret[i] = s*m[i];
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// Scalar multiplication
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGMatrix<T>
|
||||
operator*(const SGMatrix<T>& m, S s)
|
||||
{
|
||||
SGMatrix<T> ret;
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
|
||||
ret[i] = s*m[i];
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// Vector multiplication
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec4<T>
|
||||
operator*(const SGMatrix<T>& m, const SGVec4<T>& v)
|
||||
{
|
||||
SGVec4<T> mv;
|
||||
T tmp = v(0);
|
||||
mv(0) = tmp*m(0,0);
|
||||
mv(1) = tmp*m(1,0);
|
||||
mv(2) = tmp*m(2,0);
|
||||
mv(3) = tmp*m(3,0);
|
||||
for (unsigned i = 1; i < SGMatrix<T>::nCols; ++i) {
|
||||
T tmp = v(i);
|
||||
mv(0) += tmp*m(0,i);
|
||||
mv(1) += tmp*m(1,i);
|
||||
mv(2) += tmp*m(2,i);
|
||||
mv(3) += tmp*m(3,i);
|
||||
}
|
||||
return mv;
|
||||
}
|
||||
|
||||
/// Vector multiplication
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec4<T>
|
||||
operator*(const TransNegRef<T>& tm, const SGVec4<T>& v)
|
||||
{
|
||||
const SGMatrix<T>& m = tm.m;
|
||||
SGVec4<T> mv;
|
||||
SGVec3<T> v2;
|
||||
T tmp = v(3);
|
||||
mv(0) = v2(0) = -tmp*m(0,3);
|
||||
mv(1) = v2(1) = -tmp*m(1,3);
|
||||
mv(2) = v2(2) = -tmp*m(2,3);
|
||||
mv(3) = tmp*m(3,3);
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nCols - 1; ++i) {
|
||||
T tmp = v(i) + v2(i);
|
||||
mv(0) += tmp*m(i,0);
|
||||
mv(1) += tmp*m(i,1);
|
||||
mv(2) += tmp*m(i,2);
|
||||
mv(3) += tmp*m(3,i);
|
||||
}
|
||||
return mv;
|
||||
}
|
||||
|
||||
/// Matrix multiplication
|
||||
template<typename T>
|
||||
inline
|
||||
SGMatrix<T>
|
||||
operator*(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
|
||||
{
|
||||
SGMatrix<T> m;
|
||||
for (unsigned j = 0; j < SGMatrix<T>::nCols; ++j) {
|
||||
T tmp = m2(0,j);
|
||||
m(0,j) = tmp*m1(0,0);
|
||||
m(1,j) = tmp*m1(1,0);
|
||||
m(2,j) = tmp*m1(2,0);
|
||||
m(3,j) = tmp*m1(3,0);
|
||||
for (unsigned i = 1; i < SGMatrix<T>::nCols; ++i) {
|
||||
T tmp = m2(i,j);
|
||||
m(0,j) += tmp*m1(0,i);
|
||||
m(1,j) += tmp*m1(1,i);
|
||||
m(2,j) += tmp*m1(2,i);
|
||||
m(3,j) += tmp*m1(3,i);
|
||||
}
|
||||
}
|
||||
return m;
|
||||
}
|
||||
|
||||
/// Inplace matrix multiplication, post multiply
|
||||
template<typename T>
|
||||
inline
|
||||
SGMatrix<T>&
|
||||
SGMatrix<T>::operator*=(const SGMatrix<T>& m2)
|
||||
{ (*this) = operator*(*this, m2); return *this; }
|
||||
|
||||
/// Return a reference to the matrix typed to make sure we use the transposed
|
||||
/// negated matrix
|
||||
template<typename T>
|
||||
inline
|
||||
TransNegRef<T>
|
||||
transNeg(const SGMatrix<T>& m)
|
||||
{ return TransNegRef<T>(m); }
|
||||
|
||||
/// Compute the inverse if the matrix src. Store the result in dst.
|
||||
/// Return if the matrix is nonsingular. If it is singular dst contains
|
||||
/// undefined values
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
invert(SGMatrix<T>& dst, const SGMatrix<T>& src)
|
||||
{
|
||||
// Do a LU decomposition with row pivoting and solve into dst
|
||||
SGMatrix<T> tmp = src;
|
||||
dst = SGMatrix<T>::unit();
|
||||
|
||||
for (unsigned i = 0; i < 4; ++i) {
|
||||
T val = tmp(i,i);
|
||||
unsigned ind = i;
|
||||
|
||||
// Find the row with the maximum value in the i-th colum
|
||||
for (unsigned j = i + 1; j < 4; ++j) {
|
||||
if (fabs(tmp(j, i)) > fabs(val)) {
|
||||
ind = j;
|
||||
val = tmp(j, i);
|
||||
}
|
||||
}
|
||||
|
||||
// Do row pivoting
|
||||
if (ind != i) {
|
||||
for (unsigned j = 0; j < 4; ++j) {
|
||||
T t;
|
||||
t = dst(i,j); dst(i,j) = dst(ind,j); dst(ind,j) = t;
|
||||
t = tmp(i,j); tmp(i,j) = tmp(ind,j); tmp(ind,j) = t;
|
||||
}
|
||||
}
|
||||
|
||||
// Check for singularity
|
||||
if (fabs(val) <= SGLimits<T>::min())
|
||||
return false;
|
||||
|
||||
T ival = 1/val;
|
||||
for (unsigned j = 0; j < 4; ++j) {
|
||||
tmp(i,j) *= ival;
|
||||
dst(i,j) *= ival;
|
||||
}
|
||||
|
||||
for (unsigned j = 0; j < 4; ++j) {
|
||||
if (j == i)
|
||||
continue;
|
||||
|
||||
val = tmp(j,i);
|
||||
for (unsigned k = 0; k < 4; ++k) {
|
||||
tmp(j,k) -= tmp(i,k) * val;
|
||||
dst(j,k) -= dst(i,k) * val;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/// The 1-norm of the matrix, this is the largest column sum of
|
||||
/// the absolute values of A.
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
norm1(const SGMatrix<T>& m)
|
||||
{
|
||||
T nrm = 0;
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nRows; ++i) {
|
||||
T sum = fabs(m(i, 0)) + fabs(m(i, 1)) + fabs(m(i, 2)) + fabs(m(i, 3));
|
||||
if (nrm < sum)
|
||||
nrm = sum;
|
||||
}
|
||||
return nrm;
|
||||
}
|
||||
|
||||
/// The inf-norm of the matrix, this is the largest row sum of
|
||||
/// the absolute values of A.
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
normInf(const SGMatrix<T>& m)
|
||||
{
|
||||
T nrm = 0;
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nCols; ++i) {
|
||||
T sum = fabs(m(0, i)) + fabs(m(1, i)) + fabs(m(2, i)) + fabs(m(3, i));
|
||||
if (nrm < sum)
|
||||
nrm = sum;
|
||||
}
|
||||
return nrm;
|
||||
}
|
||||
|
||||
/// Return true if exactly the same
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator==(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
|
||||
{
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i)
|
||||
if (m1[i] != m2[i])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Return true if not exactly the same
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator!=(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
|
||||
{ return ! (m1 == m2); }
|
||||
|
||||
/// Return true if equal to the relative tolerance tol
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGMatrix<T>& m1, const SGMatrix<T>& m2, T rtol, T atol)
|
||||
{ return norm1(m1 - m2) < rtol*(norm1(m1) + norm1(m2)) + atol; }
|
||||
|
||||
/// Return true if equal to the relative tolerance tol
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGMatrix<T>& m1, const SGMatrix<T>& m2, T rtol)
|
||||
{ return norm1(m1 - m2) < rtol*(norm1(m1) + norm1(m2)); }
|
||||
|
||||
/// Return true if about equal to roundoff of the underlying type
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGMatrix<T>& m1, const SGMatrix<T>& m2)
|
||||
{
|
||||
T tol = 100*SGLimits<T>::epsilon();
|
||||
return equivalent(m1, m2, tol, tol);
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
isNaN(const SGMatrix<T>& m)
|
||||
{
|
||||
for (unsigned i = 0; i < SGMatrix<T>::nEnts; ++i) {
|
||||
if (SGMisc<T>::isNaN(m[i]))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s, const SGMatrix<T>& m)
|
||||
{
|
||||
s << "[ " << m(0,0) << ", " << m(0,1) << ", " << m(0,2) << ", " << m(0,3) << "\n";
|
||||
s << " " << m(1,0) << ", " << m(1,1) << ", " << m(1,2) << ", " << m(1,3) << "\n";
|
||||
s << " " << m(2,0) << ", " << m(2,1) << ", " << m(2,2) << ", " << m(2,3) << "\n";
|
||||
s << " " << m(3,0) << ", " << m(3,1) << ", " << m(3,2) << ", " << m(3,3) << " ]";
|
||||
return s;
|
||||
}
|
||||
|
||||
inline
|
||||
SGMatrixf
|
||||
toMatrixf(const SGMatrixd& m)
|
||||
{
|
||||
return SGMatrixf((float)m(0,0), (float)m(0,1), (float)m(0,2), (float)m(0,3),
|
||||
(float)m(1,0), (float)m(1,1), (float)m(1,2), (float)m(1,3),
|
||||
(float)m(2,0), (float)m(2,1), (float)m(2,2), (float)m(2,3),
|
||||
(float)m(3,0), (float)m(3,1), (float)m(3,2), (float)m(3,3));
|
||||
}
|
||||
|
||||
inline
|
||||
SGMatrixd
|
||||
toMatrixd(const SGMatrixf& m)
|
||||
{
|
||||
return SGMatrixd(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));
|
||||
}
|
||||
|
||||
#endif
|
||||
110
simgear/math/SGMisc.hxx
Normal file
110
simgear/math/SGMisc.hxx
Normal file
@@ -0,0 +1,110 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGMisc_H
|
||||
#define SGMisc_H
|
||||
|
||||
template<typename T>
|
||||
class SGMisc {
|
||||
public:
|
||||
static T pi() { return T(3.1415926535897932384626433832795029L); }
|
||||
static T twopi() { return 2*T(3.1415926535897932384626433832795029L); }
|
||||
|
||||
static T min(const T& a, const T& b)
|
||||
{ return a < b ? a : b; }
|
||||
static T min(const T& a, const T& b, const T& c)
|
||||
{ return min(min(a, b), c); }
|
||||
static T min(const T& a, const T& b, const T& c, const T& d)
|
||||
{ return min(min(min(a, b), c), d); }
|
||||
static T max(const T& a, const T& b)
|
||||
{ return a > b ? a : b; }
|
||||
static T max(const T& a, const T& b, const T& c)
|
||||
{ return max(max(a, b), c); }
|
||||
static T max(const T& a, const T& b, const T& c, const T& d)
|
||||
{ return max(max(max(a, b), c), d); }
|
||||
|
||||
// clip the value of a to be in the range between and including _min and _max
|
||||
static T clip(const T& a, const T& _min, const T& _max)
|
||||
{ return max(_min, min(_max, a)); }
|
||||
|
||||
static int sign(const T& a)
|
||||
{
|
||||
if (a < -SGLimits<T>::min())
|
||||
return -1;
|
||||
else if (SGLimits<T>::min() < a)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static T rad2deg(const T& val)
|
||||
{ return val*180/pi(); }
|
||||
static T deg2rad(const T& val)
|
||||
{ return val*pi()/180; }
|
||||
|
||||
// normalize the value to be in a range between [min, max[
|
||||
static T
|
||||
normalizePeriodic(const T& min, const T& max, const T& value)
|
||||
{
|
||||
T range = max - min;
|
||||
if (range < SGLimits<T>::min())
|
||||
return min;
|
||||
T normalized = value - range*floor((value - min)/range);
|
||||
// two security checks that can only happen due to roundoff
|
||||
if (value <= min)
|
||||
return min;
|
||||
if (max <= normalized)
|
||||
return min;
|
||||
return normalized;
|
||||
}
|
||||
|
||||
// normalize the angle to be in a range between [-pi, pi[
|
||||
static T
|
||||
normalizeAngle(const T& angle)
|
||||
{ return normalizePeriodic(-pi(), pi(), angle); }
|
||||
|
||||
// normalize the angle to be in a range between [0, 2pi[
|
||||
static T
|
||||
normalizeAngle2(const T& angle)
|
||||
{ return normalizePeriodic(0, twopi(), angle); }
|
||||
|
||||
static T round(const T& v)
|
||||
{ return floor(v + T(0.5)); }
|
||||
static int roundToInt(const T& v)
|
||||
{ return int(round(v)); }
|
||||
|
||||
#ifndef NDEBUG
|
||||
/// Returns true if v is a NaN value
|
||||
/// Use with care: allways code that you do not need to use that!
|
||||
static bool isNaN(const T& v)
|
||||
{
|
||||
#ifdef HAVE_ISNAN
|
||||
return isnan(v);
|
||||
#elif defined HAVE_STD_ISNAN
|
||||
return std::isnan(v);
|
||||
#else
|
||||
// Use that every compare involving a NaN returns false
|
||||
// But be careful, some usual compiler switches like for example
|
||||
// -fast-math from gcc might optimize that expression to v != v which
|
||||
// behaves exactly like the opposite ...
|
||||
return !(v == v);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif
|
||||
59
simgear/math/SGPlane.hxx
Normal file
59
simgear/math/SGPlane.hxx
Normal file
@@ -0,0 +1,59 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGPlane_H
|
||||
#define SGPlane_H
|
||||
|
||||
template<typename T>
|
||||
class SGPlane {
|
||||
public:
|
||||
SGPlane()
|
||||
{ }
|
||||
SGPlane(const SGVec3<T>& normal, T dist) :
|
||||
_normal(normal), _dist(dist)
|
||||
{ }
|
||||
SGPlane(const SGVec3<T> vertices[3]) :
|
||||
_normal(normalize(cross(vertices[1] - vertices[0],
|
||||
vertices[2] - vertices[0]))),
|
||||
_dist(-dot(_normal, vertices[0]))
|
||||
{ }
|
||||
|
||||
void setNormal(const SGVec3<T>& normal)
|
||||
{ _normal = normal; }
|
||||
const SGVec3<T>& getNormal() const
|
||||
{ return _normal; }
|
||||
|
||||
void setDist(const T& dist)
|
||||
{ _dist = dist; }
|
||||
const T& getDist() const
|
||||
{ return _dist; }
|
||||
|
||||
/// That is the distance where we measure positive in direction of the normal
|
||||
T getPositiveDist() const
|
||||
{ return -_dist; }
|
||||
/// That is the distance where we measure positive in the oposite direction
|
||||
/// of the normal.
|
||||
const T& getNegativeDist() const
|
||||
{ return _dist; }
|
||||
|
||||
private:
|
||||
// That ordering is important because of one constructor
|
||||
SGVec3<T> _normal;
|
||||
T _dist;
|
||||
};
|
||||
|
||||
#endif
|
||||
793
simgear/math/SGQuat.hxx
Normal file
793
simgear/math/SGQuat.hxx
Normal file
@@ -0,0 +1,793 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGQuat_H
|
||||
#define SGQuat_H
|
||||
|
||||
#ifdef min
|
||||
#undef min
|
||||
#endif
|
||||
|
||||
#ifdef max
|
||||
#undef max
|
||||
#endif
|
||||
|
||||
#include <osg/Quat>
|
||||
|
||||
template<typename T>
|
||||
struct SGQuatStorage {
|
||||
/// Readonly raw storage interface
|
||||
const T (&data(void) const)[4]
|
||||
{ return _data; }
|
||||
/// Readonly raw storage interface
|
||||
T (&data(void))[4]
|
||||
{ return _data; }
|
||||
|
||||
void osg() const
|
||||
{ }
|
||||
|
||||
private:
|
||||
T _data[4];
|
||||
};
|
||||
|
||||
template<>
|
||||
struct SGQuatStorage<double> : public osg::Quat {
|
||||
/// Access raw data by index, the index is unchecked
|
||||
const double (&data(void) const)[4]
|
||||
{ return osg::Quat::_v; }
|
||||
/// Access raw data by index, the index is unchecked
|
||||
double (&data(void))[4]
|
||||
{ return osg::Quat::_v; }
|
||||
|
||||
const osg::Quat& osg() const
|
||||
{ return *this; }
|
||||
osg::Quat& osg()
|
||||
{ return *this; }
|
||||
};
|
||||
|
||||
/// 3D Vector Class
|
||||
template<typename T>
|
||||
class SGQuat : protected SGQuatStorage<T> {
|
||||
public:
|
||||
typedef T value_type;
|
||||
|
||||
/// Default constructor. Does not initialize at all.
|
||||
/// If you need them zero initialized, SGQuat::zeros()
|
||||
SGQuat(void)
|
||||
{
|
||||
/// Initialize with nans in the debug build, that will guarantee to have
|
||||
/// a fast uninitialized default constructor in the release but shows up
|
||||
/// uninitialized values in the debug build very fast ...
|
||||
#ifndef NDEBUG
|
||||
for (unsigned i = 0; i < 4; ++i)
|
||||
data()[i] = SGLimits<T>::quiet_NaN();
|
||||
#endif
|
||||
}
|
||||
/// Constructor. Initialize by the given values
|
||||
SGQuat(T _x, T _y, T _z, T _w)
|
||||
{ x() = _x; y() = _y; z() = _z; w() = _w; }
|
||||
/// Constructor. Initialize by the content of a plain array,
|
||||
/// make sure it has at least 4 elements
|
||||
explicit SGQuat(const T* d)
|
||||
{ data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; data()[3] = d[3]; }
|
||||
explicit SGQuat(const osg::Quat& d)
|
||||
{ data()[0] = d[0]; data()[1] = d[1]; data()[2] = d[2]; data()[3] = d[3]; }
|
||||
|
||||
/// Return a unit quaternion
|
||||
static SGQuat unit(void)
|
||||
{ return fromRealImag(1, SGVec3<T>(0, 0, 0)); }
|
||||
|
||||
/// Return a quaternion from euler angles
|
||||
static SGQuat fromEulerRad(T z, T y, T x)
|
||||
{
|
||||
SGQuat q;
|
||||
T zd2 = T(0.5)*z; T yd2 = T(0.5)*y; T xd2 = T(0.5)*x;
|
||||
T Szd2 = sin(zd2); T Syd2 = sin(yd2); T Sxd2 = sin(xd2);
|
||||
T Czd2 = cos(zd2); T Cyd2 = cos(yd2); T Cxd2 = cos(xd2);
|
||||
T Cxd2Czd2 = Cxd2*Czd2; T Cxd2Szd2 = Cxd2*Szd2;
|
||||
T Sxd2Szd2 = Sxd2*Szd2; T Sxd2Czd2 = Sxd2*Czd2;
|
||||
q.w() = Cxd2Czd2*Cyd2 + Sxd2Szd2*Syd2;
|
||||
q.x() = Sxd2Czd2*Cyd2 - Cxd2Szd2*Syd2;
|
||||
q.y() = Cxd2Czd2*Syd2 + Sxd2Szd2*Cyd2;
|
||||
q.z() = Cxd2Szd2*Cyd2 - Sxd2Czd2*Syd2;
|
||||
return q;
|
||||
}
|
||||
|
||||
/// Return a quaternion from euler angles in degrees
|
||||
static SGQuat fromEulerDeg(T z, T y, T x)
|
||||
{
|
||||
return fromEulerRad(SGMisc<T>::deg2rad(z), SGMisc<T>::deg2rad(y),
|
||||
SGMisc<T>::deg2rad(x));
|
||||
}
|
||||
|
||||
/// Return a quaternion from euler angles
|
||||
static SGQuat fromYawPitchRoll(T y, T p, T r)
|
||||
{ return fromEulerRad(y, p, r); }
|
||||
|
||||
/// Return a quaternion from euler angles
|
||||
static SGQuat fromYawPitchRollDeg(T y, T p, T r)
|
||||
{ return fromEulerDeg(y, p, r); }
|
||||
|
||||
/// Return a quaternion from euler angles
|
||||
static SGQuat fromHeadAttBank(T h, T a, T b)
|
||||
{ return fromEulerRad(h, a, b); }
|
||||
|
||||
/// Return a quaternion from euler angles
|
||||
static SGQuat fromHeadAttBankDeg(T h, T a, T b)
|
||||
{ return fromEulerDeg(h, a, b); }
|
||||
|
||||
/// Return a quaternion rotation from the earth centered to the
|
||||
/// simulation usual horizontal local frame from given
|
||||
/// longitude and latitude.
|
||||
/// The horizontal local frame used in simulations is the frame with x-axis
|
||||
/// pointing north, the y-axis pointing eastwards and the z axis
|
||||
/// pointing downwards.
|
||||
static SGQuat fromLonLatRad(T lon, T lat)
|
||||
{
|
||||
SGQuat q;
|
||||
T zd2 = T(0.5)*lon;
|
||||
T yd2 = T(-0.25)*SGMisc<T>::pi() - T(0.5)*lat;
|
||||
T Szd2 = sin(zd2);
|
||||
T Syd2 = sin(yd2);
|
||||
T Czd2 = cos(zd2);
|
||||
T Cyd2 = cos(yd2);
|
||||
q.w() = Czd2*Cyd2;
|
||||
q.x() = -Szd2*Syd2;
|
||||
q.y() = Czd2*Syd2;
|
||||
q.z() = Szd2*Cyd2;
|
||||
return q;
|
||||
}
|
||||
/// Like the above provided for convenience
|
||||
static SGQuat fromLonLatDeg(T lon, T lat)
|
||||
{ return fromLonLatRad(SGMisc<T>::deg2rad(lon), SGMisc<T>::deg2rad(lat)); }
|
||||
/// Like the above provided for convenience
|
||||
static SGQuat fromLonLat(const SGGeod& geod)
|
||||
{ return fromLonLatRad(geod.getLongitudeRad(), geod.getLatitudeRad()); }
|
||||
|
||||
/// Return a quaternion rotation from the earth centered to the
|
||||
/// OpenGL/viewer horizontal local frame from given longitude and latitude.
|
||||
/// This frame matches the usual OpenGL axis directions. That is the target
|
||||
/// frame has an x-axis pointing eastwards, y-axis pointing up and y z-axis
|
||||
/// pointing south.
|
||||
static SGQuat viewHLRad(T lon, T lat)
|
||||
{
|
||||
// That bails down to a 3-2-1 euler sequence lon+pi/2, 0, -lat-pi
|
||||
// what is here is again the hand optimized version ...
|
||||
SGQuat q;
|
||||
T xd2 = -T(0.5)*lat - T(0.5)*SGMisc<T>::pi();
|
||||
T zd2 = T(0.5)*lon + T(0.25)*SGMisc<T>::pi();
|
||||
T Szd2 = sin(zd2);
|
||||
T Sxd2 = sin(xd2);
|
||||
T Czd2 = cos(zd2);
|
||||
T Cxd2 = cos(xd2);
|
||||
q.w() = Cxd2*Czd2;
|
||||
q.x() = Sxd2*Czd2;
|
||||
q.y() = Sxd2*Szd2;
|
||||
q.z() = Cxd2*Szd2;
|
||||
return q;
|
||||
}
|
||||
/// Like the above provided for convenience
|
||||
static SGQuat viewHLDeg(T lon, T lat)
|
||||
{ return viewHLRad(SGMisc<T>::deg2rad(lon), SGMisc<T>::deg2rad(lat)); }
|
||||
/// Like the above provided for convenience
|
||||
static SGQuat viewHL(const SGGeod& geod)
|
||||
{ return viewHLRad(geod.getLongitudeRad(), geod.getLatitudeRad()); }
|
||||
|
||||
/// Convert a quaternion rotation from the simulation frame
|
||||
/// to the view (OpenGL) frame. That is it just swaps the axis part of
|
||||
/// this current quaternion.
|
||||
/// That proves useful when you want to use the euler 3-2-1 sequence
|
||||
/// for the usual heading/pitch/roll sequence within the context of
|
||||
/// OpenGL/viewer frames.
|
||||
static SGQuat simToView(const SGQuat& q)
|
||||
{ return SGQuat(q.y(), -q.z(), -q.x(), q.w()); }
|
||||
|
||||
/// Create a quaternion from the angle axis representation
|
||||
static SGQuat fromAngleAxis(T angle, const SGVec3<T>& axis)
|
||||
{
|
||||
T angle2 = 0.5*angle;
|
||||
return fromRealImag(cos(angle2), T(sin(angle2))*axis);
|
||||
}
|
||||
|
||||
/// Create a quaternion from the angle axis representation
|
||||
static SGQuat fromAngleAxisDeg(T angle, const SGVec3<T>& axis)
|
||||
{ return fromAngleAxis(SGMisc<T>::deg2rad(angle), axis); }
|
||||
|
||||
/// Create a quaternion from the angle axis representation where the angle
|
||||
/// is stored in the axis' length
|
||||
static SGQuat fromAngleAxis(const SGVec3<T>& axis)
|
||||
{
|
||||
T nAxis = norm(axis);
|
||||
if (nAxis <= SGLimits<T>::min())
|
||||
return SGQuat(1, 0, 0, 0);
|
||||
T angle2 = 0.5*nAxis;
|
||||
return fromRealImag(cos(angle2), T(sin(angle2)/nAxis)*axis);
|
||||
}
|
||||
|
||||
static SGQuat fromRotateTo(const SGVec3<T>& from, const SGVec3<T>& to)
|
||||
{
|
||||
T nfrom = norm(from);
|
||||
T nto = norm(to);
|
||||
if (nfrom < SGLimits<T>::min() || nto < SGLimits<T>::min())
|
||||
return SGQuat::unit();
|
||||
|
||||
return SGQuat::fromRotateToNorm((1/nfrom)*from, (1/nto)*to);
|
||||
}
|
||||
|
||||
// FIXME more finegrained error behavour.
|
||||
static SGQuat fromRotateTo(const SGVec3<T>& v1, unsigned i1,
|
||||
const SGVec3<T>& v2, unsigned i2)
|
||||
{
|
||||
T nrmv1 = norm(v1);
|
||||
T nrmv2 = norm(v2);
|
||||
if (nrmv1 < SGLimits<T>::min() || nrmv2 < SGLimits<T>::min())
|
||||
return SGQuat::unit();
|
||||
|
||||
SGVec3<T> nv1 = (1/nrmv1)*v1;
|
||||
SGVec3<T> nv2 = (1/nrmv2)*v2;
|
||||
T dv1v2 = dot(nv1, nv2);
|
||||
if (fabs(fabs(dv1v2)-1) < SGLimits<T>::epsilon())
|
||||
return SGQuat::unit();
|
||||
|
||||
// The target vector for the first rotation
|
||||
SGVec3<T> nto1 = SGVec3<T>::zeros();
|
||||
SGVec3<T> nto2 = SGVec3<T>::zeros();
|
||||
nto1[i1] = 1;
|
||||
nto2[i2] = 1;
|
||||
|
||||
// The first rotation can be done with the usual routine.
|
||||
SGQuat q = SGQuat::fromRotateToNorm(nv1, nto1);
|
||||
|
||||
// The rotation axis for the second rotation is the
|
||||
// target for the first one, so the rotation axis is nto1
|
||||
// We need to get the angle.
|
||||
|
||||
// Make nv2 exactly orthogonal to nv1.
|
||||
nv2 = normalize(nv2 - dv1v2*nv1);
|
||||
|
||||
SGVec3<T> tnv2 = q.transform(nv2);
|
||||
T cosang = dot(nto2, tnv2);
|
||||
T cos05ang = T(0.5+0.5*cosang);
|
||||
if (cos05ang <= 0)
|
||||
cosang = T(0);
|
||||
cos05ang = sqrt(cos05ang);
|
||||
T sig = dot(nto1, cross(nto2, tnv2));
|
||||
T sin05ang = T(0.5-0.5*cosang);
|
||||
if (sin05ang <= 0)
|
||||
sin05ang = 0;
|
||||
sin05ang = copysign(sqrt(sin05ang), sig);
|
||||
q *= SGQuat::fromRealImag(cos05ang, sin05ang*nto1);
|
||||
|
||||
return q;
|
||||
}
|
||||
|
||||
|
||||
// Return a quaternion which rotates the vector given by v
|
||||
// to the vector -v. Other directions are *not* preserved.
|
||||
static SGQuat fromChangeSign(const SGVec3<T>& v)
|
||||
{
|
||||
// The vector from points to the oposite direction than to.
|
||||
// Find a vector perpendicular to the vector to.
|
||||
T absv1 = fabs(v(0));
|
||||
T absv2 = fabs(v(1));
|
||||
T absv3 = fabs(v(2));
|
||||
|
||||
SGVec3<T> axis;
|
||||
if (absv2 < absv1 && absv3 < absv1) {
|
||||
T quot = v(1)/v(0);
|
||||
axis = (1/sqrt(1+quot*quot))*SGVec3<T>(quot, -1, 0);
|
||||
} else if (absv1 < absv2 && absv3 < absv2) {
|
||||
T quot = v(2)/v(1);
|
||||
axis = (1/sqrt(1+quot*quot))*SGVec3<T>(0, quot, -1);
|
||||
} else if (absv1 < absv3 && absv2 < absv3) {
|
||||
T quot = v(0)/v(2);
|
||||
axis = (1/sqrt(1+quot*quot))*SGVec3<T>(-1, 0, quot);
|
||||
} else {
|
||||
// The all zero case.
|
||||
return SGQuat::unit();
|
||||
}
|
||||
|
||||
return SGQuat::fromRealImag(0, axis);
|
||||
}
|
||||
|
||||
/// Return a quaternion from real and imaginary part
|
||||
static SGQuat fromRealImag(T r, const SGVec3<T>& i)
|
||||
{
|
||||
SGQuat q;
|
||||
q.w() = r;
|
||||
q.x() = i.x();
|
||||
q.y() = i.y();
|
||||
q.z() = i.z();
|
||||
return q;
|
||||
}
|
||||
|
||||
/// Return an all zero vector
|
||||
static SGQuat zeros(void)
|
||||
{ return SGQuat(0, 0, 0, 0); }
|
||||
|
||||
/// write the euler angles into the references
|
||||
void getEulerRad(T& zRad, T& yRad, T& xRad) const
|
||||
{
|
||||
T sqrQW = w()*w();
|
||||
T sqrQX = x()*x();
|
||||
T sqrQY = y()*y();
|
||||
T sqrQZ = z()*z();
|
||||
|
||||
T num = 2*(y()*z() + w()*x());
|
||||
T den = sqrQW - sqrQX - sqrQY + sqrQZ;
|
||||
if (fabs(den) < SGLimits<T>::min() &&
|
||||
fabs(num) < SGLimits<T>::min())
|
||||
xRad = 0;
|
||||
else
|
||||
xRad = atan2(num, den);
|
||||
|
||||
T tmp = 2*(x()*z() - w()*y());
|
||||
if (tmp < -1)
|
||||
yRad = 0.5*SGMisc<T>::pi();
|
||||
else if (1 < tmp)
|
||||
yRad = -0.5*SGMisc<T>::pi();
|
||||
else
|
||||
yRad = -asin(tmp);
|
||||
|
||||
num = 2*(x()*y() + w()*z());
|
||||
den = sqrQW + sqrQX - sqrQY - sqrQZ;
|
||||
if (fabs(den) < SGLimits<T>::min() &&
|
||||
fabs(num) < SGLimits<T>::min())
|
||||
zRad = 0;
|
||||
else {
|
||||
T psi = atan2(num, den);
|
||||
if (psi < 0)
|
||||
psi += 2*SGMisc<T>::pi();
|
||||
zRad = psi;
|
||||
}
|
||||
}
|
||||
|
||||
/// write the euler angles in degrees into the references
|
||||
void getEulerDeg(T& zDeg, T& yDeg, T& xDeg) const
|
||||
{
|
||||
getEulerRad(zDeg, yDeg, xDeg);
|
||||
zDeg = SGMisc<T>::rad2deg(zDeg);
|
||||
yDeg = SGMisc<T>::rad2deg(yDeg);
|
||||
xDeg = SGMisc<T>::rad2deg(xDeg);
|
||||
}
|
||||
|
||||
/// write the angle axis representation into the references
|
||||
void getAngleAxis(T& angle, SGVec3<T>& axis) const
|
||||
{
|
||||
T nrm = norm(*this);
|
||||
if (nrm < SGLimits<T>::min()) {
|
||||
angle = 0;
|
||||
axis = SGVec3<T>(0, 0, 0);
|
||||
} else {
|
||||
T rNrm = 1/nrm;
|
||||
angle = acos(SGMisc<T>::max(-1, SGMisc<T>::min(1, rNrm*w())));
|
||||
T sAng = sin(angle);
|
||||
if (fabs(sAng) < SGLimits<T>::min())
|
||||
axis = SGVec3<T>(1, 0, 0);
|
||||
else
|
||||
axis = (rNrm/sAng)*imag(*this);
|
||||
angle *= 2;
|
||||
}
|
||||
}
|
||||
|
||||
/// write the angle axis representation into the references
|
||||
void getAngleAxis(SGVec3<T>& axis) const
|
||||
{
|
||||
T angle;
|
||||
getAngleAxis(angle, axis);
|
||||
axis *= angle;
|
||||
}
|
||||
|
||||
/// Access by index, the index is unchecked
|
||||
const T& operator()(unsigned i) const
|
||||
{ return data()[i]; }
|
||||
/// Access by index, the index is unchecked
|
||||
T& operator()(unsigned i)
|
||||
{ return data()[i]; }
|
||||
|
||||
/// Access raw data by index, the index is unchecked
|
||||
const T& operator[](unsigned i) const
|
||||
{ return data()[i]; }
|
||||
/// Access raw data by index, the index is unchecked
|
||||
T& operator[](unsigned i)
|
||||
{ return data()[i]; }
|
||||
|
||||
/// Access the x component
|
||||
const T& x(void) const
|
||||
{ return data()[0]; }
|
||||
/// Access the x component
|
||||
T& x(void)
|
||||
{ return data()[0]; }
|
||||
/// Access the y component
|
||||
const T& y(void) const
|
||||
{ return data()[1]; }
|
||||
/// Access the y component
|
||||
T& y(void)
|
||||
{ return data()[1]; }
|
||||
/// Access the z component
|
||||
const T& z(void) const
|
||||
{ return data()[2]; }
|
||||
/// Access the z component
|
||||
T& z(void)
|
||||
{ return data()[2]; }
|
||||
/// Access the w component
|
||||
const T& w(void) const
|
||||
{ return data()[3]; }
|
||||
/// Access the w component
|
||||
T& w(void)
|
||||
{ return data()[3]; }
|
||||
|
||||
/// Get the data pointer
|
||||
using SGQuatStorage<T>::data;
|
||||
|
||||
/// Readonly interface function to ssg's sgQuat/sgdQuat
|
||||
const T (&sg(void) const)[4]
|
||||
{ return data(); }
|
||||
/// Interface function to ssg's sgQuat/sgdQuat
|
||||
T (&sg(void))[4]
|
||||
{ return data(); }
|
||||
|
||||
/// Interface function to osg's Quat*
|
||||
using SGQuatStorage<T>::osg;
|
||||
|
||||
/// Inplace addition
|
||||
SGQuat& operator+=(const SGQuat& v)
|
||||
{ data()[0]+=v(0);data()[1]+=v(1);data()[2]+=v(2);data()[3]+=v(3);return *this; }
|
||||
/// Inplace subtraction
|
||||
SGQuat& operator-=(const SGQuat& v)
|
||||
{ data()[0]-=v(0);data()[1]-=v(1);data()[2]-=v(2);data()[3]-=v(3);return *this; }
|
||||
/// Inplace scalar multiplication
|
||||
template<typename S>
|
||||
SGQuat& operator*=(S s)
|
||||
{ data()[0] *= s; data()[1] *= s; data()[2] *= s; data()[3] *= s; return *this; }
|
||||
/// Inplace scalar multiplication by 1/s
|
||||
template<typename S>
|
||||
SGQuat& operator/=(S s)
|
||||
{ return operator*=(1/T(s)); }
|
||||
/// Inplace quaternion multiplication
|
||||
SGQuat& operator*=(const SGQuat& v);
|
||||
|
||||
/// Transform a vector from the current coordinate frame to a coordinate
|
||||
/// frame rotated with the quaternion
|
||||
SGVec3<T> transform(const SGVec3<T>& v) const
|
||||
{
|
||||
T r = 2/dot(*this, *this);
|
||||
SGVec3<T> qimag = imag(*this);
|
||||
T qr = real(*this);
|
||||
return (r*qr*qr - 1)*v + (r*dot(qimag, v))*qimag - (r*qr)*cross(qimag, v);
|
||||
}
|
||||
/// Transform a vector from the coordinate frame rotated with the quaternion
|
||||
/// to the current coordinate frame
|
||||
SGVec3<T> backTransform(const SGVec3<T>& v) const
|
||||
{
|
||||
T r = 2/dot(*this, *this);
|
||||
SGVec3<T> qimag = imag(*this);
|
||||
T qr = real(*this);
|
||||
return (r*qr*qr - 1)*v + (r*dot(qimag, v))*qimag + (r*qr)*cross(qimag, v);
|
||||
}
|
||||
|
||||
/// Rotate a given vector with the quaternion
|
||||
SGVec3<T> rotate(const SGVec3<T>& v) const
|
||||
{ return backTransform(v); }
|
||||
/// Rotate a given vector with the inverse quaternion
|
||||
SGVec3<T> rotateBack(const SGVec3<T>& v) const
|
||||
{ return transform(v); }
|
||||
|
||||
/// Return the time derivative of the quaternion given the angular velocity
|
||||
SGQuat
|
||||
derivative(const SGVec3<T>& angVel) const
|
||||
{
|
||||
SGQuat deriv;
|
||||
|
||||
deriv.w() = 0.5*(-x()*angVel(0) - y()*angVel(1) - z()*angVel(2));
|
||||
deriv.x() = 0.5*( w()*angVel(0) - z()*angVel(1) + y()*angVel(2));
|
||||
deriv.y() = 0.5*( z()*angVel(0) + w()*angVel(1) - x()*angVel(2));
|
||||
deriv.z() = 0.5*(-y()*angVel(0) + x()*angVel(1) + w()*angVel(2));
|
||||
|
||||
return deriv;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
// Private because it assumes normalized inputs.
|
||||
static SGQuat
|
||||
fromRotateToSmaller90Deg(T cosang,
|
||||
const SGVec3<T>& from, const SGVec3<T>& to)
|
||||
{
|
||||
// In this function we assume that the angle required to rotate from
|
||||
// the vector from to the vector to is <= 90 deg.
|
||||
// That is done so because of possible instabilities when we rotate more
|
||||
// then 90deg.
|
||||
|
||||
// Note that the next comment does actually cover a *more* *general* case
|
||||
// than we need in this function. That shows that this formula is even
|
||||
// valid for rotations up to 180deg.
|
||||
|
||||
// Because of the signs in the axis, it is sufficient to care for angles
|
||||
// in the interval [-pi,pi]. That means that 0.5*angle is in the interval
|
||||
// [-pi/2,pi/2]. But in that range the cosine is allways >= 0.
|
||||
// So we do not need to care for egative roots in the following equation:
|
||||
T cos05ang = sqrt(0.5+0.5*cosang);
|
||||
|
||||
|
||||
// Now our assumption of angles <= 90 deg comes in play.
|
||||
// For that reason, we know that cos05ang is not zero.
|
||||
// It is even more, we can see from the above formula that
|
||||
// sqrt(0.5) < cos05ang.
|
||||
|
||||
|
||||
// Compute the rotation axis, that is
|
||||
// sin(angle)*normalized rotation axis
|
||||
SGVec3<T> axis = cross(to, from);
|
||||
|
||||
// We need sin(0.5*angle)*normalized rotation axis.
|
||||
// So rescale with sin(0.5*x)/sin(x).
|
||||
// To do that we use the equation:
|
||||
// sin(x) = 2*sin(0.5*x)*cos(0.5*x)
|
||||
return SGQuat::fromRealImag( cos05ang, (1/(2*cos05ang))*axis);
|
||||
}
|
||||
|
||||
// Private because it assumes normalized inputs.
|
||||
static SGQuat
|
||||
fromRotateToNorm(const SGVec3<T>& from, const SGVec3<T>& to)
|
||||
{
|
||||
// To avoid instabilities with roundoff, we distinguish between rotations
|
||||
// with more then 90deg and rotations with less than 90deg.
|
||||
|
||||
// Compute the cosine of the angle.
|
||||
T cosang = dot(from, to);
|
||||
|
||||
// For the small ones do direct computation
|
||||
if (T(-0.5) < cosang)
|
||||
return SGQuat::fromRotateToSmaller90Deg(cosang, from, to);
|
||||
|
||||
// For larger rotations. first rotate from to -from.
|
||||
// Past that we will have a smaller angle again.
|
||||
SGQuat q1 = SGQuat::fromChangeSign(from);
|
||||
SGQuat q2 = SGQuat::fromRotateToSmaller90Deg(-cosang, -from, to);
|
||||
return q1*q2;
|
||||
}
|
||||
};
|
||||
|
||||
/// Unary +, do nothing ...
|
||||
template<typename T>
|
||||
inline
|
||||
const SGQuat<T>&
|
||||
operator+(const SGQuat<T>& v)
|
||||
{ return v; }
|
||||
|
||||
/// Unary -, do nearly nothing
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
operator-(const SGQuat<T>& v)
|
||||
{ return SGQuat<T>(-v(0), -v(1), -v(2), -v(3)); }
|
||||
|
||||
/// Binary +
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
operator+(const SGQuat<T>& v1, const SGQuat<T>& v2)
|
||||
{ return SGQuat<T>(v1(0)+v2(0), v1(1)+v2(1), v1(2)+v2(2), v1(3)+v2(3)); }
|
||||
|
||||
/// Binary -
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
operator-(const SGQuat<T>& v1, const SGQuat<T>& v2)
|
||||
{ return SGQuat<T>(v1(0)-v2(0), v1(1)-v2(1), v1(2)-v2(2), v1(3)-v2(3)); }
|
||||
|
||||
/// Scalar multiplication
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
operator*(S s, const SGQuat<T>& v)
|
||||
{ return SGQuat<T>(s*v(0), s*v(1), s*v(2), s*v(3)); }
|
||||
|
||||
/// Scalar multiplication
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
operator*(const SGQuat<T>& v, S s)
|
||||
{ return SGQuat<T>(s*v(0), s*v(1), s*v(2), s*v(3)); }
|
||||
|
||||
/// Quaterion multiplication
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
operator*(const SGQuat<T>& v1, const SGQuat<T>& v2)
|
||||
{
|
||||
SGQuat<T> v;
|
||||
v.x() = v1.w()*v2.x() + v1.x()*v2.w() + v1.y()*v2.z() - v1.z()*v2.y();
|
||||
v.y() = v1.w()*v2.y() - v1.x()*v2.z() + v1.y()*v2.w() + v1.z()*v2.x();
|
||||
v.z() = v1.w()*v2.z() + v1.x()*v2.y() - v1.y()*v2.x() + v1.z()*v2.w();
|
||||
v.w() = v1.w()*v2.w() - v1.x()*v2.x() - v1.y()*v2.y() - v1.z()*v2.z();
|
||||
return v;
|
||||
}
|
||||
|
||||
/// Now define the inplace multiplication
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>&
|
||||
SGQuat<T>::operator*=(const SGQuat& v)
|
||||
{ (*this) = (*this)*v; return *this; }
|
||||
|
||||
/// The conjugate of the quaternion, this is also the
|
||||
/// inverse for normalized quaternions
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
conj(const SGQuat<T>& v)
|
||||
{ return SGQuat<T>(-v(0), -v(1), -v(2), v(3)); }
|
||||
|
||||
/// The conjugate of the quaternion, this is also the
|
||||
/// inverse for normalized quaternions
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
inverse(const SGQuat<T>& v)
|
||||
{ return (1/dot(v, v))*SGQuat<T>(-v(0), -v(1), -v(2), v(3)); }
|
||||
|
||||
/// The imagniary part of the quaternion
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
real(const SGQuat<T>& v)
|
||||
{ return v.w(); }
|
||||
|
||||
/// The imagniary part of the quaternion
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec3<T>
|
||||
imag(const SGQuat<T>& v)
|
||||
{ return SGVec3<T>(v.x(), v.y(), v.z()); }
|
||||
|
||||
/// Scalar dot product
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
dot(const SGQuat<T>& v1, const SGQuat<T>& v2)
|
||||
{ return v1(0)*v2(0) + v1(1)*v2(1) + v1(2)*v2(2) + v1(3)*v2(3); }
|
||||
|
||||
/// The euclidean norm of the vector, that is what most people call length
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
norm(const SGQuat<T>& v)
|
||||
{ return sqrt(dot(v, v)); }
|
||||
|
||||
/// The euclidean norm of the vector, that is what most people call length
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
length(const SGQuat<T>& v)
|
||||
{ return sqrt(dot(v, v)); }
|
||||
|
||||
/// The 1-norm of the vector, this one is the fastest length function we
|
||||
/// can implement on modern cpu's
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
norm1(const SGQuat<T>& v)
|
||||
{ return fabs(v(0)) + fabs(v(1)) + fabs(v(2)) + fabs(v(3)); }
|
||||
|
||||
/// The euclidean norm of the vector, that is what most people call length
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
normalize(const SGQuat<T>& q)
|
||||
{ return (1/norm(q))*q; }
|
||||
|
||||
/// Return true if exactly the same
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator==(const SGQuat<T>& v1, const SGQuat<T>& v2)
|
||||
{ return v1(0)==v2(0) && v1(1)==v2(1) && v1(2)==v2(2) && v1(3)==v2(3); }
|
||||
|
||||
/// Return true if not exactly the same
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator!=(const SGQuat<T>& v1, const SGQuat<T>& v2)
|
||||
{ return ! (v1 == v2); }
|
||||
|
||||
/// Return true if equal to the relative tolerance tol
|
||||
/// Note that this is not the same than comparing quaternions to represent
|
||||
/// the same rotation
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGQuat<T>& v1, const SGQuat<T>& v2, T tol)
|
||||
{ return norm1(v1 - v2) < tol*(norm1(v1) + norm1(v2)); }
|
||||
|
||||
/// Return true if about equal to roundoff of the underlying type
|
||||
/// Note that this is not the same than comparing quaternions to represent
|
||||
/// the same rotation
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGQuat<T>& v1, const SGQuat<T>& v2)
|
||||
{ return equivalent(v1, v2, 100*SGLimits<T>::epsilon()); }
|
||||
|
||||
#ifndef NDEBUG
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
isNaN(const SGQuat<T>& v)
|
||||
{
|
||||
return SGMisc<T>::isNaN(v(0)) || SGMisc<T>::isNaN(v(1))
|
||||
|| SGMisc<T>::isNaN(v(2)) || SGMisc<T>::isNaN(v(3));
|
||||
}
|
||||
#endif
|
||||
|
||||
/// quaternion interpolation for t in [0,1] interpolate between src (=0)
|
||||
/// and dst (=1)
|
||||
template<typename T>
|
||||
inline
|
||||
SGQuat<T>
|
||||
interpolate(T t, const SGQuat<T>& src, const SGQuat<T>& dst)
|
||||
{
|
||||
T cosPhi = dot(src, dst);
|
||||
// need to take the shorter way ...
|
||||
int signCosPhi = SGMisc<T>::sign(cosPhi);
|
||||
// cosPhi must be corrected for that sign
|
||||
cosPhi = fabs(cosPhi);
|
||||
|
||||
// first opportunity to fail - make sure acos will succeed later -
|
||||
// result is correct
|
||||
if (1 <= cosPhi)
|
||||
return dst;
|
||||
|
||||
// now the half angle between the orientations
|
||||
T o = acos(cosPhi);
|
||||
|
||||
// need the scales now, if the angle is very small, do linear interpolation
|
||||
// to avoid instabilities
|
||||
T scale0, scale1;
|
||||
if (fabs(o) < SGLimits<T>::epsilon()) {
|
||||
scale0 = 1 - t;
|
||||
scale1 = t;
|
||||
} else {
|
||||
// note that we can give a positive lower bound for sin(o) here
|
||||
T sino = sin(o);
|
||||
T so = 1/sino;
|
||||
scale0 = sin((1 - t)*o)*so;
|
||||
scale1 = sin(t*o)*so;
|
||||
}
|
||||
|
||||
return scale0*src + signCosPhi*scale1*dst;
|
||||
}
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s, const SGQuat<T>& v)
|
||||
{ return s << "[ " << v(0) << ", " << v(1) << ", " << v(2) << ", " << v(3) << " ]"; }
|
||||
|
||||
inline
|
||||
SGQuatf
|
||||
toQuatf(const SGQuatd& v)
|
||||
{ return SGQuatf((float)v(0), (float)v(1), (float)v(2), (float)v(3)); }
|
||||
|
||||
inline
|
||||
SGQuatd
|
||||
toQuatd(const SGQuatf& v)
|
||||
{ return SGQuatd(v(0), v(1), v(2), v(3)); }
|
||||
|
||||
#endif
|
||||
62
simgear/math/SGRay.hxx
Normal file
62
simgear/math/SGRay.hxx
Normal file
@@ -0,0 +1,62 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGRay_H
|
||||
#define SGRay_H
|
||||
|
||||
template<typename T>
|
||||
class SGRay {
|
||||
public:
|
||||
SGRay()
|
||||
{ }
|
||||
SGRay(const SGVec3<T>& origin, const SGVec3<T>& dir) :
|
||||
_origin(origin), _direction(dir)
|
||||
{ }
|
||||
|
||||
void set(const SGVec3<T>& origin, const SGVec3<T>& dir)
|
||||
{ _origin = origin; _direction = dir; }
|
||||
|
||||
void setOrigin(const SGVec3<T>& origin)
|
||||
{ _origin = origin; }
|
||||
const SGVec3<T>& getOrigin() const
|
||||
{ return _origin; }
|
||||
|
||||
void setDirection(const SGVec3<T>& direction)
|
||||
{ _direction = direction; }
|
||||
const SGVec3<T>& getDirection() const
|
||||
{ return _direction; }
|
||||
|
||||
SGVec3<T> getNormalizedDirection() const
|
||||
{ return normalize(getDirection()); }
|
||||
|
||||
private:
|
||||
SGVec3<T> _origin;
|
||||
SGVec3<T> _direction;
|
||||
};
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s,
|
||||
const SGRay<T>& ray)
|
||||
{
|
||||
return s << "ray: origin = " << ray.getOrigin()
|
||||
<< ", direction = " << ray.getDirection();
|
||||
}
|
||||
|
||||
#endif
|
||||
87
simgear/math/SGSphere.hxx
Normal file
87
simgear/math/SGSphere.hxx
Normal file
@@ -0,0 +1,87 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGSphere_H
|
||||
#define SGSphere_H
|
||||
|
||||
template<typename T>
|
||||
class SGSphere {
|
||||
public:
|
||||
SGSphere() :
|
||||
_radius(-1)
|
||||
{ }
|
||||
SGSphere(const SGVec3<T>& center, const T& radius) :
|
||||
_center(center),
|
||||
_radius(radius)
|
||||
{ }
|
||||
|
||||
const SGVec3<T>& getCenter() const
|
||||
{ return _center; }
|
||||
void setCenter(const SGVec3<T>& center)
|
||||
{ _center = center; }
|
||||
|
||||
const T& getRadius() const
|
||||
{ return _radius; }
|
||||
void setRadius(const T& radius)
|
||||
{ _radius = radius; }
|
||||
T getRadius2() const
|
||||
{ return _radius*_radius; }
|
||||
|
||||
const bool empty() const
|
||||
{ return !valid(); }
|
||||
|
||||
bool valid() const
|
||||
{ return 0 <= _radius; }
|
||||
|
||||
void clear()
|
||||
{ _radius = -1; }
|
||||
|
||||
void expandBy(const SGVec3<T>& v)
|
||||
{
|
||||
if (empty()) {
|
||||
_center = v;
|
||||
_radius = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
T dist2 = distSqr(_center, v);
|
||||
if (dist2 <= getRadius2())
|
||||
return;
|
||||
|
||||
T dist = sqrt(dist2);
|
||||
T newRadius = T(0.5)*(_radius + dist);
|
||||
_center += ((newRadius - _radius)/dist)*(v - _center);
|
||||
_radius = newRadius;
|
||||
}
|
||||
|
||||
private:
|
||||
SGVec3<T> _center;
|
||||
T _radius;
|
||||
};
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s,
|
||||
const SGSphere<T>& sphere)
|
||||
{
|
||||
return s << "center = " << sphere.getCenter()
|
||||
<< ", radius = " << sphere.getRadius();
|
||||
}
|
||||
|
||||
#endif
|
||||
101
simgear/math/SGTriangle.hxx
Normal file
101
simgear/math/SGTriangle.hxx
Normal file
@@ -0,0 +1,101 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGTriangle_H
|
||||
#define SGTrianlge_H
|
||||
|
||||
template<typename T>
|
||||
class SGTriangle {
|
||||
public:
|
||||
SGTriangle()
|
||||
{ }
|
||||
SGTriangle(const SGVec3<T>& v0, const SGVec3<T>& v1, const SGVec3<T>& v2)
|
||||
{ set(v0, v1, v2); }
|
||||
SGTriangle(const SGVec3<T> v[3])
|
||||
{ set(v); }
|
||||
|
||||
void set(const SGVec3<T>& v0, const SGVec3<T>& v1, const SGVec3<T>& v2)
|
||||
{
|
||||
_v0 = v0;
|
||||
_d[0] = v1 - v0;
|
||||
_d[1] = v2 - v0;
|
||||
}
|
||||
void set(const SGVec3<T> v[3])
|
||||
{
|
||||
_v0 = v[0];
|
||||
_d[0] = v[1] - v[0];
|
||||
_d[1] = v[2] - v[0];
|
||||
}
|
||||
|
||||
SGVec3d getCenter() const
|
||||
{
|
||||
SGBoxd box;
|
||||
box.expandBy(_v0);
|
||||
box.expandBy(_v0 + _d[0]);
|
||||
box.expandBy(_v0 + _d[1]);
|
||||
return box.getCenter();
|
||||
}
|
||||
|
||||
// note that the index is unchecked
|
||||
SGVec3<T> getVertex(unsigned i) const
|
||||
{
|
||||
if (0 < i)
|
||||
return _v0 + _d[i-1];
|
||||
return _v0;
|
||||
}
|
||||
/// return the normalized surface normal
|
||||
SGVec3<T> getNormal() const
|
||||
{ return normalize(cross(_d[0], _d[1])); }
|
||||
|
||||
const SGVec3<T>& getBaseVertex() const
|
||||
{ return _v0; }
|
||||
void setBaseVertex(const SGVec3<T>& v)
|
||||
{ _v0 = v; }
|
||||
const SGVec3<T>& getEdge(unsigned i) const
|
||||
{ return _d[i]; }
|
||||
void setEdge(unsigned i, const SGVec3<T>& d)
|
||||
{ _d[i] = d; }
|
||||
|
||||
// flip the positive side
|
||||
void flip()
|
||||
{
|
||||
SGVec3<T> tmp = _d[0];
|
||||
_d[0] = _d[1];
|
||||
_d[1] = tmp;
|
||||
}
|
||||
private:
|
||||
/// Store one vertex directly, _d is the offset of the other two
|
||||
/// vertices wrt the base vertex
|
||||
/// For fast intersection tests this format prooves usefull. For that same
|
||||
/// purpose also cache the cross product of the _d[i].
|
||||
SGVec3<T> _v0;
|
||||
SGVec3<T> _d[2];
|
||||
};
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s,
|
||||
const SGTriangle<T>& triangle)
|
||||
{
|
||||
return s << "triangle: v0 = " << triangle.getVertex(0)
|
||||
<< ", v1 = " << triangle.getVertex(1)
|
||||
<< ", v2 = " << triangle.getVertex(2);
|
||||
}
|
||||
|
||||
#endif
|
||||
405
simgear/math/SGVec2.hxx
Normal file
405
simgear/math/SGVec2.hxx
Normal file
@@ -0,0 +1,405 @@
|
||||
// Copyright (C) 2006 Mathias Froehlich - Mathias.Froehlich@web.de
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU Library General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// Library General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
//
|
||||
|
||||
#ifndef SGVec2_H
|
||||
#define SGVec2_H
|
||||
|
||||
#include <osg/Vec2f>
|
||||
#include <osg/Vec2d>
|
||||
|
||||
template<typename T>
|
||||
struct SGVec2Storage {
|
||||
/// Readonly raw storage interface
|
||||
const T (&data(void) const)[2]
|
||||
{ return _data; }
|
||||
/// Readonly raw storage interface
|
||||
T (&data(void))[2]
|
||||
{ return _data; }
|
||||
|
||||
void osg() const
|
||||
{ }
|
||||
|
||||
private:
|
||||
T _data[2];
|
||||
};
|
||||
|
||||
template<>
|
||||
struct SGVec2Storage<float> : public osg::Vec2f {
|
||||
/// Access raw data by index, the index is unchecked
|
||||
const float (&data(void) const)[2]
|
||||
{ return osg::Vec2f::_v; }
|
||||
/// Access raw data by index, the index is unchecked
|
||||
float (&data(void))[2]
|
||||
{ return osg::Vec2f::_v; }
|
||||
|
||||
const osg::Vec2f& osg() const
|
||||
{ return *this; }
|
||||
osg::Vec2f& osg()
|
||||
{ return *this; }
|
||||
};
|
||||
|
||||
template<>
|
||||
struct SGVec2Storage<double> : public osg::Vec2d {
|
||||
/// Access raw data by index, the index is unchecked
|
||||
const double (&data(void) const)[2]
|
||||
{ return osg::Vec2d::_v; }
|
||||
/// Access raw data by index, the index is unchecked
|
||||
double (&data(void))[2]
|
||||
{ return osg::Vec2d::_v; }
|
||||
|
||||
const osg::Vec2d& osg() const
|
||||
{ return *this; }
|
||||
osg::Vec2d& osg()
|
||||
{ return *this; }
|
||||
};
|
||||
|
||||
/// 2D Vector Class
|
||||
template<typename T>
|
||||
class SGVec2 : protected SGVec2Storage<T> {
|
||||
public:
|
||||
typedef T value_type;
|
||||
|
||||
/// Default constructor. Does not initialize at all.
|
||||
/// If you need them zero initialized, use SGVec2::zeros()
|
||||
SGVec2(void)
|
||||
{
|
||||
/// Initialize with nans in the debug build, that will guarantee to have
|
||||
/// a fast uninitialized default constructor in the release but shows up
|
||||
/// uninitialized values in the debug build very fast ...
|
||||
#ifndef NDEBUG
|
||||
for (unsigned i = 0; i < 2; ++i)
|
||||
data()[i] = SGLimits<T>::quiet_NaN();
|
||||
#endif
|
||||
}
|
||||
/// Constructor. Initialize by the given values
|
||||
SGVec2(T x, T y)
|
||||
{ data()[0] = x; data()[1] = y; }
|
||||
/// Constructor. Initialize by the content of a plain array,
|
||||
/// make sure it has at least 2 elements
|
||||
explicit SGVec2(const T* d)
|
||||
{ data()[0] = d[0]; data()[1] = d[1]; }
|
||||
explicit SGVec2(const osg::Vec2f& d)
|
||||
{ data()[0] = d[0]; data()[1] = d[1]; }
|
||||
explicit SGVec2(const osg::Vec2d& d)
|
||||
{ data()[0] = d[0]; data()[1] = d[1]; }
|
||||
|
||||
/// Access by index, the index is unchecked
|
||||
const T& operator()(unsigned i) const
|
||||
{ return data()[i]; }
|
||||
/// Access by index, the index is unchecked
|
||||
T& operator()(unsigned i)
|
||||
{ return data()[i]; }
|
||||
|
||||
/// Access raw data by index, the index is unchecked
|
||||
const T& operator[](unsigned i) const
|
||||
{ return data()[i]; }
|
||||
/// Access raw data by index, the index is unchecked
|
||||
T& operator[](unsigned i)
|
||||
{ return data()[i]; }
|
||||
|
||||
/// Access the x component
|
||||
const T& x(void) const
|
||||
{ return data()[0]; }
|
||||
/// Access the x component
|
||||
T& x(void)
|
||||
{ return data()[0]; }
|
||||
/// Access the y component
|
||||
const T& y(void) const
|
||||
{ return data()[1]; }
|
||||
/// Access the y component
|
||||
T& y(void)
|
||||
{ return data()[1]; }
|
||||
|
||||
/// Get the data pointer
|
||||
using SGVec2Storage<T>::data;
|
||||
|
||||
/// Readonly interface function to ssg's sgVec2/sgdVec2
|
||||
const T (&sg(void) const)[2]
|
||||
{ return data(); }
|
||||
/// Interface function to ssg's sgVec2/sgdVec2
|
||||
T (&sg(void))[2]
|
||||
{ return data(); }
|
||||
|
||||
/// Interface function to osg's Vec2*
|
||||
using SGVec2Storage<T>::osg;
|
||||
|
||||
/// Inplace addition
|
||||
SGVec2& operator+=(const SGVec2& v)
|
||||
{ data()[0] += v(0); data()[1] += v(1); return *this; }
|
||||
/// Inplace subtraction
|
||||
SGVec2& operator-=(const SGVec2& v)
|
||||
{ data()[0] -= v(0); data()[1] -= v(1); return *this; }
|
||||
/// Inplace scalar multiplication
|
||||
template<typename S>
|
||||
SGVec2& operator*=(S s)
|
||||
{ data()[0] *= s; data()[1] *= s; return *this; }
|
||||
/// Inplace scalar multiplication by 1/s
|
||||
template<typename S>
|
||||
SGVec2& operator/=(S s)
|
||||
{ return operator*=(1/T(s)); }
|
||||
|
||||
/// Return an all zero vector
|
||||
static SGVec2 zeros(void)
|
||||
{ return SGVec2(0, 0); }
|
||||
/// Return unit vectors
|
||||
static SGVec2 e1(void)
|
||||
{ return SGVec2(1, 0); }
|
||||
static SGVec2 e2(void)
|
||||
{ return SGVec2(0, 1); }
|
||||
};
|
||||
|
||||
/// Unary +, do nothing ...
|
||||
template<typename T>
|
||||
inline
|
||||
const SGVec2<T>&
|
||||
operator+(const SGVec2<T>& v)
|
||||
{ return v; }
|
||||
|
||||
/// Unary -, do nearly nothing
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
operator-(const SGVec2<T>& v)
|
||||
{ return SGVec2<T>(-v(0), -v(1)); }
|
||||
|
||||
/// Binary +
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
operator+(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return SGVec2<T>(v1(0)+v2(0), v1(1)+v2(1)); }
|
||||
|
||||
/// Binary -
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
operator-(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return SGVec2<T>(v1(0)-v2(0), v1(1)-v2(1)); }
|
||||
|
||||
/// Scalar multiplication
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
operator*(S s, const SGVec2<T>& v)
|
||||
{ return SGVec2<T>(s*v(0), s*v(1)); }
|
||||
|
||||
/// Scalar multiplication
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
operator*(const SGVec2<T>& v, S s)
|
||||
{ return SGVec2<T>(s*v(0), s*v(1)); }
|
||||
|
||||
/// multiplication as a multiplicator, that is assume that the first vector
|
||||
/// represents a 2x2 diagonal matrix with the diagonal elements in the vector.
|
||||
/// Then the result is the product of that matrix times the second vector.
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
mult(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return SGVec2<T>(v1(0)*v2(0), v1(1)*v2(1)); }
|
||||
|
||||
/// component wise min
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
min(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{return SGVec2<T>(SGMisc<T>::min(v1(0), v2(0)), SGMisc<T>::min(v1(1), v2(1)));}
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
min(const SGVec2<T>& v, S s)
|
||||
{ return SGVec2<T>(SGMisc<T>::min(s, v(0)), SGMisc<T>::min(s, v(1))); }
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
min(S s, const SGVec2<T>& v)
|
||||
{ return SGVec2<T>(SGMisc<T>::min(s, v(0)), SGMisc<T>::min(s, v(1))); }
|
||||
|
||||
/// component wise max
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
max(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{return SGVec2<T>(SGMisc<T>::max(v1(0), v2(0)), SGMisc<T>::max(v1(1), v2(1)));}
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
max(const SGVec2<T>& v, S s)
|
||||
{ return SGVec2<T>(SGMisc<T>::max(s, v(0)), SGMisc<T>::max(s, v(1))); }
|
||||
template<typename S, typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
max(S s, const SGVec2<T>& v)
|
||||
{ return SGVec2<T>(SGMisc<T>::max(s, v(0)), SGMisc<T>::max(s, v(1))); }
|
||||
|
||||
/// Scalar dot product
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
dot(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return v1(0)*v2(0) + v1(1)*v2(1); }
|
||||
|
||||
/// The euclidean norm of the vector, that is what most people call length
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
norm(const SGVec2<T>& v)
|
||||
{ return sqrt(dot(v, v)); }
|
||||
|
||||
/// The euclidean norm of the vector, that is what most people call length
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
length(const SGVec2<T>& v)
|
||||
{ return sqrt(dot(v, v)); }
|
||||
|
||||
/// The 1-norm of the vector, this one is the fastest length function we
|
||||
/// can implement on modern cpu's
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
norm1(const SGVec2<T>& v)
|
||||
{ return fabs(v(0)) + fabs(v(1)); }
|
||||
|
||||
/// The inf-norm of the vector
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
normI(const SGVec2<T>& v)
|
||||
{ return SGMisc<T>::max(fabs(v(0)), fabs(v(1))); }
|
||||
|
||||
/// The euclidean norm of the vector, that is what most people call length
|
||||
template<typename T>
|
||||
inline
|
||||
SGVec2<T>
|
||||
normalize(const SGVec2<T>& v)
|
||||
{ return (1/norm(v))*v; }
|
||||
|
||||
/// Return true if exactly the same
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator==(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return v1(0) == v2(0) && v1(1) == v2(1); }
|
||||
|
||||
/// Return true if not exactly the same
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator!=(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return ! (v1 == v2); }
|
||||
|
||||
/// Return true if smaller, good for putting that into a std::map
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator<(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{
|
||||
if (v1(0) < v2(0)) return true;
|
||||
else if (v2(0) < v1(0)) return false;
|
||||
else return (v1(1) < v2(1));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator<=(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{
|
||||
if (v1(0) < v2(0)) return true;
|
||||
else if (v2(0) < v1(0)) return false;
|
||||
else return (v1(1) <= v2(1));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator>(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return operator<(v2, v1); }
|
||||
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
operator>=(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return operator<=(v2, v1); }
|
||||
|
||||
/// Return true if equal to the relative tolerance tol
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGVec2<T>& v1, const SGVec2<T>& v2, T rtol, T atol)
|
||||
{ return norm1(v1 - v2) < rtol*(norm1(v1) + norm1(v2)) + atol; }
|
||||
|
||||
/// Return true if equal to the relative tolerance tol
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGVec2<T>& v1, const SGVec2<T>& v2, T rtol)
|
||||
{ return norm1(v1 - v2) < rtol*(norm1(v1) + norm1(v2)); }
|
||||
|
||||
/// Return true if about equal to roundoff of the underlying type
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
equivalent(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{
|
||||
T tol = 100*SGLimits<T>::epsilon();
|
||||
return equivalent(v1, v2, tol, tol);
|
||||
}
|
||||
|
||||
/// The euclidean distance of the two vectors
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
dist(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ return norm(v1 - v2); }
|
||||
|
||||
/// The squared euclidean distance of the two vectors
|
||||
template<typename T>
|
||||
inline
|
||||
T
|
||||
distSqr(const SGVec2<T>& v1, const SGVec2<T>& v2)
|
||||
{ SGVec2<T> tmp = v1 - v2; return dot(tmp, tmp); }
|
||||
|
||||
#ifndef NDEBUG
|
||||
template<typename T>
|
||||
inline
|
||||
bool
|
||||
isNaN(const SGVec2<T>& v)
|
||||
{
|
||||
return SGMisc<T>::isNaN(v(0)) || SGMisc<T>::isNaN(v(1));
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Output to an ostream
|
||||
template<typename char_type, typename traits_type, typename T>
|
||||
inline
|
||||
std::basic_ostream<char_type, traits_type>&
|
||||
operator<<(std::basic_ostream<char_type, traits_type>& s, const SGVec2<T>& v)
|
||||
{ return s << "[ " << v(0) << ", " << v(1) << " ]"; }
|
||||
|
||||
inline
|
||||
SGVec2f
|
||||
toVec2f(const SGVec2d& v)
|
||||
{ return SGVec2f((float)v(0), (float)v(1)); }
|
||||
|
||||
inline
|
||||
SGVec2d
|
||||
toVec2d(const SGVec2f& v)
|
||||
{ return SGVec2d(v(0), v(1)); }
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user