author | koda |
Sat, 20 Apr 2013 20:48:33 +0200 | |
branch | 0.9.19 |
changeset 8930 | a71599790f7a |
parent 8924 | 13ac59499066 |
child 9080 | 9b42757d7e71 |
permissions | -rw-r--r-- |
351 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
6700 | 3 |
* Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com> |
351 | 4 |
* |
5 |
* This program is free software; you can redistribute it and/or modify |
|
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
8 |
* |
|
9 |
* This program is distributed in the hope that it will be useful, |
|
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
13 |
* |
|
14 |
* You should have received a copy of the GNU General Public License |
|
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
17 |
*) |
|
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
351 | 21 |
unit uFloat; |
5122 | 22 |
(* |
23 |
* This unit provides a custom data type, hwFloat. |
|
24 |
* |
|
25 |
* hwFloat represents a floating point number - the value and operations |
|
26 |
* of this numbers are independent from the hardware architecture |
|
27 |
* the game runs on. |
|
28 |
* |
|
29 |
* This is important for calculations that affect the course of the game |
|
30 |
* and would lead to different results if based on a hardware dependent |
|
31 |
* data type. |
|
32 |
* |
|
33 |
* Note: Not all comparisons are implemented. |
|
34 |
* |
|
35 |
* Note: Below you'll find a list of hwFloat constants: |
|
36 |
* E.g. _1 is an hwFloat with value 1.0, and -_0_9 is -0.9 |
|
5124 | 37 |
* Use and extend the list if needed, rather than using int2hwFloat() |
38 |
* with integer constants. |
|
5122 | 39 |
*) |
351 | 40 |
interface |
41 |
||
42 |
{$IFDEF FPC} |
|
2599 | 43 |
{$IFDEF ENDIAN_LITTLE} |
351 | 44 |
type hwFloat = record |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
45 |
isNegative: boolean; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
46 |
case byte of |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
47 |
0: (Frac, Round: Longword); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
48 |
1: (QWordValue : QWord); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
49 |
end; |
2599 | 50 |
{$ELSE} |
351 | 51 |
type hwFloat = record |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
52 |
isNegative: boolean; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
53 |
case byte of |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
54 |
0: (Round, Frac: Longword); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
55 |
1: (QWordValue : QWord); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
56 |
end; |
2599 | 57 |
{$ENDIF} |
351 | 58 |
|
5122 | 59 |
// Returns an hwFloat that represents the value of integer parameter i |
3599 | 60 |
function int2hwFloat (const i: LongInt) : hwFloat; inline; |
5151
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
61 |
function hwFloat2Float (const i: hwFloat) : extended; inline; |
351 | 62 |
|
5122 | 63 |
// The implemented operators |
64 |
||
6415 | 65 |
operator = (const z1, z2: hwFloat) z : boolean; inline; |
8838
aa2ffd427f6a
strip PAS2C, old WEB symbols and outdated pas2c sources from default branch, all c-related development is done on the webgl branch
koda
parents:
7715
diff
changeset
|
66 |
|
3599 | 67 |
operator + (const z1, z2: hwFloat) z : hwFloat; inline; |
68 |
operator - (const z1, z2: hwFloat) z : hwFloat; inline; |
|
3929
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
69 |
operator - (const z1: hwFloat) z : hwFloat; inline; |
351 | 70 |
|
3929
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
71 |
operator * (const z1, z2: hwFloat) z : hwFloat; inline; |
3599 | 72 |
operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline; |
3929
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
73 |
operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; inline; |
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
74 |
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline; |
351 | 75 |
|
3929
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
76 |
operator < (const z1, z2: hwFloat) b : boolean; inline; |
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
77 |
operator > (const z1, z2: hwFloat) b : boolean; inline; |
351 | 78 |
|
5122 | 79 |
|
80 |
// Various functions for hwFloat (some are inlined in the resulting code for better performance) |
|
81 |
||
82 |
function cstr(const z: hwFloat): shortstring; // Returns a shortstring representations of the hwFloat. |
|
83 |
function hwRound(const t: hwFloat): LongInt; inline; // Does NOT really round but returns the integer representation of the hwFloat without fractional digits. (-_0_9 -> -0, _1_5 -> _1) |
|
84 |
function hwAbs(const t: hwFloat): hwFloat; inline; // Returns the value of t with positive sign. |
|
85 |
function hwSqr(const t: hwFloat): hwFloat; inline; // Returns the square value of parameter t. |
|
6785 | 86 |
function hwPow(const t: hwFloat; p: LongWord): hwFloat; inline; // Returns the power of the value |
8905
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
87 |
function hwSqrt1(const t: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t. |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
88 |
function hwSqrt(const x: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t. |
5122 | 89 |
function Distance(const dx, dy: hwFloat): hwFloat; // Returns the distance between two points in 2-dimensional space, of which the parameters are the horizontal and vertical distance. |
90 |
function DistanceI(const dx, dy: LongInt): hwFloat; // Same as above for integer parameters. |
|
515 | 91 |
function AngleSin(const Angle: Longword): hwFloat; |
92 |
function AngleCos(const Angle: Longword): hwFloat; |
|
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
93 |
function vector2Angle(const x, y: hwFloat): LongInt; |
5122 | 94 |
function SignAs(const num, signum: hwFloat): hwFloat; inline; // Returns an hwFloat with the value of parameter num and the sign of signum. |
95 |
function hwSign(r: hwFloat): LongInt; inline; // Returns an integer with value 1 and sign of parameter r. |
|
6879 | 96 |
function hwSignf(r: real): LongInt; inline; // Returns an integer with value 1 and sign of parameter r. |
5599
2e4b90f33a83
aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen
Xeli
parents:
5319
diff
changeset
|
97 |
function isZero(const z: hwFloat): boolean; inline; |
2599 | 98 |
{$IFDEF FPC} |
538 | 99 |
{$J-} |
2599 | 100 |
{$ENDIF} |
611 | 101 |
{$WARNINGS OFF} |
5122 | 102 |
|
103 |
||
104 |
// some hwFloat constants |
|
105 |
||
351 | 106 |
const _1div1024: hwFloat = (isNegative: false; QWordValue: 4194304); |
107 |
_1div10000: hwFloat = (isNegative: false; QWordValue: 429496); |
|
108 |
_1div50000: hwFloat = (isNegative: false; QWordValue: 85899); |
|
109 |
_1div100000: hwFloat = (isNegative: false; QWordValue: 42950); |
|
110 |
_1div3: hwFloat = (isNegative: false; QWordValue: 1431655766); |
|
111 |
hwPi: hwFloat = (isNegative: false; QWordValue: 13493037704); |
|
112 |
_0_000004: hwFloat = (isNegative: false; QWordValue: 17179); |
|
3591 | 113 |
_0_000064: hwFloat = (isNegative: false; QWordValue: 274878); |
351 | 114 |
_0_0002: hwFloat = (isNegative: false; QWordValue: 858993); |
1586 | 115 |
_0_0005: hwFloat = (isNegative: false; QWordValue: 2147484); |
351 | 116 |
_0_001: hwFloat = (isNegative: false; QWordValue: 4294967); |
117 |
_0_003: hwFloat = (isNegative: false; QWordValue: 12884902); |
|
7663 | 118 |
_0_0032: hwFloat = (isNegative: false; QWordValue: 13743895); |
351 | 119 |
_0_004: hwFloat = (isNegative: false; QWordValue: 17179869); |
120 |
_0_005: hwFloat = (isNegative: false; QWordValue: 21474836); |
|
3428 | 121 |
_0_008: hwFloat = (isNegative: false; QWordValue: 34359738); |
351 | 122 |
_0_01: hwFloat = (isNegative: false; QWordValue: 42949673); |
7593
b966e2d833f2
An attempt to run main rope code only every 8th tick:
unc0rr
parents:
7515
diff
changeset
|
123 |
_0_0128: hwFloat = (isNegative: false; QWordValue: 54975581); |
351 | 124 |
_0_02: hwFloat = (isNegative: false; QWordValue: 85899345); |
125 |
_0_03: hwFloat = (isNegative: false; QWordValue: 128849018); |
|
6295
5b2b304a91ec
Due to the small values and friction, halve the step in low gravity, instead of the value
nemo
parents:
5843
diff
changeset
|
126 |
_0_07: hwFloat = (isNegative: false; QWordValue: 300647710); |
351 | 127 |
_0_08: hwFloat = (isNegative: false; QWordValue: 343597383); |
365 | 128 |
_0_1: hwFloat = (isNegative: false; QWordValue: 429496730); |
351 | 129 |
_0_15: hwFloat = (isNegative: false; QWordValue: 644245094); |
130 |
_0_2: hwFloat = (isNegative: false; QWordValue: 858993459); |
|
131 |
_0_25: hwFloat = (isNegative: false; QWordValue: 1073741824); |
|
132 |
_0_3: hwFloat = (isNegative: false; QWordValue: 1288490189); |
|
133 |
_0_35: hwFloat = (isNegative: false; QWordValue: 1503238553); |
|
2784 | 134 |
_0_375: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3 div 8); |
835
6f567934cc44
Automatically use parachute when vertical speed is high enough
unc0rr
parents:
745
diff
changeset
|
135 |
_0_39: hwFloat = (isNegative: false; QWordValue: 1675037245); |
351 | 136 |
_0_4: hwFloat = (isNegative: false; QWordValue: 1717986918); |
137 |
_0_45: hwFloat = (isNegative: false; QWordValue: 1932735283); |
|
138 |
_0_5: hwFloat = (isNegative: false; QWordValue: 2147483648); |
|
139 |
_0_55: hwFloat = (isNegative: false; QWordValue: 2362232012); |
|
140 |
_0_6: hwFloat = (isNegative: false; QWordValue: 2576980377); |
|
3583 | 141 |
_0_64: hwFloat = (isNegative: false; QWordValue: 2748779064); |
358 | 142 |
_0_7: hwFloat = (isNegative: false; QWordValue: 3006477107); |
351 | 143 |
_0_8: hwFloat = (isNegative: false; QWordValue: 3435973837); |
144 |
_0_84: hwFloat = (isNegative: false; QWordValue: 3607772528); |
|
145 |
_0_87: hwFloat = (isNegative: false; QWordValue: 3736621547); |
|
146 |
_0_9: hwFloat = (isNegative: false; QWordValue: 3865470566); |
|
147 |
_0_93: hwFloat = (isNegative: false; QWordValue: 3994319585); |
|
148 |
_0_96: hwFloat = (isNegative: false; QWordValue: 4123168604); |
|
149 |
_0_995: hwFloat = (isNegative: false; QWordValue: 4273492459); |
|
150 |
_0_999: hwFloat = (isNegative: false; QWordValue: 4290672328); |
|
498 | 151 |
_0: hwFloat = (isNegative: false; QWordValue: 0); |
152 |
_1: hwFloat = (isNegative: false; QWordValue: 4294967296); |
|
7657
347e18494fb9
Let's try *4 instead. Not nearly as much of a win, but might be usable.
nemo
parents:
7638
diff
changeset
|
153 |
_1_2: hwFloat = (isNegative: false; QWordValue: 1288490189*4); |
513
69e06d710d46
Moving hedgehog could get another hedgehog moving forward
unc0rr
parents:
498
diff
changeset
|
154 |
_1_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3 div 2); |
7593
b966e2d833f2
An attempt to run main rope code only every 8th tick:
unc0rr
parents:
7515
diff
changeset
|
155 |
_1_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 8 div 5); |
3584 | 156 |
_1_9: hwFloat = (isNegative: false; QWordValue: 8160437862); |
498 | 157 |
_2: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2); |
7593
b966e2d833f2
An attempt to run main rope code only every 8th tick:
unc0rr
parents:
7515
diff
changeset
|
158 |
_2_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12 div 5); |
498 | 159 |
_3: hwFloat = (isNegative: false; QWordValue: 4294967296 * 3); |
7657
347e18494fb9
Let's try *4 instead. Not nearly as much of a win, but might be usable.
nemo
parents:
7638
diff
changeset
|
160 |
_3_2: hwFloat = (isNegative: false; QWordValue: 3435973837*4); |
6785 | 161 |
_PI: hwFloat = (isNegative: false; QWordValue: 13493037704); |
498 | 162 |
_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4); |
6498 | 163 |
_4_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 9 div 2); |
498 | 164 |
_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 5); |
165 |
_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 6); |
|
7594 | 166 |
_6_4: hwFloat = (isNegative: false; QWordValue: 3435973837 * 8); |
7593
b966e2d833f2
An attempt to run main rope code only every 8th tick:
unc0rr
parents:
7515
diff
changeset
|
167 |
_7: hwFloat = (isNegative: false; QWordValue: 4294967296 * 7); |
498 | 168 |
_10: hwFloat = (isNegative: false; QWordValue: 4294967296 * 10); |
3422
41ae3c48faa0
* some changes/cleanups to portal, still much to do :/ * reverted nemo's temporary loop fix * notice: small loops possible again, so take care :P, bigger onces should be interrupted
sheepluva
parents:
3407
diff
changeset
|
169 |
_12: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12); |
498 | 170 |
_16: hwFloat = (isNegative: false; QWordValue: 4294967296 * 16); |
171 |
_19: hwFloat = (isNegative: false; QWordValue: 4294967296 * 19); |
|
172 |
_20: hwFloat = (isNegative: false; QWordValue: 4294967296 * 20); |
|
173 |
_25: hwFloat = (isNegative: false; QWordValue: 4294967296 * 25); |
|
174 |
_30: hwFloat = (isNegative: false; QWordValue: 4294967296 * 30); |
|
2955
fb361d137524
Tweak to joke in french locale (everyone always fixes the spelling) updated explosive frames from Palewolf, increase explosive fall damage from 30 to 40
nemo
parents:
2948
diff
changeset
|
175 |
_40: hwFloat = (isNegative: false; QWordValue: 4294967296 * 40); |
7594 | 176 |
_41: hwFloat = (isNegative: false; QWordValue: 4294967296 * 41); |
7593
b966e2d833f2
An attempt to run main rope code only every 8th tick:
unc0rr
parents:
7515
diff
changeset
|
177 |
_49: hwFloat = (isNegative: false; QWordValue: 4294967296 * 49); |
3036
c6ba6531cb4b
Make barrels a little more likely to blow up. 25% more damage in fall
nemo
parents:
2955
diff
changeset
|
178 |
_50: hwFloat = (isNegative: false; QWordValue: 4294967296 * 50); |
2933 | 179 |
_70: hwFloat = (isNegative: false; QWordValue: 4294967296 * 70); |
5599
2e4b90f33a83
aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen
Xeli
parents:
5319
diff
changeset
|
180 |
_90: hwFloat = (isNegative: false; QWordValue: 4294967296 * 90); |
498 | 181 |
_128: hwFloat = (isNegative: false; QWordValue: 4294967296 * 128); |
5599
2e4b90f33a83
aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen
Xeli
parents:
5319
diff
changeset
|
182 |
_180: hwFloat = (isNegative: false; QWordValue: 4294967296 * 180); |
5319
51d8e4747876
bounce. tweak of values, remove friction modifier, move to weapon, to match timer behaviour
nemo
parents:
5192
diff
changeset
|
183 |
_250: hwFloat = (isNegative: false; QWordValue: 4294967296 * 250); |
1915 | 184 |
_256: hwFloat = (isNegative: false; QWordValue: 4294967296 * 256); |
1124 | 185 |
_300: hwFloat = (isNegative: false; QWordValue: 4294967296 * 300); |
5599
2e4b90f33a83
aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen
Xeli
parents:
5319
diff
changeset
|
186 |
_360: hwFloat = (isNegative: false; QWordValue: 4294967296 * 360); |
498 | 187 |
_450: hwFloat = (isNegative: false; QWordValue: 4294967296 * 450); |
5319
51d8e4747876
bounce. tweak of values, remove friction modifier, move to weapon, to match timer behaviour
nemo
parents:
5192
diff
changeset
|
188 |
_1000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1000); |
611 | 189 |
_1024: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1024); |
190 |
_2048: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2048); |
|
1753 | 191 |
_4096: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4096); |
498 | 192 |
_10000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 10000); |
351 | 193 |
|
194 |
cLittle: hwFloat = (isNegative: false; QWordValue: 1); |
|
967 | 195 |
cHHKick: hwFloat = (isNegative: false; QWordValue: 42949673); // _0_01 |
611 | 196 |
{$WARNINGS ON} |
351 | 197 |
{$ENDIF} |
198 |
||
199 |
{$IFNDEF FPC} |
|
200 |
type hwFloat = Extended; |
|
201 |
{$ENDIF} |
|
202 |
||
203 |
implementation |
|
4415 | 204 |
uses uSinTable; |
351 | 205 |
|
3599 | 206 |
|
351 | 207 |
{$IFDEF FPC} |
208 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
209 |
function int2hwFloat (const i: LongInt) : hwFloat; inline; |
351 | 210 |
begin |
498 | 211 |
int2hwFloat.isNegative:= i < 0; |
212 |
int2hwFloat.Round:= abs(i); |
|
213 |
int2hwFloat.Frac:= 0 |
|
351 | 214 |
end; |
215 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
216 |
function hwFloat2Float (const i: hwFloat) : extended; inline; |
5151
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
217 |
begin |
7614
3ae60c8a15f2
Starting to rewrite uFloat routines to avoid QWordValue - in the interests of JS which may get uint64/int64 in the spec in the future but does not have it now.
nemo
parents:
7594
diff
changeset
|
218 |
hwFloat2Float:= i.Frac / $100000000 + i.Round; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
219 |
if i.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
220 |
hwFloat2Float:= -hwFloat2Float; |
5151
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
221 |
end; |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
222 |
|
6415 | 223 |
operator = (const z1, z2: hwFloat) z : boolean; inline; |
5599
2e4b90f33a83
aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen
Xeli
parents:
5319
diff
changeset
|
224 |
begin |
5665 | 225 |
z:= (z1.isNegative = z2.isNegative) and (z1.QWordValue = z2.QWordValue); |
5599
2e4b90f33a83
aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen
Xeli
parents:
5319
diff
changeset
|
226 |
end; |
2e4b90f33a83
aiming fixed, inverted cursor on ammo menu, added equal and isZero function to uFloat, changed the way ammo menu opens, you must now click on the hog rather than anywhere on the screen
Xeli
parents:
5319
diff
changeset
|
227 |
|
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
228 |
operator + (const z1, z2: hwFloat) z : hwFloat; inline; |
351 | 229 |
begin |
230 |
if z1.isNegative = z2.isNegative then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
231 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
232 |
z.isNegative:= z1.isNegative; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
233 |
z.QWordValue:= z1.QWordValue + z2.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
234 |
end |
351 | 235 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
236 |
if z1.QWordValue > z2.QWordValue then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
237 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
238 |
z.isNegative:= z1.isNegative; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
239 |
z.QWordValue:= z1.QWordValue - z2.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
240 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
241 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
242 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
243 |
z.isNegative:= z2.isNegative; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
244 |
z.QWordValue:= z2.QWordValue - z1.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
245 |
end |
351 | 246 |
end; |
247 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
248 |
operator - (const z1, z2: hwFloat) z : hwFloat; inline; |
351 | 249 |
begin |
250 |
if z1.isNegative = z2.isNegative then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
251 |
if z1.QWordValue > z2.QWordValue then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
252 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
253 |
z.isNegative:= z1.isNegative; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
254 |
z.QWordValue:= z1.QWordValue - z2.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
255 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
256 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
257 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
258 |
z.isNegative:= not z2.isNegative; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
259 |
z.QWordValue:= z2.QWordValue - z1.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
260 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
261 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
262 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
263 |
z.isNegative:= z1.isNegative; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
264 |
z.QWordValue:= z1.QWordValue + z2.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
265 |
end |
351 | 266 |
end; |
7623
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7614
diff
changeset
|
267 |
|
8924 | 268 |
function isZero(const z: hwFloat): boolean; inline; |
7623
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7614
diff
changeset
|
269 |
begin |
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7614
diff
changeset
|
270 |
isZero := z.QWordValue = 0; |
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7614
diff
changeset
|
271 |
end; |
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
272 |
|
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
273 |
operator < (const z1, z2: hwFloat) b : boolean; inline; |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
274 |
begin |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
275 |
if z1.isNegative xor z2.isNegative then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
276 |
b:= z1.isNegative |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
277 |
else |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
278 |
if z1.QWordValue = z2.QWordValue then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
279 |
b:= false |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
280 |
else |
8915
36e1574e989d
Trivial optimization. Wonder if compiler was smart enough about it.
unc0rr
parents:
8905
diff
changeset
|
281 |
b:= (z2.QWordValue < z1.QWordValue) = z1.isNegative |
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
282 |
end; |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
283 |
|
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
284 |
operator > (const z1, z2: hwFloat) b : boolean; inline; |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
285 |
begin |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
286 |
if z1.isNegative xor z2.isNegative then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
287 |
b:= z2.isNegative |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
288 |
else |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
289 |
if z1.QWordValue = z2.QWordValue then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
290 |
b:= false |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
291 |
else |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
292 |
b:= (z1.QWordValue > z2.QWordValue) <> z2.isNegative |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
293 |
end; |
351 | 294 |
|
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
295 |
operator - (const z1: hwFloat) z : hwFloat; inline; |
351 | 296 |
begin |
297 |
z:= z1; |
|
298 |
z.isNegative:= not z.isNegative |
|
299 |
end; |
|
300 |
||
301 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
302 |
operator * (const z1, z2: hwFloat) z : hwFloat; inline; |
351 | 303 |
begin |
304 |
z.isNegative:= z1.isNegative xor z2.isNegative; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
305 |
z.QWordValue:= QWord(z1.Round) * z2.Frac + QWord(z1.Frac) * z2.Round + ((QWord(z1.Frac) * z2.Frac) shr 32); |
351 | 306 |
z.Round:= z.Round + QWord(z1.Round) * z2.Round; |
307 |
end; |
|
308 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
309 |
operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline; |
351 | 310 |
begin |
311 |
z.isNegative:= z1.isNegative xor (z2 < 0); |
|
515 | 312 |
z.QWordValue:= z1.QWordValue * abs(z2) |
351 | 313 |
end; |
314 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
315 |
operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; inline; |
8919
67214340fa53
lol, how did it manage to work for years? (z1 - z2 * z.Round) shouldn't respect signs of z1 and z2. It turns out we often had arbitrary .Frac value in division result. Also fixes issue 613.
unc0rr
parents:
8917
diff
changeset
|
316 |
var t: QWord; |
351 | 317 |
begin |
318 |
z.isNegative:= z1.isNegative xor z2.isNegative; |
|
319 |
z.Round:= z1.QWordValue div z2.QWordValue; |
|
8919
67214340fa53
lol, how did it manage to work for years? (z1 - z2 * z.Round) shouldn't respect signs of z1 and z2. It turns out we often had arbitrary .Frac value in division result. Also fixes issue 613.
unc0rr
parents:
8917
diff
changeset
|
320 |
t:= z1.QWordValue - z2.QWordValue * z.Round; |
8916 | 321 |
z.Frac:= 0; |
322 |
||
8919
67214340fa53
lol, how did it manage to work for years? (z1 - z2 * z.Round) shouldn't respect signs of z1 and z2. It turns out we often had arbitrary .Frac value in division result. Also fixes issue 613.
unc0rr
parents:
8917
diff
changeset
|
323 |
if t <> 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
324 |
begin |
8919
67214340fa53
lol, how did it manage to work for years? (z1 - z2 * z.Round) shouldn't respect signs of z1 and z2. It turns out we often had arbitrary .Frac value in division result. Also fixes issue 613.
unc0rr
parents:
8917
diff
changeset
|
325 |
while ((t and $FF00000000000000) = 0) and ((z2.QWordValue and $FF00000000000000) = 0) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
326 |
begin |
8919
67214340fa53
lol, how did it manage to work for years? (z1 - z2 * z.Round) shouldn't respect signs of z1 and z2. It turns out we often had arbitrary .Frac value in division result. Also fixes issue 613.
unc0rr
parents:
8917
diff
changeset
|
327 |
t:= t shl 8; |
8916 | 328 |
z2.QWordValue:= z2.QWordValue shl 8 |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
329 |
end; |
8921 | 330 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
331 |
if z2.Round > 0 then |
8919
67214340fa53
lol, how did it manage to work for years? (z1 - z2 * z.Round) shouldn't respect signs of z1 and z2. It turns out we often had arbitrary .Frac value in division result. Also fixes issue 613.
unc0rr
parents:
8917
diff
changeset
|
332 |
inc(z.QWordValue, t div z2.Round); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
333 |
end |
351 | 334 |
end; |
335 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
336 |
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline; |
498 | 337 |
begin |
338 |
z.isNegative:= z1.isNegative xor (z2 < 0); |
|
515 | 339 |
z.QWordValue:= z1.QWordValue div abs(z2) |
498 | 340 |
end; |
341 |
||
2905 | 342 |
function cstr(const z: hwFloat): shortstring; |
343 |
var tmpstr: shortstring; |
|
351 | 344 |
begin |
345 |
str(z.Round, cstr); |
|
346 |
if z.Frac <> 0 then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
347 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
348 |
str(z.Frac / $100000000, tmpstr); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
349 |
delete(tmpstr, 1, 2); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
350 |
cstr:= cstr + '.' + copy(tmpstr, 1, 10) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
351 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
352 |
if z.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
353 |
cstr:= '-' + cstr |
351 | 354 |
end; |
355 |
||
515 | 356 |
function hwRound(const t: hwFloat): LongInt; |
351 | 357 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
358 |
if t.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
359 |
hwRound:= -(t.Round and $7FFFFFFF) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
360 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
361 |
hwRound:= t.Round and $7FFFFFFF |
351 | 362 |
end; |
363 |
||
515 | 364 |
function hwAbs(const t: hwFloat): hwFloat; |
351 | 365 |
begin |
366 |
hwAbs:= t; |
|
367 |
hwAbs.isNegative:= false |
|
368 |
end; |
|
369 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
370 |
function hwSqr(const t: hwFloat): hwFloat; inline; |
351 | 371 |
begin |
1433 | 372 |
hwSqr.isNegative:= false; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
373 |
hwSqr.QWordValue:= ((QWord(t.Round) * t.Round) shl 32) + QWord(t.Round) * t.Frac * 2 + ((QWord(t.Frac) * t.Frac) shr 32); |
351 | 374 |
end; |
375 |
||
6785 | 376 |
function hwPow(const t: hwFloat;p: LongWord): hwFloat; |
377 |
begin |
|
378 |
hwPow:= t; |
|
7515 | 379 |
if p mod 2 = 0 then hwPow.isNegative:= false; |
6785 | 380 |
|
381 |
while p > 0 do |
|
382 |
begin |
|
383 |
hwPow.QWordValue:= QWord(hwPow.Round) * t.Frac + QWord(hwPow.Frac) * t.Round + ((QWord(hwPow.Frac) * t.Frac) shr 32); |
|
384 |
dec(p) |
|
385 |
end |
|
386 |
end; |
|
387 |
||
8905
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
388 |
function hwSqrt1(const t: hwFloat): hwFloat; |
7688
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
389 |
const pwr = 8; // even value, feel free to adjust |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
390 |
rThreshold = 1 shl (pwr + 32); |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
391 |
lThreshold = 1 shl (pwr div 2 + 32); |
738 | 392 |
var l, r: QWord; |
393 |
c: hwFloat; |
|
357 | 394 |
begin |
8905
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
395 |
hwSqrt1.isNegative:= false; |
744 | 396 |
|
397 |
if t.Round = 0 then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
398 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
399 |
l:= t.QWordValue; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
400 |
r:= $100000000 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
401 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
402 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
403 |
begin |
7688
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
404 |
if t.QWordValue > $FFFFFFFFFFFF then // t.Round > 65535.9999 |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
405 |
begin |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
406 |
l:= $10000000000; // 256 |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
407 |
r:= $FFFFFFFFFFFF; // 65535.9999 |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
408 |
end else |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
409 |
if t.QWordValue >= rThreshold then |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
410 |
begin |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
411 |
l:= lThreshold; |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
412 |
r:= $10000000000; // 256 |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
413 |
end else |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
414 |
begin |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
415 |
l:= $100000000; |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
416 |
r:= lThreshold; |
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
417 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
418 |
end; |
744 | 419 |
|
738 | 420 |
repeat |
7688
9daa06188551
New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents:
7663
diff
changeset
|
421 |
c.QWordValue:= (l + r) shr 1; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
422 |
if hwSqr(c).QWordValue > t.QWordValue then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
423 |
r:= c.QWordValue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
424 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
425 |
l:= c.QWordValue |
738 | 426 |
until r - l <= 1; |
744 | 427 |
|
8905
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
428 |
hwSqrt1.QWordValue:= l |
357 | 429 |
end; |
430 |
||
8905
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
431 |
function hwSqrt(const x: hwFloat): hwFloat; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
432 |
var r, t, s, q: QWord; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
433 |
i: integer; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
434 |
begin |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
435 |
hwSqrt.isNegative:= false; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
436 |
|
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
437 |
t:= $4000000000000000; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
438 |
r:= 0; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
439 |
q:= x.QWordValue; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
440 |
|
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
441 |
for i:= 0 to 31 do |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
442 |
begin |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
443 |
s:= r + t; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
444 |
r:= r shr 1; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
445 |
if s <= q then |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
446 |
begin |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
447 |
dec(q, s); |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
448 |
inc(r, t); |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
449 |
end; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
450 |
t:= t shr 2; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
451 |
end; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
452 |
|
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
453 |
hwSqrt.QWordValue:= r shl 16 |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
454 |
end; |
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
455 |
|
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
456 |
|
82b1400f4a08
New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents:
8838
diff
changeset
|
457 |
|
515 | 458 |
function Distance(const dx, dy: hwFloat): hwFloat; |
8921 | 459 |
var r: QWord; |
351 | 460 |
begin |
8921 | 461 |
r:= dx.QWordValue or dy.QWordValue; |
462 |
||
463 |
if r < $10000 then |
|
464 |
begin |
|
465 |
Distance.QWordValue:= r; |
|
466 |
Distance.isNegative:= false |
|
467 |
end else |
|
468 |
Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy)) |
|
351 | 469 |
end; |
470 |
||
515 | 471 |
function DistanceI(const dx, dy: LongInt): hwFloat; |
498 | 472 |
begin |
856 | 473 |
DistanceI:= hwSqrt(int2hwFloat(sqr(dx) + sqr(dy))) |
498 | 474 |
end; |
475 |
||
515 | 476 |
function SignAs(const num, signum: hwFloat): hwFloat; |
498 | 477 |
begin |
856 | 478 |
SignAs.QWordValue:= num.QWordValue; |
498 | 479 |
SignAs.isNegative:= signum.isNegative |
480 |
end; |
|
481 |
||
4374 | 482 |
function hwSign(r: hwFloat): LongInt; |
483 |
begin |
|
484 |
// yes, we have negative zero for a reason |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
485 |
if r.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
486 |
hwSign:= -1 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
487 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
488 |
hwSign:= 1 |
4374 | 489 |
end; |
490 |
||
6879 | 491 |
function hwSignf(r: real): LongInt; |
6775 | 492 |
begin |
493 |
if r < 0 then |
|
6879 | 494 |
hwSignf:= -1 |
6775 | 495 |
else |
6879 | 496 |
hwSignf:= 1 |
6775 | 497 |
end; |
498 |
||
357 | 499 |
|
515 | 500 |
function AngleSin(const Angle: Longword): hwFloat; |
351 | 501 |
begin |
3929
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
502 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Sin param exceeds limits', true); |
351 | 503 |
AngleSin.isNegative:= false; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
504 |
if Angle < 1024 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
505 |
AngleSin.QWordValue:= SinTable[Angle] |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
506 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
507 |
AngleSin.QWordValue:= SinTable[2048 - Angle] |
351 | 508 |
end; |
509 |
||
515 | 510 |
function AngleCos(const Angle: Longword): hwFloat; |
351 | 511 |
begin |
3929
9a4bbc1f67a2
Inline most of uFloat (saves ~7.5% opcount on a test game), inline a few very short candidates in uMisc, comment out some unused functions in uMisc
nemo
parents:
3599
diff
changeset
|
512 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Cos param exceeds limits', true); |
357 | 513 |
AngleCos.isNegative:= Angle > 1024; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
514 |
if Angle < 1024 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
515 |
AngleCos.QWordValue:= SinTable[1024 - Angle] |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
516 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
517 |
AngleCos.QWordValue:= SinTable[Angle - 1024] |
351 | 518 |
end; |
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
519 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
520 |
function vector2Angle(const x, y: hwFloat): LongInt; |
7715 | 521 |
var d, nf: hwFloat; |
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
522 |
l, r, c, oc: Longword; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
523 |
n: QWord; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
524 |
begin |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
525 |
d:= _1 / Distance(x, y); |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
526 |
|
7715 | 527 |
nf:= y * d; |
528 |
n:= nf.QWordValue; |
|
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
529 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
530 |
l:= 0; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
531 |
r:= 1024; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
532 |
c:= 0; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
533 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
534 |
repeat |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
535 |
oc:= c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
536 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
537 |
c:= (l + r) shr 1; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
538 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
539 |
if n >= SinTable[c] then |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
540 |
l:= c |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
541 |
else |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
542 |
r:= c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
543 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
544 |
until (oc = c); |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
545 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
546 |
if x.isNegative then c:= 2048 - c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
547 |
if y.isNegative then c:= - c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
548 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
549 |
vector2Angle:= c |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
550 |
end; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
551 |
|
351 | 552 |
{$ENDIF} |
553 |
||
554 |
end. |