author | koda |
Fri, 05 Apr 2013 22:57:31 +0200 | |
changeset 8874 | 8121ce2b0a88 |
parent 8838 | aa2ffd427f6a |
child 8847 | ff7fbab7cd56 |
child 8905 | 82b1400f4a08 |
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 |
5122 | 87 |
function hwSqrt(const t: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t. |
88 |
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. |
|
89 |
function DistanceI(const dx, dy: LongInt): hwFloat; // Same as above for integer parameters. |
|
515 | 90 |
function AngleSin(const Angle: Longword): hwFloat; |
91 |
function AngleCos(const Angle: Longword): hwFloat; |
|
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
92 |
function vector2Angle(const x, y: hwFloat): LongInt; |
5122 | 93 |
function SignAs(const num, signum: hwFloat): hwFloat; inline; // Returns an hwFloat with the value of parameter num and the sign of signum. |
94 |
function hwSign(r: hwFloat): LongInt; inline; // Returns an integer with value 1 and sign of parameter r. |
|
6879 | 95 |
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
|
96 |
function isZero(const z: hwFloat): boolean; inline; |
2599 | 97 |
{$IFDEF FPC} |
538 | 98 |
{$J-} |
2599 | 99 |
{$ENDIF} |
611 | 100 |
{$WARNINGS OFF} |
5122 | 101 |
|
102 |
||
103 |
// some hwFloat constants |
|
104 |
||
351 | 105 |
const _1div1024: hwFloat = (isNegative: false; QWordValue: 4194304); |
106 |
_1div10000: hwFloat = (isNegative: false; QWordValue: 429496); |
|
107 |
_1div50000: hwFloat = (isNegative: false; QWordValue: 85899); |
|
108 |
_1div100000: hwFloat = (isNegative: false; QWordValue: 42950); |
|
109 |
_1div3: hwFloat = (isNegative: false; QWordValue: 1431655766); |
|
110 |
hwPi: hwFloat = (isNegative: false; QWordValue: 13493037704); |
|
111 |
_0_000004: hwFloat = (isNegative: false; QWordValue: 17179); |
|
3591 | 112 |
_0_000064: hwFloat = (isNegative: false; QWordValue: 274878); |
351 | 113 |
_0_0002: hwFloat = (isNegative: false; QWordValue: 858993); |
1586 | 114 |
_0_0005: hwFloat = (isNegative: false; QWordValue: 2147484); |
351 | 115 |
_0_001: hwFloat = (isNegative: false; QWordValue: 4294967); |
116 |
_0_003: hwFloat = (isNegative: false; QWordValue: 12884902); |
|
7663 | 117 |
_0_0032: hwFloat = (isNegative: false; QWordValue: 13743895); |
351 | 118 |
_0_004: hwFloat = (isNegative: false; QWordValue: 17179869); |
119 |
_0_005: hwFloat = (isNegative: false; QWordValue: 21474836); |
|
3428 | 120 |
_0_008: hwFloat = (isNegative: false; QWordValue: 34359738); |
351 | 121 |
_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
|
122 |
_0_0128: hwFloat = (isNegative: false; QWordValue: 54975581); |
351 | 123 |
_0_02: hwFloat = (isNegative: false; QWordValue: 85899345); |
124 |
_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
|
125 |
_0_07: hwFloat = (isNegative: false; QWordValue: 300647710); |
351 | 126 |
_0_08: hwFloat = (isNegative: false; QWordValue: 343597383); |
365 | 127 |
_0_1: hwFloat = (isNegative: false; QWordValue: 429496730); |
351 | 128 |
_0_15: hwFloat = (isNegative: false; QWordValue: 644245094); |
129 |
_0_2: hwFloat = (isNegative: false; QWordValue: 858993459); |
|
130 |
_0_25: hwFloat = (isNegative: false; QWordValue: 1073741824); |
|
131 |
_0_3: hwFloat = (isNegative: false; QWordValue: 1288490189); |
|
132 |
_0_35: hwFloat = (isNegative: false; QWordValue: 1503238553); |
|
2784 | 133 |
_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
|
134 |
_0_39: hwFloat = (isNegative: false; QWordValue: 1675037245); |
351 | 135 |
_0_4: hwFloat = (isNegative: false; QWordValue: 1717986918); |
136 |
_0_45: hwFloat = (isNegative: false; QWordValue: 1932735283); |
|
137 |
_0_5: hwFloat = (isNegative: false; QWordValue: 2147483648); |
|
138 |
_0_55: hwFloat = (isNegative: false; QWordValue: 2362232012); |
|
139 |
_0_6: hwFloat = (isNegative: false; QWordValue: 2576980377); |
|
3583 | 140 |
_0_64: hwFloat = (isNegative: false; QWordValue: 2748779064); |
358 | 141 |
_0_7: hwFloat = (isNegative: false; QWordValue: 3006477107); |
351 | 142 |
_0_8: hwFloat = (isNegative: false; QWordValue: 3435973837); |
143 |
_0_84: hwFloat = (isNegative: false; QWordValue: 3607772528); |
|
144 |
_0_87: hwFloat = (isNegative: false; QWordValue: 3736621547); |
|
145 |
_0_9: hwFloat = (isNegative: false; QWordValue: 3865470566); |
|
146 |
_0_93: hwFloat = (isNegative: false; QWordValue: 3994319585); |
|
147 |
_0_96: hwFloat = (isNegative: false; QWordValue: 4123168604); |
|
148 |
_0_995: hwFloat = (isNegative: false; QWordValue: 4273492459); |
|
149 |
_0_999: hwFloat = (isNegative: false; QWordValue: 4290672328); |
|
498 | 150 |
_0: hwFloat = (isNegative: false; QWordValue: 0); |
151 |
_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
|
152 |
_1_2: hwFloat = (isNegative: false; QWordValue: 1288490189*4); |
513
69e06d710d46
Moving hedgehog could get another hedgehog moving forward
unc0rr
parents:
498
diff
changeset
|
153 |
_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
|
154 |
_1_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 8 div 5); |
3584 | 155 |
_1_9: hwFloat = (isNegative: false; QWordValue: 8160437862); |
498 | 156 |
_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
|
157 |
_2_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12 div 5); |
498 | 158 |
_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
|
159 |
_3_2: hwFloat = (isNegative: false; QWordValue: 3435973837*4); |
6785 | 160 |
_PI: hwFloat = (isNegative: false; QWordValue: 13493037704); |
498 | 161 |
_4: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4); |
6498 | 162 |
_4_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 9 div 2); |
498 | 163 |
_5: hwFloat = (isNegative: false; QWordValue: 4294967296 * 5); |
164 |
_6: hwFloat = (isNegative: false; QWordValue: 4294967296 * 6); |
|
7594 | 165 |
_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
|
166 |
_7: hwFloat = (isNegative: false; QWordValue: 4294967296 * 7); |
498 | 167 |
_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
|
168 |
_12: hwFloat = (isNegative: false; QWordValue: 4294967296 * 12); |
498 | 169 |
_16: hwFloat = (isNegative: false; QWordValue: 4294967296 * 16); |
170 |
_19: hwFloat = (isNegative: false; QWordValue: 4294967296 * 19); |
|
171 |
_20: hwFloat = (isNegative: false; QWordValue: 4294967296 * 20); |
|
172 |
_25: hwFloat = (isNegative: false; QWordValue: 4294967296 * 25); |
|
173 |
_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
|
174 |
_40: hwFloat = (isNegative: false; QWordValue: 4294967296 * 40); |
7594 | 175 |
_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
|
176 |
_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
|
177 |
_50: hwFloat = (isNegative: false; QWordValue: 4294967296 * 50); |
2933 | 178 |
_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
|
179 |
_90: hwFloat = (isNegative: false; QWordValue: 4294967296 * 90); |
498 | 180 |
_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
|
181 |
_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
|
182 |
_250: hwFloat = (isNegative: false; QWordValue: 4294967296 * 250); |
1915 | 183 |
_256: hwFloat = (isNegative: false; QWordValue: 4294967296 * 256); |
1124 | 184 |
_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
|
185 |
_360: hwFloat = (isNegative: false; QWordValue: 4294967296 * 360); |
498 | 186 |
_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
|
187 |
_1000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1000); |
611 | 188 |
_1024: hwFloat = (isNegative: false; QWordValue: 4294967296 * 1024); |
189 |
_2048: hwFloat = (isNegative: false; QWordValue: 4294967296 * 2048); |
|
1753 | 190 |
_4096: hwFloat = (isNegative: false; QWordValue: 4294967296 * 4096); |
498 | 191 |
_10000: hwFloat = (isNegative: false; QWordValue: 4294967296 * 10000); |
351 | 192 |
|
193 |
cLittle: hwFloat = (isNegative: false; QWordValue: 1); |
|
967 | 194 |
cHHKick: hwFloat = (isNegative: false; QWordValue: 42949673); // _0_01 |
611 | 195 |
{$WARNINGS ON} |
351 | 196 |
{$ENDIF} |
197 |
||
198 |
{$IFNDEF FPC} |
|
199 |
type hwFloat = Extended; |
|
200 |
{$ENDIF} |
|
201 |
||
202 |
implementation |
|
4415 | 203 |
uses uSinTable; |
351 | 204 |
|
3599 | 205 |
|
351 | 206 |
{$IFDEF FPC} |
207 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
208 |
function int2hwFloat (const i: LongInt) : hwFloat; inline; |
351 | 209 |
begin |
498 | 210 |
int2hwFloat.isNegative:= i < 0; |
211 |
int2hwFloat.Round:= abs(i); |
|
212 |
int2hwFloat.Frac:= 0 |
|
351 | 213 |
end; |
214 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
215 |
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
|
216 |
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
|
217 |
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
|
218 |
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
|
219 |
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
|
220 |
end; |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5124
diff
changeset
|
221 |
|
6415 | 222 |
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
|
223 |
begin |
5665 | 224 |
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
|
225 |
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
|
226 |
|
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
227 |
operator + (const z1, z2: hwFloat) z : hwFloat; inline; |
351 | 228 |
begin |
229 |
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
|
230 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
231 |
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
|
232 |
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
|
233 |
end |
351 | 234 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
235 |
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
|
236 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
237 |
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
|
238 |
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
|
239 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
240 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
241 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
242 |
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
|
243 |
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
|
244 |
end |
351 | 245 |
end; |
246 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
247 |
operator - (const z1, z2: hwFloat) z : hwFloat; inline; |
351 | 248 |
begin |
249 |
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
|
250 |
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
|
251 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
252 |
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
|
253 |
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
|
254 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
255 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
256 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
257 |
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
|
258 |
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
|
259 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
260 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
261 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
262 |
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
|
263 |
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
|
264 |
end |
351 | 265 |
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
|
266 |
|
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7614
diff
changeset
|
267 |
function isZero(const z: hwFloat): boolean; inline; |
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7614
diff
changeset
|
268 |
begin |
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7614
diff
changeset
|
269 |
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
|
270 |
end; |
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
271 |
|
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
272 |
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
|
273 |
begin |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
274 |
if z1.isNegative xor z2.isNegative then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
275 |
b:= z1.isNegative |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
276 |
else |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
277 |
if z1.QWordValue = z2.QWordValue then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
278 |
b:= false |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
279 |
else |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
280 |
b:= not((z1.QWordValue = z2.QWordValue) or ((z2.QWordValue < z1.QWordValue) <> z1.isNegative)) |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
281 |
end; |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
282 |
|
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
283 |
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
|
284 |
begin |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
285 |
if z1.isNegative xor z2.isNegative then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
286 |
b:= z2.isNegative |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
287 |
else |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
288 |
if z1.QWordValue = z2.QWordValue then |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
289 |
b:= false |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
290 |
else |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
291 |
b:= (z1.QWordValue > z2.QWordValue) <> z2.isNegative |
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
292 |
end; |
351 | 293 |
|
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
294 |
operator - (const z1: hwFloat) z : hwFloat; inline; |
351 | 295 |
begin |
296 |
z:= z1; |
|
297 |
z.isNegative:= not z.isNegative |
|
298 |
end; |
|
299 |
||
300 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
301 |
operator * (const z1, z2: hwFloat) z : hwFloat; inline; |
351 | 302 |
begin |
303 |
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
|
304 |
z.QWordValue:= QWord(z1.Round) * z2.Frac + QWord(z1.Frac) * z2.Round + ((QWord(z1.Frac) * z2.Frac) shr 32); |
351 | 305 |
z.Round:= z.Round + QWord(z1.Round) * z2.Round; |
306 |
end; |
|
307 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
308 |
operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline; |
351 | 309 |
begin |
310 |
z.isNegative:= z1.isNegative xor (z2 < 0); |
|
515 | 311 |
z.QWordValue:= z1.QWordValue * abs(z2) |
351 | 312 |
end; |
313 |
||
7624
03d662ff9c41
A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents:
7623
diff
changeset
|
314 |
operator / (const z1: hwFloat; z2: hwFloat) z : hwFloat; inline; |
351 | 315 |
var t: hwFloat; |
316 |
begin |
|
317 |
z.isNegative:= z1.isNegative xor z2.isNegative; |
|
318 |
z.Round:= z1.QWordValue div z2.QWordValue; |
|
319 |
t:= z1 - z2 * z.Round; |
|
320 |
if t.QWordValue = 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
|
321 |
z.Frac:= 0 |
351 | 322 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
323 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
324 |
while ((t.QWordValue and $8000000000000000) = 0) and ((z2.QWordValue and $8000000000000000) = 0) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
325 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
326 |
t.QWordValue:= t.QWordValue shl 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
327 |
z2.QWordValue:= z2.QWordValue shl 1 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
328 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
329 |
if z2.Round > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
330 |
z.Frac:= (t.QWordValue) div (z2.Round) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
331 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
332 |
z.Frac:= 0 |
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 |
||
515 | 388 |
function hwSqrt(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 |
395 |
hwSqrt.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 |
|
738 | 428 |
hwSqrt.QWordValue:= l |
357 | 429 |
end; |
430 |
||
515 | 431 |
function Distance(const dx, dy: hwFloat): hwFloat; |
351 | 432 |
begin |
738 | 433 |
Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy)) |
351 | 434 |
end; |
435 |
||
515 | 436 |
function DistanceI(const dx, dy: LongInt): hwFloat; |
498 | 437 |
begin |
856 | 438 |
DistanceI:= hwSqrt(int2hwFloat(sqr(dx) + sqr(dy))) |
498 | 439 |
end; |
440 |
||
515 | 441 |
function SignAs(const num, signum: hwFloat): hwFloat; |
498 | 442 |
begin |
856 | 443 |
SignAs.QWordValue:= num.QWordValue; |
498 | 444 |
SignAs.isNegative:= signum.isNegative |
445 |
end; |
|
446 |
||
4374 | 447 |
function hwSign(r: hwFloat): LongInt; |
448 |
begin |
|
449 |
// 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
|
450 |
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
|
451 |
hwSign:= -1 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
452 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
453 |
hwSign:= 1 |
4374 | 454 |
end; |
455 |
||
6879 | 456 |
function hwSignf(r: real): LongInt; |
6775 | 457 |
begin |
458 |
if r < 0 then |
|
6879 | 459 |
hwSignf:= -1 |
6775 | 460 |
else |
6879 | 461 |
hwSignf:= 1 |
6775 | 462 |
end; |
463 |
||
357 | 464 |
|
515 | 465 |
function AngleSin(const Angle: Longword): hwFloat; |
351 | 466 |
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
|
467 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Sin param exceeds limits', true); |
351 | 468 |
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
|
469 |
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
|
470 |
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
|
471 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
472 |
AngleSin.QWordValue:= SinTable[2048 - Angle] |
351 | 473 |
end; |
474 |
||
515 | 475 |
function AngleCos(const Angle: Longword): hwFloat; |
351 | 476 |
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
|
477 |
//TryDo((Angle >= 0) and (Angle <= 2048), 'Cos param exceeds limits', true); |
357 | 478 |
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
|
479 |
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
|
480 |
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
|
481 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6498
diff
changeset
|
482 |
AngleCos.QWordValue:= SinTable[Angle - 1024] |
351 | 483 |
end; |
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
484 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
485 |
function vector2Angle(const x, y: hwFloat): LongInt; |
7715 | 486 |
var d, nf: hwFloat; |
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
487 |
l, r, c, oc: Longword; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
488 |
n: QWord; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
489 |
begin |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
490 |
d:= _1 / Distance(x, y); |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
491 |
|
7715 | 492 |
nf:= y * d; |
493 |
n:= nf.QWordValue; |
|
7714
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
494 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
495 |
l:= 0; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
496 |
r:= 1024; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
497 |
c:= 0; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
498 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
499 |
repeat |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
500 |
oc:= c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
501 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
502 |
c:= (l + r) shr 1; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
503 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
504 |
if n >= SinTable[c] then |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
505 |
l:= c |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
506 |
else |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
507 |
r:= c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
508 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
509 |
until (oc = c); |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
510 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
511 |
if x.isNegative then c:= 2048 - c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
512 |
if y.isNegative then c:= - c; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
513 |
|
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
514 |
vector2Angle:= c |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
515 |
end; |
981001b84f0b
vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents:
7688
diff
changeset
|
516 |
|
351 | 517 |
{$ENDIF} |
518 |
||
519 |
end. |