hedgewars/uFloat.pas
author unC0Rr
Mon, 17 Jun 2013 23:21:53 +0200
branchwebgl
changeset 9240 3a6608ae0a5e
parent 9127 e350500c4edb
child 9968 7fb2f35bdd5b
permissions -rw-r--r--
uscript rendering
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
     1
(*
1066
1f1b3686a2b0 Update copyright headers a bit
unc0rr
parents: 967
diff changeset
     2
 * Hedgewars, a free turn based strategy game
9080
9b42757d7e71 bump copyright year for Andrey entries
unc0rr
parents: 8924
diff changeset
     3
 * Copyright (c) 2004-2013 Andrey Korotaev <unC0Rr@gmail.com>
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
     4
 *
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
     5
 * This program is free software; you can redistribute it and/or modify
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
     6
 * it under the terms of the GNU General Public License as published by
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
     7
 * the Free Software Foundation; version 2 of the License
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
     8
 *
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
     9
 * This program is distributed in the hope that it will be useful,
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    12
 * GNU General Public License for more details.
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    13
 *
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    14
 * You should have received a copy of the GNU General Public License
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    15
 * along with this program; if not, write to the Free Software
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    17
 *)
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    18
2630
079ef82eac75 revamped file access and debug display
koda
parents: 2599
diff changeset
    19
{$INCLUDE "options.inc"}
079ef82eac75 revamped file access and debug display
koda
parents: 2599
diff changeset
    20
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    21
unit uFloat;
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    22
(*
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    23
 * This unit provides a custom data type, hwFloat.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    24
 *
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    25
 * hwFloat represents a floating point number - the value and operations
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    26
 * of this numbers are independent from the hardware architecture
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    27
 * the game runs on.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    28
 *
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    29
 * This is important for calculations that affect the course of the game
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    30
 * and would lead to different results if based on a hardware dependent
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    31
 * data type.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    32
 *
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    33
 * Note: Not all comparisons are implemented.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    34
 *
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    35
 * Note: Below you'll find a list of hwFloat constants:
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    36
 *       E.g. _1 is an hwFloat with value 1.0, and -_0_9 is -0.9
5124
84267f79879b comments
sheepluva
parents: 5122
diff changeset
    37
 *       Use and extend the list if needed, rather than using int2hwFloat()
84267f79879b comments
sheepluva
parents: 5122
diff changeset
    38
 *       with integer constants.
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    39
 *)
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    40
interface
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    41
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    42
{$IFDEF FPC}
2599
c7153d2348f3 move compiler directives to standard pascal
koda
parents: 2587
diff changeset
    43
{$IFDEF ENDIAN_LITTLE}
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    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
c7153d2348f3 move compiler directives to standard pascal
koda
parents: 2587
diff changeset
    50
{$ELSE}
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    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
c7153d2348f3 move compiler directives to standard pascal
koda
parents: 2587
diff changeset
    57
{$ENDIF}
8026
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 7715
diff changeset
    58
		  
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    59
// Returns an hwFloat that represents the value of integer parameter i
3599
715a43602da8 sheepluva's inline patch, fix a crash in overlay
koda
parents: 3591
diff changeset
    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
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    62
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    63
// The implemented operators
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    64
6415
af2047bb4f70 GSoC 2011: Android port - merged mainstream
koda
parents: 6328
diff changeset
    65
operator = (const z1, z2: hwFloat) z : boolean; inline;
7043
7c080e5ac8d0 Some work to make more units compile after conversion to c
unc0rr
parents: 7042
diff changeset
    66
{$IFDEF PAS2C}
7042
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents: 6879
diff changeset
    67
operator <> (const z1, z2: hwFloat) z : boolean; inline;
7043
7c080e5ac8d0 Some work to make more units compile after conversion to c
unc0rr
parents: 7042
diff changeset
    68
{$ENDIF}
3599
715a43602da8 sheepluva's inline patch, fix a crash in overlay
koda
parents: 3591
diff changeset
    69
operator + (const z1, z2: hwFloat) z : hwFloat; inline;
715a43602da8 sheepluva's inline patch, fix a crash in overlay
koda
parents: 3591
diff changeset
    70
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
    71
operator - (const z1: hwFloat) z : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    72
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, z2: hwFloat) z : hwFloat; inline;
3599
715a43602da8 sheepluva's inline patch, fix a crash in overlay
koda
parents: 3591
diff changeset
    74
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
    75
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
    76
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    77
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
    78
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
    79
operator > (const z1, z2: hwFloat) b : boolean; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
    80
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    81
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    82
// Various functions for hwFloat (some are inlined in the resulting code for better performance)
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    83
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    84
function cstr(const z: hwFloat): shortstring; // Returns a shortstring representations of the hwFloat.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    85
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)
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    86
function hwAbs(const t: hwFloat): hwFloat; inline; // Returns the value of t with positive sign.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    87
function hwSqr(const t: hwFloat): hwFloat; inline; // Returns the square value of parameter t.
6785
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
    88
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
    89
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
    90
function hwSqrt(const x: hwFloat): hwFloat; inline; // Returns the the positive square root of parameter t.
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    91
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.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    92
function DistanceI(const dx, dy: LongInt): hwFloat; // Same as above for integer parameters.
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
    93
function AngleSin(const Angle: Longword): hwFloat;
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
    94
function AngleCos(const Angle: Longword): hwFloat;
7714
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
    95
function vector2Angle(const x, y: hwFloat): LongInt;
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    96
function SignAs(const num, signum: hwFloat): hwFloat; inline; // Returns an hwFloat with the value of parameter num and the sign of signum.
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
    97
function hwSign(r: hwFloat): LongInt; inline; // Returns an integer with value 1 and sign of parameter r.
6879
f44042ba755c Simplify converter's life
unc0rr
parents: 6785
diff changeset
    98
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
    99
function isZero(const z: hwFloat): boolean; inline;
2599
c7153d2348f3 move compiler directives to standard pascal
koda
parents: 2587
diff changeset
   100
{$IFDEF FPC}
538
74219eadab5e - Various small fixes
unc0rr
parents: 515
diff changeset
   101
{$J-}
2599
c7153d2348f3 move compiler directives to standard pascal
koda
parents: 2587
diff changeset
   102
{$ENDIF}
611
8cf6d27cec86 Fix warnings
unc0rr
parents: 543
diff changeset
   103
{$WARNINGS OFF}
5122
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
   104
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
   105
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
   106
// some hwFloat constants
9b0513507ba8 some more comments *yawns*
sheepluva
parents: 4976
diff changeset
   107
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   108
const  _1div1024: hwFloat = (isNegative: false; QWordValue:     4194304);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   109
      _1div10000: hwFloat = (isNegative: false; QWordValue:      429496);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   110
      _1div50000: hwFloat = (isNegative: false; QWordValue:       85899);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   111
     _1div100000: hwFloat = (isNegative: false; QWordValue:       42950);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   112
          _1div3: hwFloat = (isNegative: false; QWordValue:  1431655766);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   113
            hwPi: hwFloat = (isNegative: false; QWordValue: 13493037704);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   114
       _0_000004: hwFloat = (isNegative: false; QWordValue:       17179);
3591
sheepluva
parents: 3584
diff changeset
   115
       _0_000064: hwFloat = (isNegative: false; QWordValue:      274878);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   116
         _0_0002: hwFloat = (isNegative: false; QWordValue:      858993);
1586
2c6f1d1f43c1 Adjust flame parameters to produce more damage
unc0rr
parents: 1433
diff changeset
   117
         _0_0005: hwFloat = (isNegative: false; QWordValue:     2147484);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   118
          _0_001: hwFloat = (isNegative: false; QWordValue:     4294967);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   119
          _0_003: hwFloat = (isNegative: false; QWordValue:    12884902);
7663
16e1422aee8e More precision
unc0rr
parents: 7657
diff changeset
   120
         _0_0032: hwFloat = (isNegative: false; QWordValue:    13743895);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   121
          _0_004: hwFloat = (isNegative: false; QWordValue:    17179869);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   122
          _0_005: hwFloat = (isNegative: false; QWordValue:    21474836);
3428
46a2694867bc portal:
sheepluva
parents: 3422
diff changeset
   123
          _0_008: hwFloat = (isNegative: false; QWordValue:    34359738);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   124
           _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
   125
         _0_0128: hwFloat = (isNegative: false; QWordValue:    54975581);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   126
           _0_02: hwFloat = (isNegative: false; QWordValue:    85899345);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   127
           _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
   128
           _0_07: hwFloat = (isNegative: false; QWordValue:   300647710);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   129
           _0_08: hwFloat = (isNegative: false; QWordValue:   343597383);
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 358
diff changeset
   130
            _0_1: hwFloat = (isNegative: false; QWordValue:   429496730);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   131
           _0_15: hwFloat = (isNegative: false; QWordValue:   644245094);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   132
            _0_2: hwFloat = (isNegative: false; QWordValue:   858993459);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   133
           _0_25: hwFloat = (isNegative: false; QWordValue:  1073741824);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   134
            _0_3: hwFloat = (isNegative: false; QWordValue:  1288490189);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   135
           _0_35: hwFloat = (isNegative: false; QWordValue:  1503238553);
2784
1a2e3c7c6a46 King health proportional to team size
nemo
parents: 2630
diff changeset
   136
          _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
   137
           _0_39: hwFloat = (isNegative: false; QWordValue:  1675037245);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   138
            _0_4: hwFloat = (isNegative: false; QWordValue:  1717986918);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   139
           _0_45: hwFloat = (isNegative: false; QWordValue:  1932735283);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   140
            _0_5: hwFloat = (isNegative: false; QWordValue:  2147483648);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   141
           _0_55: hwFloat = (isNegative: false; QWordValue:  2362232012);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   142
            _0_6: hwFloat = (isNegative: false; QWordValue:  2576980377);
3583
13818670ad9e rope: tiny optimisation
sheepluva
parents: 3428
diff changeset
   143
           _0_64: hwFloat = (isNegative: false; QWordValue:  2748779064);
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 357
diff changeset
   144
            _0_7: hwFloat = (isNegative: false; QWordValue:  3006477107);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   145
            _0_8: hwFloat = (isNegative: false; QWordValue:  3435973837);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   146
           _0_84: hwFloat = (isNegative: false; QWordValue:  3607772528);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   147
           _0_87: hwFloat = (isNegative: false; QWordValue:  3736621547);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   148
            _0_9: hwFloat = (isNegative: false; QWordValue:  3865470566);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   149
           _0_93: hwFloat = (isNegative: false; QWordValue:  3994319585);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   150
           _0_96: hwFloat = (isNegative: false; QWordValue:  4123168604);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   151
          _0_995: hwFloat = (isNegative: false; QWordValue:  4273492459);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   152
          _0_999: hwFloat = (isNegative: false; QWordValue:  4290672328);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   153
              _0: hwFloat = (isNegative: false; QWordValue:           0);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   154
              _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
   155
            _1_2: hwFloat = (isNegative: false; QWordValue:  1288490189*4);
513
69e06d710d46 Moving hedgehog could get another hedgehog moving forward
unc0rr
parents: 498
diff changeset
   156
            _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
   157
            _1_6: hwFloat = (isNegative: false; QWordValue:  4294967296 * 8 div 5);
3584
7c05f2e0a8b5 rope: another small optimization
sheepluva
parents: 3583
diff changeset
   158
            _1_9: hwFloat = (isNegative: false; QWordValue:  8160437862);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   159
              _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
   160
            _2_4: hwFloat = (isNegative: false; QWordValue:  4294967296 * 12 div 5);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   161
              _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
   162
            _3_2: hwFloat = (isNegative: false; QWordValue:  3435973837*4);
6785
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   163
             _PI: hwFloat = (isNegative: false; QWordValue: 13493037704);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   164
              _4: hwFloat = (isNegative: false; QWordValue:  4294967296 * 4);
6498
5678806aafca Some tiny optimizations
unc0rr
parents: 6443
diff changeset
   165
            _4_5: hwFloat = (isNegative: false; QWordValue:  4294967296 * 9 div 2);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   166
              _5: hwFloat = (isNegative: false; QWordValue:  4294967296 * 5);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   167
              _6: hwFloat = (isNegative: false; QWordValue:  4294967296 * 6);
7594
5f03595335e6 fromdos + fix end of turn velocity
nemo
parents: 7593
diff changeset
   168
            _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
   169
              _7: hwFloat = (isNegative: false; QWordValue:  4294967296 * 7);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   170
             _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
   171
             _12: hwFloat = (isNegative: false; QWordValue:  4294967296 * 12);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   172
             _16: hwFloat = (isNegative: false; QWordValue:  4294967296 * 16);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   173
             _19: hwFloat = (isNegative: false; QWordValue:  4294967296 * 19);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   174
             _20: hwFloat = (isNegative: false; QWordValue:  4294967296 * 20);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   175
             _25: hwFloat = (isNegative: false; QWordValue:  4294967296 * 25);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   176
             _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
   177
             _40: hwFloat = (isNegative: false; QWordValue:  4294967296 * 40);
7594
5f03595335e6 fromdos + fix end of turn velocity
nemo
parents: 7593
diff changeset
   178
             _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
   179
             _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
   180
             _50: hwFloat = (isNegative: false; QWordValue:  4294967296 * 50);
2933
02af54eb7e1e Experiment with barrels. Add rolling.
nemo
parents: 2905
diff changeset
   181
             _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
   182
             _90: hwFloat = (isNegative: false; QWordValue:  4294967296 * 90);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   183
            _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
   184
            _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
   185
            _250: hwFloat = (isNegative: false; QWordValue:  4294967296 * 250);
1915
c357f5b55320 patch by nemo:
unc0rr
parents: 1753
diff changeset
   186
            _256: hwFloat = (isNegative: false; QWordValue:  4294967296 * 256);
1124
1636a3c7c061 - Airplane is higher
unc0rr
parents: 1066
diff changeset
   187
            _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
   188
            _360: hwFloat = (isNegative: false; QWordValue:  4294967296 * 360);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   189
            _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
   190
           _1000: hwFloat = (isNegative: false; QWordValue:  4294967296 * 1000);
611
8cf6d27cec86 Fix warnings
unc0rr
parents: 543
diff changeset
   191
           _1024: hwFloat = (isNegative: false; QWordValue:  4294967296 * 1024);
8cf6d27cec86 Fix warnings
unc0rr
parents: 543
diff changeset
   192
           _2048: hwFloat = (isNegative: false; QWordValue:  4294967296 * 2048);
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1652
diff changeset
   193
           _4096: hwFloat = (isNegative: false; QWordValue:  4294967296 * 4096);
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   194
          _10000: hwFloat = (isNegative: false; QWordValue:  4294967296 * 10000);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   195
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   196
         cLittle: hwFloat = (isNegative: false; QWordValue:           1);
967
8be3938d73c2 Don't let jumping hedgehog to move others
unc0rr
parents: 953
diff changeset
   197
         cHHKick: hwFloat = (isNegative: false; QWordValue:    42949673);  // _0_01
611
8cf6d27cec86 Fix warnings
unc0rr
parents: 543
diff changeset
   198
{$WARNINGS ON}
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   199
{$ENDIF}
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   200
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   201
{$IFNDEF FPC}
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   202
type hwFloat = Extended;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   203
{$ENDIF}
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   204
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   205
implementation
4415
941251bad467 SinTable.inc -> uSinTable.pas
unc0rr
parents: 4374
diff changeset
   206
uses uSinTable;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   207
3599
715a43602da8 sheepluva's inline patch, fix a crash in overlay
koda
parents: 3591
diff changeset
   208
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   209
{$IFDEF FPC}
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   210
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   211
function int2hwFloat (const i: LongInt) : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   212
begin
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   213
int2hwFloat.isNegative:= i < 0;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   214
int2hwFloat.Round:= abs(i);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   215
int2hwFloat.Frac:= 0
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   216
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   217
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   218
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
   219
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
   220
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
   221
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
   222
    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
   223
end;
cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents: 5124
diff changeset
   224
8026
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 7715
diff changeset
   225
{$IFNDEF WEBGL}
6415
af2047bb4f70 GSoC 2011: Android port - merged mainstream
koda
parents: 6328
diff changeset
   226
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
   227
begin
5665
8805f3167058 fixed = operator in uFloat
Xeli
parents: 5599
diff changeset
   228
    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
   229
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
   230
7043
7c080e5ac8d0 Some work to make more units compile after conversion to c
unc0rr
parents: 7042
diff changeset
   231
{$IFDEF PAS2C}
7042
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents: 6879
diff changeset
   232
operator <> (const z1, z2: hwFloat) z : boolean; inline;
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents: 6879
diff changeset
   233
begin
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents: 6879
diff changeset
   234
    z:= (z1.isNegative <> z2.isNegative) or (z1.QWordValue <> z2.QWordValue);
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents: 6879
diff changeset
   235
end;
7043
7c080e5ac8d0 Some work to make more units compile after conversion to c
unc0rr
parents: 7042
diff changeset
   236
{$ENDIF}
7042
de20086a6bcc Support overloaded operators on (hwFloat op hwFloat) calls
unc0rr
parents: 6879
diff changeset
   237
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   238
operator + (const z1, z2: hwFloat) z : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   239
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   240
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
   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:= z1.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:= 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
   244
    end
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   245
else
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   246
    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
   247
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   248
        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
   249
        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
   250
        end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   251
    else
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:= z2.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:= 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
   255
        end
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   256
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   257
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   258
operator - (const z1, z2: hwFloat) z : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   259
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   260
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
   261
    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
   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
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   266
    else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   267
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   268
        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
   269
        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
   270
        end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   271
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   272
    begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   273
    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
   274
    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
   275
    end
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   276
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
   277
8924
13ac59499066 update 0.9.19 with dev branch
koda
parents: 8921
diff changeset
   278
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
   279
begin
addc5b262617 isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents: 7614
diff changeset
   280
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
   281
end;
7624
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:= z1.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
8915
36e1574e989d Trivial optimization. Wonder if compiler was smart enough about it.
unc0rr
parents: 8905
diff changeset
   291
        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
   292
end;
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   293
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   294
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
   295
begin
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   296
if z1.isNegative xor z2.isNegative then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   297
    b:= z2.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   298
else
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   299
    if z1.QWordValue = z2.QWordValue then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   300
        b:= false
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   301
    else
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   302
        b:= (z1.QWordValue > z2.QWordValue) <> z2.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   303
end;
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
   304
{$ENDIF}
8026
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 7715
diff changeset
   305
{$IFDEF WEBGL}
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
   306
(*
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
   307
    Mostly to be kind to JS as of 2012-08-27 where there is no int64/uint64.  This may change though.
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
   308
*)
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
   309
operator = (const z1, z2: hwFloat) z : boolean; inline;
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
   310
begin
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
   311
    z:= (z1.isNegative = z2.isNegative) and (z1.Frac = z2.Frac) and (z1.Round = z2.Round);
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
   312
end;
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
   313
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
   314
operator <> (const z1, z2: hwFloat) z : boolean; inline;
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
   315
begin
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
   316
    z:= (z1.isNegative <> z2.isNegative) or (z1.Frac <> z2.Frac) or (z1.Round <> z2.Round);
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
   317
end;
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
   318
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   319
operator + (const z1, z2: hwFloat) z : hwFloat; inline;
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
   320
begin
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
   321
if z1.isNegative = z2.isNegative then
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
   322
    begin
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
   323
    z:= z1;
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
   324
    z.Frac:= z.Frac + z2.Frac;
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
   325
    z.Round:= z.Round + z2.Round;
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
   326
    if z.Frac<z1.Frac then inc(z.Round)
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
   327
    end
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
   328
else
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
   329
    if (z1.Round > z2.Round) or ((z1.Round = z2.Round) and (z1.Frac > z2.Frac)) then
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
   330
        begin
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
   331
        z.isNegative:= z1.isNegative;
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
   332
        z.Round:= z1.Round - z2.Round;
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
   333
        z.Frac:= z1.Frac - z2.Frac;
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
   334
        if z2.Frac > z1.Frac then dec(z.Round)
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
   335
        end
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
   336
    else
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
   337
        begin
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
   338
        z.isNegative:= z2.isNegative;
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
   339
        z.Round:= z2.Round - z1.Round;
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
   340
        z.Frac:= z2.Frac-z1.Frac;
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
   341
        if z2.Frac < z1.Frac then dec(z.Round)
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
   342
        end
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
   343
end;
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
   344
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   345
operator - (const z1, z2: hwFloat) z : hwFloat; inline;
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
   346
begin
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
   347
if z1.isNegative = z2.isNegative then
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
   348
    if (z1.Round > z2.Round) or ((z1.Round = z2.Round) and (z1.Frac > z2.Frac)) then
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
   349
        begin
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
   350
        z.isNegative:= z1.isNegative;
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
   351
        z.Round:= z1.Round - z2.Round;
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
   352
        z.Frac:= z1.Frac-z2.Frac;
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
   353
        if z2.Frac > z1.Frac then dec(z.Round)
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
   354
        end
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
   355
    else
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
   356
        begin
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
   357
        z.isNegative:= not z2.isNegative;
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
   358
        z.Round:= z2.Round - z1.Round;
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
   359
        z.Frac:= z2.Frac-z1.Frac;
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
   360
        if z2.Frac < z1.Frac then dec(z.Round)
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
   361
        end
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
   362
else
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
   363
    begin
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
   364
    z:= z1;
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
   365
    z.Frac:= z.Frac + z2.Frac;
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
   366
    z.Round:= z.Round + z2.Round;
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
   367
    if z.Frac<z1.Frac then inc(z.Round)
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
   368
    end
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
   369
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
   370
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   371
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
   372
begin
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   373
if z1.isNegative xor z2.isNegative then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   374
    b:= z1.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   375
else
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   376
(*  Not so sure this specialcase is a win w/ Round/Frac. have to do more tests anyway.
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   377
    if (z1.Round = z2.Round and (z1.Frac = z2.Frac)) then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   378
        b:= false
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   379
    else *)
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   380
        b:= ((z1.Round < z2.Round) or ((z1.Round = z2.Round) and (z1.Frac < z2.Frac))) <> z1.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   381
end;
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   382
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   383
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
   384
begin
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   385
if z1.isNegative xor z2.isNegative then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   386
    b:= z2.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   387
else
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   388
(*
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   389
    if z1.QWordValue = z2.QWordValue then
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   390
        b:= false
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   391
    else*)
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   392
        b:= ((z1.Round > z2.Round) or ((z1.Round = z2.Round) and (z1.Frac > z2.Frac))) <> z1.isNegative
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   393
end;
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   394
7623
addc5b262617 isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents: 7614
diff changeset
   395
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
   396
begin
7638
nemo
parents: 7624
diff changeset
   397
isZero := (z.Round = 0) and (z.Frac = 0);
7623
addc5b262617 isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents: 7614
diff changeset
   398
end;
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
   399
{$ENDIF}
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   400
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   401
operator - (const z1: hwFloat) z : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   402
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   403
z:= z1;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   404
z.isNegative:= not z.isNegative
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   405
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   406
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   407
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   408
operator * (const z1, z2: hwFloat) z : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   409
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   410
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
   411
z.QWordValue:= QWord(z1.Round) * z2.Frac + QWord(z1.Frac) * z2.Round + ((QWord(z1.Frac) * z2.Frac) shr 32);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   412
z.Round:= z.Round + QWord(z1.Round) * z2.Round;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   413
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   414
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   415
operator * (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   416
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   417
z.isNegative:= z1.isNegative xor (z2 < 0);
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   418
z.QWordValue:= z1.QWordValue * abs(z2)
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   419
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   420
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   421
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
   422
var t: QWord;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   423
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   424
z.isNegative:= z1.isNegative xor z2.isNegative;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   425
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
   426
t:= z1.QWordValue - z2.QWordValue * z.Round;
8916
71485c03a507 hwFloat division is ~1.6 times faster now
unc0rr
parents: 8915
diff changeset
   427
z.Frac:= 0;
71485c03a507 hwFloat division is ~1.6 times faster now
unc0rr
parents: 8915
diff changeset
   428
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
   429
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
   430
    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
   431
    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
   432
        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
   433
        t:= t shl 8;
8916
71485c03a507 hwFloat division is ~1.6 times faster now
unc0rr
parents: 8915
diff changeset
   434
        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
   435
        end;
8921
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   436
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   437
    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
   438
        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
   439
    end
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   440
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   441
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   442
operator / (const z1: hwFloat; const z2: LongInt) z : hwFloat; inline;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   443
begin
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   444
z.isNegative:= z1.isNegative xor (z2 < 0);
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   445
z.QWordValue:= z1.QWordValue div abs(z2)
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   446
end;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   447
2905
f3c79f7193a9 Engine:
smxx
parents: 2784
diff changeset
   448
function cstr(const z: hwFloat): shortstring;
f3c79f7193a9 Engine:
smxx
parents: 2784
diff changeset
   449
var tmpstr: shortstring;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   450
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   451
str(z.Round, cstr);
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   452
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
   453
    begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   454
    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
   455
    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
   456
    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
   457
    end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   458
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
   459
    cstr:= '-' + cstr
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   460
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   461
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   462
function hwRound(const t: hwFloat): LongInt;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   463
begin
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   464
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
   465
    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
   466
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   467
    hwRound:= t.Round and $7FFFFFFF
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   468
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   469
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   470
function hwAbs(const t: hwFloat): hwFloat;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   471
begin
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   472
hwAbs:= t;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   473
hwAbs.isNegative:= false
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   474
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   475
7624
03d662ff9c41 A few more operators. Committing in case unc0rr wants to fiddle.
nemo
parents: 7623
diff changeset
   476
function hwSqr(const t: hwFloat): hwFloat; inline;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   477
begin
1433
4af291d5d79c Repair flame dependancy on wind
unc0rr
parents: 1124
diff changeset
   478
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
   479
hwSqr.QWordValue:= ((QWord(t.Round) * t.Round) shl 32) + QWord(t.Round) * t.Frac * 2 + ((QWord(t.Frac) * t.Frac) shr 32);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   480
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   481
6785
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   482
function hwPow(const t: hwFloat;p: LongWord): hwFloat;
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   483
begin
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   484
hwPow:= t;
7515
nemo
parents: 7043
diff changeset
   485
if p mod 2 = 0 then hwPow.isNegative:= false;
6785
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   486
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   487
while p > 0 do
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   488
    begin
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   489
    hwPow.QWordValue:= QWord(hwPow.Round) * t.Frac + QWord(hwPow.Frac) * t.Round + ((QWord(hwPow.Frac) * t.Frac) shr 32);
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   490
    dec(p)
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   491
    end
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   492
end;
a8aa5984185f Allow RC plane to go through portals
nemo
parents: 6775
diff changeset
   493
8905
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   494
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
   495
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
   496
      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
   497
      lThreshold = 1 shl (pwr div 2 + 32);
738
d7f640e99b17 Ignore many files, created by build system
unc0rr
parents: 611
diff changeset
   498
var l, r: QWord;
d7f640e99b17 Ignore many files, created by build system
unc0rr
parents: 611
diff changeset
   499
    c: hwFloat;
357
165a040e4cfa - Fix Blow Torch and Air Attack
unc0rr
parents: 355
diff changeset
   500
begin
8905
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   501
hwSqrt1.isNegative:= false;
744
7a9663194767 - Remove debug
unc0rr
parents: 738
diff changeset
   502
7a9663194767 - Remove debug
unc0rr
parents: 738
diff changeset
   503
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
   504
    begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   505
    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
   506
    r:= $100000000
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   507
    end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   508
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   509
    begin
7688
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   510
    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
   511
        begin
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   512
        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
   513
        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
   514
        end else
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   515
        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
   516
            begin
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   517
            l:= lThreshold;
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   518
            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
   519
            end else
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   520
            begin
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   521
            l:= $100000000;
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   522
            r:= lThreshold;
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   523
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   524
    end;
744
7a9663194767 - Remove debug
unc0rr
parents: 738
diff changeset
   525
738
d7f640e99b17 Ignore many files, created by build system
unc0rr
parents: 611
diff changeset
   526
repeat
7688
9daa06188551 New hwSqrt which is up to 8.7% more efficient than old one on synthetic tests
unc0rr
parents: 7663
diff changeset
   527
    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
   528
    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
   529
        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
   530
    else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   531
        l:= c.QWordValue
738
d7f640e99b17 Ignore many files, created by build system
unc0rr
parents: 611
diff changeset
   532
until r - l <= 1;
744
7a9663194767 - Remove debug
unc0rr
parents: 738
diff changeset
   533
8905
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   534
hwSqrt1.QWordValue:= l
357
165a040e4cfa - Fix Blow Torch and Air Attack
unc0rr
parents: 355
diff changeset
   535
end;
165a040e4cfa - Fix Blow Torch and Air Attack
unc0rr
parents: 355
diff changeset
   536
8905
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   537
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
   538
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
   539
    i: integer;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   540
begin
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   541
hwSqrt.isNegative:= false;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   542
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   543
t:= $4000000000000000;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   544
r:= 0;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   545
q:= x.QWordValue;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   546
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   547
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
   548
    begin
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   549
    s:= r + t;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   550
    r:= r shr 1;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   551
    if s <= q then
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   552
        begin
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   553
        dec(q, s);
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   554
        inc(r, t);
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   555
        end;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   556
    t:= t shr 2;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   557
    end;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   558
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   559
hwSqrt.QWordValue:= r shl 16
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   560
end;
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   561
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   562
82b1400f4a08 New hwSqrt implementation which is 46/19 times faster than the old one!
unc0rr
parents: 8838
diff changeset
   563
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   564
function Distance(const dx, dy: hwFloat): hwFloat;
8921
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   565
var r: QWord;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   566
begin
8921
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   567
r:= dx.QWordValue or dy.QWordValue;
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   568
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   569
if r < $10000 then
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   570
    begin
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   571
    Distance.QWordValue:= r;
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   572
    Distance.isNegative:= false
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   573
    end else
e5db2a42e7e8 - Revert division hack nonsense
unc0rr
parents: 8919
diff changeset
   574
    Distance:= hwSqrt(hwSqr(dx) + hwSqr(dy))
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   575
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   576
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   577
function DistanceI(const dx, dy: LongInt): hwFloat;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   578
begin
856
beecc5c5c71c - Fix braindead shotgun shot arithmetics
unc0rr
parents: 835
diff changeset
   579
DistanceI:= hwSqrt(int2hwFloat(sqr(dx) + sqr(dy)))
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   580
end;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   581
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   582
function SignAs(const num, signum: hwFloat): hwFloat;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   583
begin
856
beecc5c5c71c - Fix braindead shotgun shot arithmetics
unc0rr
parents: 835
diff changeset
   584
SignAs.QWordValue:= num.QWordValue;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   585
SignAs.isNegative:= signum.isNegative
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   586
end;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 493
diff changeset
   587
4374
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 3929
diff changeset
   588
function hwSign(r: hwFloat): LongInt;
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 3929
diff changeset
   589
begin
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 3929
diff changeset
   590
// 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
   591
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
   592
    hwSign:= -1
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   593
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   594
    hwSign:= 1
4374
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 3929
diff changeset
   595
end;
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 3929
diff changeset
   596
6879
f44042ba755c Simplify converter's life
unc0rr
parents: 6785
diff changeset
   597
function hwSignf(r: real): LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6700
diff changeset
   598
begin
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6700
diff changeset
   599
if r < 0 then
6879
f44042ba755c Simplify converter's life
unc0rr
parents: 6785
diff changeset
   600
    hwSignf:= -1
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6700
diff changeset
   601
else
6879
f44042ba755c Simplify converter's life
unc0rr
parents: 6785
diff changeset
   602
    hwSignf:= 1
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6700
diff changeset
   603
end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6700
diff changeset
   604
357
165a040e4cfa - Fix Blow Torch and Air Attack
unc0rr
parents: 355
diff changeset
   605
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   606
function AngleSin(const Angle: Longword): hwFloat;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   607
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
   608
//TryDo((Angle >= 0) and (Angle <= 2048), 'Sin param exceeds limits', true);
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   609
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
   610
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
   611
    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
   612
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   613
    AngleSin.QWordValue:= SinTable[2048 - Angle]
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   614
end;
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   615
515
270f10276d2e - Remove deprecated code
unc0rr
parents: 513
diff changeset
   616
function AngleCos(const Angle: Longword): hwFloat;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   617
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
   618
//TryDo((Angle >= 0) and (Angle <= 2048), 'Cos param exceeds limits', true);
357
165a040e4cfa - Fix Blow Torch and Air Attack
unc0rr
parents: 355
diff changeset
   619
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
   620
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
   621
    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
   622
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6498
diff changeset
   623
    AngleCos.QWordValue:= SinTable[Angle - 1024]
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   624
end;
7714
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   625
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   626
function vector2Angle(const x, y: hwFloat): LongInt;
7715
8b653edac2a2 Shutup pas2c
unc0rr
parents: 7714
diff changeset
   627
var d, nf: hwFloat;
7714
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   628
    l, r, c, oc: Longword;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   629
    n: QWord;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   630
begin
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   631
    d:= _1 / Distance(x, y);
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   632
7715
8b653edac2a2 Shutup pas2c
unc0rr
parents: 7714
diff changeset
   633
    nf:= y * d;
8b653edac2a2 Shutup pas2c
unc0rr
parents: 7714
diff changeset
   634
    n:= nf.QWordValue;
7714
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   635
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   636
    l:= 0;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   637
    r:= 1024;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   638
    c:= 0;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   639
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   640
    repeat
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   641
        oc:= c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   642
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   643
        c:= (l + r) shr 1;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   644
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   645
        if n >= SinTable[c] then
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   646
            l:= c
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   647
        else
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   648
            r:= c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   649
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   650
    until (oc = c);
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   651
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   652
    if x.isNegative then c:= 2048 - c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   653
    if y.isNegative then c:= - c;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   654
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   655
    vector2Angle:= c
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   656
end;
981001b84f0b vector2Angle function which converts vector to angle from -2048 to 2048
unc0rr
parents: 7688
diff changeset
   657
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   658
{$ENDIF}
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   659
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents:
diff changeset
   660
end.