GXMath.h

Go to the documentation of this file.

 
#ifndef __GXMATH__
#define __GXMATH__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __FIXMATH__
#include <FixMath.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma push
#pragma pointers_in_D0
#endif
 
    struct gxPoint
    {
        Fixed x;
        Fixed y;
    };
    typedef struct gxPoint gxPoint;
 
    typedef unsigned short gxColorValue;
    struct gxPolar
    {
        Fixed radius;
        Fixed angle;
    };
    typedef struct gxPolar gxPolar;
    struct gxMapping
    {
        Fixed map[3][3];
    };
    typedef struct gxMapping gxMapping;
#define gxColorValue1 ((gxColorValue)0x0000FFFF)
#define gxPositiveInfinity ((long)0x7FFFFFFFL)
#define gxNegativeInfinity ((long)0x80000000L)
 
#if CALL_NOT_IN_CARBON
    gxMapping *
    CopyToMapping(gxMapping *target, const gxMapping *source);
 
    gxMapping *
    InvertMapping(gxMapping *target, const gxMapping *source);
 
    gxMapping *
    MapMapping(gxMapping *target, const gxMapping *source);
 
    gxMapping *
    MoveMapping(gxMapping *target, Fixed hOffset, Fixed vOffset);
 
    gxMapping *
    MoveMappingTo(gxMapping *target, Fixed hPosition, Fixed vPosition);
 
    gxMapping *
    NormalizeMapping(gxMapping *target);
 
    gxMapping *
    RotateMapping(gxMapping *target, Fixed angle, Fixed xCenter, Fixed yCenter);
 
    gxMapping *
    ScaleMapping(gxMapping *target, Fixed hFactor, Fixed vFactor, Fixed xCenter,
                 Fixed yCenter);
 
    gxMapping *
    ResetMapping(gxMapping *target);
 
    gxMapping *
    SkewMapping(gxMapping *target, Fixed skewX, Fixed skewY, Fixed xCenter,
                Fixed yCenter);
 
    void
    MapPoints(const gxMapping *source, long count, gxPoint theVector[]);
 
    short
    FirstBit(unsigned long x);
 
    short
    WideScale(const wide *source);
 
    short
    LinearRoot(Fixed first, Fixed last, Fract t[]);
 
    short
    QuadraticRoot(Fixed first, Fixed control, Fixed last, Fract t[]);
 
    gxPoint *
    PolarToPoint(const gxPolar *ra, gxPoint *xy);
 
    gxPolar *
    PointToPolar(const gxPoint *xy, gxPolar *ra);
 
    Fract
    FractCubeRoot(Fract source);
 
    Fract
    FractDivide(Fract dividend, Fract divisor);
 
    Fract
    FractMultiply(Fract multiplicand, Fract multiplier);
 
    Fract
    FractSineCosine(Fixed degrees, Fract *cosine);
 
    Fract
    FractSquareRoot(Fract source);
 
    Fixed
    FixedDivide(Fixed dividend, Fixed divisor);
 
    Fixed
    FixedMultiply(Fixed multiplicand, Fixed multiplier);
 
    long
    MultiplyDivide(long source, long multiplier, long divisor);
 
    unsigned long
    Magnitude(long deltaX, long deltaY);
 
    long
    VectorMultiplyDivide(long count, const long *vector1, long step1,
                         const long *vector2, long step2, long divisor);
 
#endif 
#if TARGET_OS_MAC && TARGET_CPU_68K
#if CALL_NOT_IN_CARBON
    wide *
    WideAdd(wide *target, const wide *source);
 
    short
    WideCompare(const wide *target, const wide *source);
 
    wide *
    WideNegate(wide *target);
 
    wide *
    WideShift(wide *target, long shift);
 
    unsigned long
    WideSquareRoot(const wide *source);
 
    wide *
    WideSubtract(wide *target, const wide *source);
 
    wide *
    WideMultiply(long multiplicand, long multiplier, wide *target);
 
    long
    WideDivide(const wide *dividend, long divisor, long *remainder);
 
    wide *
    WideWideDivide(wide *dividend, long divisor, long *remainder);
 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
    wide *
    VectorMultiply(long count, const long *vector1, long step1, const long *vector2,
                   long step2, wide *dot);
 
    unsigned long
    RandomBits(long count, long focus);
 
    void
    SetRandomSeed(const wide *seed);
 
    wide *
    GetRandomSeed(wide *seed);
 
#endif 
#define FixedRound(a) ((short)((Fixed)(a) + fixed1 / 2 >> 16))
#define FixedSquareRoot(a) ((Fixed)FractSquareRoot(a) + 64 >> 7)
#define FixedTruncate(a) ((short)((Fixed)(a) >> 16))
#define FixedToFract(a) ((Fract)(a) << 14)
#define FractToFixed(a) (((Fixed)(a) + 8192L) >> 14)
#define FixedToInt(a) ((short)(((Fixed)(a) + fixed1 / 2) >> 16))
#define IntToFixed(a) ((Fixed)(a) << 16)
#define FixedToFloat(a) ((float)(a) / fixed1)
#define FloatToFixed(a) ((Fixed)((float)(a) * fixed1))
#define FractToFloat(a) ((float)(a) / fract1)
#define FloatToFract(a) ((Fract)((float)(a) * fract1))
#define ColorToFract(a) (((Fract)(a) << 14) + ((Fract)(a) + 2 >> 2))
#define FractToColor(a) ((gxColorValue)((a) - ((a) >> 16) + 8191 >> 14))
#ifndef ff 
#define ff(a) IntToFixed(a)
#define fl(a) FloatToFixed(a)
#endif
 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma pop
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif