Unit CastleUtils

Description

Uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Description

Various basic utilities.

Lists, using generics derived from standard Generics.Collections. Lists of primitives, like TIntegerList and TFloatList, and a helpful class to define a list of structures TStructList.
Basic operations on numbers (compare, randomize).
Some OS-dependent things.
Some compatibility things, to plug the differences between various versions of FPC and Delphi.
Filenames operations. They do not touch actual files (operations on files are in CastleFilesUtils.)

This unit is a bag for simple and useful things. Let's not overload this unit with too many trivial utilities. When adding new utilities, first consider more specific units, like CastleFilesUtils, CastleStringUtils and CastleClassUtils. This unit does not depend on the standard Classes unit (use CastleClassUtils for utilities on top of Classes).

Initialization of this unit does some generally-useful things:

Makes AnsiString have UTF-8 encoding when compiled with FPC.
See more docs about our approach to String handling in CGE, for both FPC and Delphi. Basically:
- With FPC, we follow Lazarus convention, and String = AnsiString (8-bit) = contains UTF-8.
- With Delphi, we follow Delphi convention, and String = UnicodeString (16-bit) = contains UTF-16.
This way you can just use String throughout your code, and everything will just work.
This way your applications will behave the same, whether they use Delphi, or FPC with LCL (which happens if you use TCastleControl on Lazarus form), or FPC without LCL (which happens if you use TCastleWindow with FPC).
Some code in CGE has to assume that String is encoded like this – e.g. TCastleAbstractFont iterates over Unicode characters in a String, so it assumes that the encoding is as above, for FPC and Delphi.

Source: base/castleutils.pas (line 69).

Uses

BaseUnix
Unix
Dl
Variants
SysUtils
Math
Generics.Collections

Overview

Classes, Interfaces, Objects and Records

Name	Description
Class `EInternalError`	Internal error (bug) in the program.
Class `ECheckFailed`
Class `TNoParameterlessContructor`	Descend from this to hide a parameterless constructor.
Class `TCastleFastList`	Simple fast list.
Class `ELinearInterpolationImpossible`	TStructList
Class `TStructList`	List of structures.
Class `TMethodList`	List of methods (callbacks "of object").
Class `EListsDifferentCount`	Raised by various AssignLerp implementations on lists, like TStructList.AssignLerp, when the arguments have different length.
Class `TWordList`	List of Word (16-bit unsigned) values.
Class `TUInt32List`	List of 32-bit unsigned values.
Class `TFloatList`	List of Float values (defined in Math unit as float with maximum precision).
Class `TSingleList`	List of Single (single-precision floating point) values.
Class `TDoubleList`	List of Double (double-precision floating point) values.
Class `TCardinalList`	List of Cardinal (unsigned) values.
Class `TBooleanList`	List of booleans.
Class `TInt32List`	List of 32-bit signed integer values.
Class `TIntegerList`	List of Integer (signed) values.
Class `EShortErrorMessage`	Descend from this to mark exceptions that should be shown in more concise way by ExceptMessage function.
Class `TCodeBreaker`	Special class to raise an exception that is always catched.
Class `EVectorInvalidOp`
Class `ETransformedResultInvalid`

Functions and Procedures

function Platform: TCastlePlatform;

function PlatformToStr(const T: TCastlePlatform): String;

function StrToPlatform(const S: String): TCastlePlatform;

procedure Check(TrueValue: boolean; const ErrMessage: string = 'Check failed');

function ArrayPosStr(const A: String; const Arr: array of String): Integer; overload;

function ArrayPosText(const A: String; const Arr: array of String; const IgnoreCase: boolean = true): Integer; overload;

function ArrayContainsString(const A: String; const Arr: array of String): Boolean;

function Iff(boolval: boolean; trueval, falseval: string) : string; overload;

function Iff(boolval: boolean; trueval, falseval: Integer) : Integer; overload;

function Iff(boolval: boolean; trueval, falseval: Float) : Float; overload;

function Iff(boolval: boolean; trueval, falseval: Cardinal): Cardinal; overload;

function Iff(boolval: boolean; trueval, falseval: char) : char; overload;

function SCompilerDescription: string;

function SPlatformDescription: String;

function SCastleEngineProgramHelpSuffix(const AppName, AppVersion: String; const Ignored: Boolean): String; deprecated 'use ApplicationProperties.Description';

procedure OSCheck(TrueValue: boolean); overload;

procedure OSCheck(TrueValue: boolean; const Place: string); overload;

function FormatDot(const Fmt: String; const Args: array of const): String;

function FloatToStrDot(const Value: Extended): String;

function FloatToStrFDot(const Value: Extended; const FloatFormat: TFloatFormat; const Precision: Integer; const Digits: Integer): String;

function FloatToStrDisplay(const AValue: Extended; const ADigits: Byte = DefaultFloatStrDigits): String;

function TryStrToFloatDot(const S: String; out Value: Single): Boolean; overload;

function TryStrToFloatDot(const S: String; out Value: Double): Boolean; overload;

function StrToFloatDot(const S: String): Extended;

function StrToFloatDefDot(Const S: String; const Default: Extended): Extended;

function CastleApplicationMode: TCastleApplicationMode;

function CastleDesignMode: Boolean;

function ExceptMessage(const E: TObject): string;

procedure ProgramBreak; deprecated 'Use Halt';

function CastleReadLink(const FileName: string): string;

procedure SwapValues(var a, b: Byte ); overload; inline;

procedure SwapValues(var a, b: Int64 ); overload; inline;

procedure SwapValues(var a, b: QWord ); overload; inline;

procedure SwapValues(var a, b: Int32 ); overload; inline;

procedure SwapValues(var a, b: UInt32 ); overload; inline;

procedure SwapValues(var a, b: Single ); overload; inline;

procedure SwapValues(var a, b: Double ); overload; inline;

procedure SwapValues(var a, b: char ); overload; inline;

procedure SwapValues(var a, b: Pointer ); overload; inline;

procedure OrderUp(var Smaller, Larger: Int64 ); overload; inline;

procedure OrderUp(var Smaller, Larger: Int32 ); overload; inline;

procedure OrderUp(var Smaller, Larger: UInt32 ); overload; inline;

procedure OrderUp(var Smaller, Larger: Single ); overload; inline;

procedure OrderUp(var Smaller, Larger: Double ); overload; inline;

procedure OrderUp(x, y: Int32 ; var Smaller, Larger: Int32 ); overload; inline;

procedure OrderUp(x, y: UInt32; var Smaller, Larger: UInt32 ); overload; inline;

procedure OrderUp(x, y: Single; var Smaller, Larger: Single ); overload; inline;

procedure OrderUp(x, y: Double; var Smaller, Larger: Double ); overload; inline;

procedure MinVar(var a: Word ; const b: Word ); overload; inline;

procedure MinVar(var a: Int64 ; const b: Int64 ); overload; inline;

procedure MinVar(var a: Int32 ; const b: Int32 ); overload; inline;

procedure MinVar(var a: UInt32 ; const b: UInt32 ); overload; inline;

procedure MinVar(var a: Single ; const b: Single ); overload; inline;

procedure MinVar(var a: Double ; const b: Double ); overload; inline;

procedure MaxVar(var a: Word ; const b: Word ); overload; inline;

procedure MaxVar(var a: Int64 ; const b: Int64 ); overload; inline;

procedure MaxVar(var a: Int32 ; const b: Int32 ); overload; inline;

procedure MaxVar(var a: UInt32 ; const b: UInt32 ); overload; inline;

procedure MaxVar(var a: Single ; const b: Single ); overload; inline;

procedure MaxVar(var a: Double ; const b: Double ); overload; inline;

function IndexMax(const a0, a1, a2: Double): T3DAxis; overload; inline;

function IndexMin(const a0, a1, a2: Double): T3DAxis; overload; inline;

function Between(const a, vBegin, vEnd: Int64 ): boolean; overload; inline;

function Between(const a, vBegin, vEnd: Int32 ): boolean; overload; inline;

function Between(const a, vBegin, vEnd: UInt32 ): boolean; overload; inline;

function Between(const a, vBegin, vEnd: Float ): boolean; overload; inline;

function Between(const a, vBegin, vEnd: Char ): boolean; overload; inline;

function RoundClamp255(const A: Single): Byte; inline;

function Clamped(const a, vBegin, vEnd: Int64 ): Int64 ; overload; inline;

function Clamped(const a, vBegin, vEnd: QWord ): QWord ; overload; inline;

function Clamped(const a, vBegin, vEnd: Int32 ): Int32 ; overload; inline;

function Clamped(const a, vBegin, vEnd: UInt32 ): UInt32 ; overload; inline;

function Clamped(const a, vBegin, vEnd: Single ): Single ; overload; inline;

function Clamped(const a, vBegin, vEnd: Double ): Double ; overload; inline;

procedure ClampVar(var a: Int64 ; const vBegin, vEnd: Int64 ); overload; inline;

procedure ClampVar(var a: QWord ; const vBegin, vEnd: QWord ); overload; inline;

procedure ClampVar(var a: Int32 ; const vBegin, vEnd: Int32 ); overload; inline;

procedure ClampVar(var a: UInt32 ; const vBegin, vEnd: UInt32 ); overload; inline;

procedure ClampVar(var a: Single ; const vBegin, vEnd: Single ); overload; inline;

procedure ClampVar(var a: Double ; const vBegin, vEnd: Double ); overload; inline;

procedure Clamp(var a: Int64 ; const vBegin, vEnd: Int64 ); overload; inline; deprecated 'Use ClampVar';

procedure Clamp(var a: Int32 ; const vBegin, vEnd: Int32 ); overload; inline; deprecated 'Use ClampVar';

procedure Clamp(var a: UInt32 ; const vBegin, vEnd: UInt32 ); overload; inline; deprecated 'Use ClampVar';

procedure Clamp(var a: Single ; const vBegin, vEnd: Single ); overload; inline; deprecated 'Use ClampVar';

procedure Clamp(var a: Double ; const vBegin, vEnd: Double ); overload; inline; deprecated 'Use ClampVar';

procedure RestOf3DCoords(const Coord: T3DAxis; out First, Second: T3DAxis);

procedure RestOf3DCoordsCycle(const Coord: T3DAxis; out First, Second: T3DAxis);

function ChangeIntCycle(Value, Change, MaxValue: Integer): Integer;

function Lerp(const a: Single; const l, h: Int32 ): Single; overload; inline;

function Lerp(const a: Single; const l, h: UInt32 ): Single; overload; inline;

function Lerp(const a, l, h: Single): Single; overload; inline;

function Lerp(const a: Double; const l, h: Int32 ): Double; overload; inline;

function Lerp(const a: Double; const l, h: UInt32 ): Double; overload; inline;

function Lerp(const a, l, h: Double): Double; overload; inline;

function AngleLerp(T, Angle1, Angle2: Single): Single;

function RoundUpToMultiply(value, multiplicator: Integer): Integer;

function BiggestPowerOf2(Value: Cardinal): Cardinal;

function Biggest2Exponent(Value: Cardinal): Integer;

function Smallest2Exponent(Value: Cardinal): Integer;

function Smallest2Power(Value: Cardinal): Cardinal;

function IsPowerOf2(Value: Cardinal): boolean;

function DivRoundUp(const Value, Divider: Cardinal): Cardinal; overload;

function DivRoundUp(const Value, Divider: Integer): Integer; overload;

function MapRange(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: Integer): Float; overload;

function MapRange(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: Int64 ): Float; overload;

function MapRange(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: QWord ): Float; overload;

function MapRange(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: Float ): Float; overload;

function MapRangeClamped(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: Integer): Float; overload;

function MapRangeClamped(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: Int64 ): Float; overload;

function MapRangeClamped(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: QWord ): Float; overload;

function MapRangeClamped(const SourceVal, SourceBegin, SourceEnd, DestBegin, DestEnd: Float ): Float; overload;

function MapRangeTo01(const SourceVal, SourceBegin, SourceEnd: Single): Single;

function RandomFloatRange(const RangeBegin, RangeEnd: Single): Single; overload;

function RandomFloatRange(const RangeBegin, RangeEnd: Float): Float; overload;

function RandomIntRange(const RangeBegin, RangeEnd: Integer): Integer; overload;

function RandomIntRange(const RangeBegin, RangeEnd: Int64): Int64; overload;

function RandomIntRangeInclusive(const RangeBegin, RangeEnd: Integer): Integer; overload;

function RandomIntRangeInclusive(const RangeBegin, RangeEnd: Int64): Int64; overload;

function RandomBoolean: boolean;

function RandomPlusMinus: Integer;

function AngleRadPointToPoint(x1, y1, x2, y2: Single): Single;

function NatNatPower(Base, Exponent: Cardinal): Cardinal;

function ArcCot(const x: Float): Float;

function SmallFactorial(n: Integer): Int64;

procedure CastleDivMod(Dividend: Integer; Divisor: Word; out Result, Remainder: SmallInt);

procedure DivUnsignedMod(Dividend: Integer; Divisor: Word; out Result: Smallint; out Remainder: Word);

function CeilDiv(const A, B: Cardinal): Cardinal; overload;

function CeilDiv(const A, B: Int64): Int64; overload;

procedure FloatDivMod(const A, B: Double; out DivResult: Int64; out Remainder: Double);

function FloatModulo(const A, B: Double): Double;

procedure MinMax(const x0, x1, x2: Double; out min, max: Double); overload;

procedure MinMax(const x0, x1, x2: Single; out min, max: Single); overload;

function CastleCoTan(const Value: Single): Single;

function IntSqrt(const Value: Cardinal): Cardinal;

function SmoothStep(const Edge0, Edge1, X: Single): Single;

function Swap32(Value: UInt32): UInt32;

function Swap64(Value: QWord): QWord;

function SwapEndian(const Value: Single): Single; overload;

function SwapEndian(const Value: Double): Double; overload;

function NtoLE(const Value: Single): Single; overload;

function NtoLE(const Value: Double): Double; overload;

function NtoBE(const Value: Single): Single; overload;

function NtoBE(const Value: Double): Double; overload;

function LEtoN(const Value: Single): Single; overload;

function LEtoN(const Value: Double): Double; overload;

function BEtoN(const Value: Single): Single; overload;

function BEtoN(const Value: Double): Double; overload;

function Deg(const Degrees: Float): Float;

function DeleteFileExt(const FileName: string): string;

function ExtractFileDoubleExt(const FileName: string): string;

function ExtractOnlyFilename(const FileName: string): string; deprecated;

function ChangeFilePath(const FileName, NewPath: string): string; deprecated;

function InclPathDelim(const s: string): string;

function ExclPathDelim(const s: string): string;

function IsPathAbsolute(const Path: string): boolean;

function IsPathAbsoluteOnDrive(const Path: string): boolean;

function SpecialDirName(const DirectoryName: string): boolean;

function AppendToFilename(const FileName, Suffix: string): string;

function PointerAdd(p: pointer; add: integer): pointer;

function GetClearMem(Size: integer; ClearValue: byte = 0): pointer; overload;

procedure FreeMemNiling(var p: pointer);

function CheckIsMemCharFilled(const Data; Size: Integer; AChar: AnsiChar): Integer;

function IsMemCharFilled(const Data; Size: Integer; AChar: AnsiChar): boolean;

function IsMemWordFilled(const Data; Size: Integer; Value: Word): boolean;

function IsMemDWordFilled(const Data; Size: Integer; Value: DWord): boolean;

function OffsetUInt(var A, B): PtrUInt;

function Offset(var A, B): Pointer;

function CompareMethods(const AMethod1, AMethod2: TMethod): boolean; deprecated 'use SameMethods';

function SameMethods(const AMethod1, AMethod2: TMethod): boolean;

procedure ErrorWrite(const s: string); overload;

procedure WarningWrite(const s: string); overload;

procedure InfoWrite(const s: string); overload;

procedure ErrorWrite(const s: string; const args: array of const); overload;

procedure WarningWrite(const s: string; const args: array of const); overload;

procedure InfoWrite(const s: string; const args: array of const); overload;

procedure InfoWriteParts(const TitleFormat: string; const Messages: array of string); deprecated;

Types

Float = Math.Float ;

PFloat = Math.PFloat ;

PCardinal = ˆCardinal;

PLongWord = ˆLongWord;

PShortint = ˆShortint;

PBoolean = ˆBoolean;

PByteArray = ˆTByteArray;

TByteArray = array[0..MaxInt div SizeOf(Byte)-1] of Byte;

PtrObject = ˆTObject;

TListSize = SizeInt ;

TCastlePlatform = (...);

TCastlePlatforms = set of TCastlePlatform;

TSimpleNotifyEvent = procedure of object;

TCastleApplicationMode = (...);

TBooleanSet = set of Boolean;

TUInt16List = TWordList;

TSingleArray = packed array [0..MaxInt div SizeOf(Single) - 1] of Single;

PSingleArray = ˆTSingleArray;

TInt32Array = packed array [0..MaxInt div SizeOf(Int32) - 1] of Int32;

PInt32Array = ˆTInt32Array;

EWithHiddenClassName = EShortErrorMessage deprecated 'use EShortErrorMessage';

T2DAxis = 0..1;

T3DAxis = 0..2;

Constants

AllPlatforms = [Low(TCastlePlatform)..High(TCastlePlatform)];

NL = LineEnding;

CastleEngineVersion = '7.0-alpha.3.snapshot'


;

DefaultFloatStrDigits = 5;

ENatural = 2.71828182845905;

Sqrt2 = 1.4142135623730950488016887242097;

Sqrt3 = 1.7320508075688773;

HalfPi = 1.57079632679489661923;

Pi2 = 6.28318530717958647703;

RootDir =  '/' 
            
            
            ;

ExeExtension = '' ;

Description

Functions and Procedures

function Platform: TCastlePlatform;

Current platform of this application, where we run on.

"Platform" is our term that encompasses a group of OS (operating system) and CPU (processor) combinations that behave similar in some way (for users, for developers). For example, cpDesktop is a platform that includes all desktop OSes (Linux, Windows, FreeBSD, macOS...) on all their supported CPUs.

Note There are many ways how you can make your code behave differently depending on the platform where it runs.

Using this function, and checking like if Platform = ... then is one approach.
Checking ApplicationProperties.TouchDevice is useful if you want to differentiate between devices with touch screen (and dedicated API for multi-touch) or not. See touch input for more details.
You can also use symbols to compile certain code only on a specific platform or specific OS or specific CPU. For example {$ifdef MSWINDOWS} WritelnLog('This is Windows'); {$endif}.
We define some symbols by our engine build tool:
- CASTLE_IOS
- CASTLE_NINTENDO_SWITCH
The compilers (Delphi or FPC) define much more symbols for this purpose. Detect OS by symbols like this:
- LINUX
- UNIX
- MSWINDOWS
- DARWIN
- ANDROID
- WASI (web)
Detect CPU by symbols like this:
- CPUX86_64
- CPUI386
- CPUAARCH64
Refer to the documentation of your Pascal compiler for more details.

Source: base/castleutils_platform.inc (line 90).

function PlatformToStr(const T: TCastlePlatform): String;

This item has no description.

Source: base/castleutils_platform.inc (line 92).

function StrToPlatform(const S: String): TCastlePlatform;

Convert string to a platform name. Case (the difference between upper and lower letters) is ignored. Raises Exception on invalid platform name.

Source: base/castleutils_platform.inc (line 97).

procedure Check(TrueValue: boolean; const ErrMessage: string = 'Check failed');

Check condition.

Exceptions raised

ECheckFailed: Raised with ErrMessage if condition TrueValue if false.

Source: base/castleutils_miscella.inc (line 51).

function ArrayPosStr(const A: String; const Arr: array of String): Integer; overload;

Search the array for a given value. Returns index (zero-based) or -1 if not found.

Useful for writing case as:

case ArrayPosStr(variable, [val1, val2]) of
  0 : Something1;
  1 : Something2;
  else SomethingElse;
end;

Source: base/castleutils_miscella.inc (line 67).

function ArrayPosText(const A: String; const Arr: array of String; const IgnoreCase: boolean = true): Integer; overload;

This item has no description.

Source: base/castleutils_miscella.inc (line 68).

function ArrayContainsString(const A: String; const Arr: array of String): Boolean;

This item has no description.

Source: base/castleutils_miscella.inc (line 71).

function Iff(boolval: boolean; trueval, falseval: string) : string; overload;

Warning: this symbol is deprecated.

Simple conditional function. Returns trueval if boolval is true, falseval otherwise.

This can be used in a similar way to the ternary operator from C-like languages, e.g. like this

AvatarHeight := Iff(AvatarCrouch, 0.5, 2.0);

However, remember that this is just a regular function, so both arguments are evaluated before the result is calculated. For example, this code is incorrect:

// INCORRECT EXAMPLE, DO NOT COPY
AvatarHeight := Iff(Avatar <> nil, Avatar.Height, 0.0);

Do not use this, as equivalent functions are available in standard Pascal libraries now. Use Math.IfThen, StrUtils.IfThen instead.

Source: base/castleutils_miscella.inc (line 99).

function Iff(boolval: boolean; trueval, falseval: Integer) : Integer; overload;

This item has no description.

Source: base/castleutils_miscella.inc (line 100).

function Iff(boolval: boolean; trueval, falseval: Float) : Float; overload;

This item has no description.

Source: base/castleutils_miscella.inc (line 101).

function Iff(boolval: boolean; trueval, falseval: Cardinal): Cardinal; overload;

This item has no description.

Source: base/castleutils_miscella.inc (line 102).

function Iff(boolval: boolean; trueval, falseval: char) : char; overload;

This item has no description.

Source: base/castleutils_miscella.inc (line 103).

function SCompilerDescription: string;

Name and version of the Pascal compiler used to compile this unit.

Exceptions raised

EOSError: In case of any failure (non-existing FileName etc.)

Source: base/unix/castleutils_os_specific_unix.inc (line 24).

procedure SwapValues(var a, b: Byte ); overload; inline;

Swap variables values.

Source: base/castleutils_math.inc (line 23).

procedure SwapValues(var a, b: Int64 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 24).

procedure SwapValues(var a, b: QWord ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 25).

procedure SwapValues(var a, b: Int32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 26).

procedure SwapValues(var a, b: UInt32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 27).

procedure SwapValues(var a, b: Single ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 28).

procedure SwapValues(var a, b: Double ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 29).

procedure SwapValues(var a, b: char ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 33).

procedure SwapValues(var a, b: Pointer ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 34).

procedure OrderUp(var Smaller, Larger: Int64 ); overload; inline;

Make sure the Smaller value is <= than the Larger value, by eventually swapping them.

Source: base/castleutils_math.inc (line 40).

procedure OrderUp(var Smaller, Larger: Int32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 41).

procedure OrderUp(var Smaller, Larger: UInt32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 42).

procedure OrderUp(var Smaller, Larger: Single ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 43).

procedure OrderUp(var Smaller, Larger: Double ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 44).

procedure OrderUp(x, y: Int32 ; var Smaller, Larger: Int32 ); overload; inline;

Assign the smaller value from X, Y to Smaller variable, the other one to Larger variable.

Source: base/castleutils_math.inc (line 53).

procedure OrderUp(x, y: UInt32; var Smaller, Larger: UInt32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 54).

procedure OrderUp(x, y: Single; var Smaller, Larger: Single ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 55).

procedure OrderUp(x, y: Double; var Smaller, Larger: Double ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 56).

procedure MinVar(var a: Word ; const b: Word ); overload; inline;

Update value of A to be a minimum of A, B. Works like A := Min(A, B), but is marginally faster, since you don't have to do anything when A is already smaller.

Source: base/castleutils_math.inc (line 66).

procedure MinVar(var a: Int64 ; const b: Int64 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 67).

procedure MinVar(var a: Int32 ; const b: Int32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 68).

procedure MinVar(var a: UInt32 ; const b: UInt32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 69).

procedure MinVar(var a: Single ; const b: Single ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 70).

procedure MinVar(var a: Double ; const b: Double ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 71).

procedure MaxVar(var a: Word ; const b: Word ); overload; inline;

Update value of A to be a maximum of A, B. Works like A := Max(A, B), but is marginally faster, since you don't have to do anything when A is already larger.

Source: base/castleutils_math.inc (line 81).

procedure MaxVar(var a: Int64 ; const b: Int64 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 82).

procedure MaxVar(var a: Int32 ; const b: Int32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 83).

procedure MaxVar(var a: UInt32 ; const b: UInt32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 84).

procedure MaxVar(var a: Single ; const b: Single ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 85).

procedure MaxVar(var a: Double ; const b: Double ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 86).

function IndexMax(const a0, a1, a2: Double): T3DAxis; overload; inline;

Index (0, 1 or 2) of maximum / minimum of 3 numbers.

Source: base/castleutils_math.inc (line 100).

function IndexMin(const a0, a1, a2: Double): T3DAxis; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 101).

function Between(const a, vBegin, vEnd: Int64 ): boolean; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 104).

function Between(const a, vBegin, vEnd: Int32 ): boolean; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 105).

function Between(const a, vBegin, vEnd: UInt32 ): boolean; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 106).

function Between(const a, vBegin, vEnd: Float ): boolean; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 107).

function Between(const a, vBegin, vEnd: Char ): boolean; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 108).

function RoundClamp255(const A: Single): Byte; inline;

This item has no description.

Source: base/castleutils_math.inc (line 110).

function Clamped(const a, vBegin, vEnd: Int64 ): Int64 ; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 112).

function Clamped(const a, vBegin, vEnd: QWord ): QWord ; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 113).

function Clamped(const a, vBegin, vEnd: Int32 ): Int32 ; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 114).

function Clamped(const a, vBegin, vEnd: UInt32 ): UInt32 ; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 115).

function Clamped(const a, vBegin, vEnd: Single ): Single ; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 116).

function Clamped(const a, vBegin, vEnd: Double ): Double ; overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 117).

procedure ClampVar(var a: Int64 ; const vBegin, vEnd: Int64 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 122).

procedure ClampVar(var a: QWord ; const vBegin, vEnd: QWord ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 123).

procedure ClampVar(var a: Int32 ; const vBegin, vEnd: Int32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 124).

procedure ClampVar(var a: UInt32 ; const vBegin, vEnd: UInt32 ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 125).

procedure ClampVar(var a: Single ; const vBegin, vEnd: Single ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 126).

procedure ClampVar(var a: Double ; const vBegin, vEnd: Double ); overload; inline;

This item has no description.

Source: base/castleutils_math.inc (line 127).

procedure Clamp(var a: Int64 ; const vBegin, vEnd: Int64 ); overload; inline; deprecated 'Use ClampVar';