intern.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef AWE_INTERN_H
#define AWE_INTERN_H
 
#include "common/algorithm.h"
#include "common/endian.h"
#include "common/language.h"
#include "common/rect.h"
 
namespace Awe {
 
using Common::Language;
 
enum {
    kPartCopyProtection = 16000,
    kPartIntro = 16001,
    kPartWater = 16002,
    kPartPrison = 16003,
    kPartCite = 16004,
    kPartArene = 16005,
    kPartLuxe = 16006,
    kPartFinal = 16007,
    kPartPassword = 16008
};
 
enum {
    kPaulaFreq = 7159092
};
 
struct Ptr {
    uint8 *pc = nullptr;
    bool byteSwap = false;
 
    uint8 fetchByte() {
        return *pc++;
    }
 
    uint16 fetchWord() {
        const uint16 i = byteSwap ? READ_LE_UINT16(pc) : READ_BE_UINT16(pc);
        pc += 2;
        return i;
    }
};
 
struct Point : public Common::Point {
    Point() : Common::Point() {}
    Point(int16 xx, int16 yy) : Common::Point(xx, yy) {}
    Point(const Point &p) : Common::Point(p) {}
 
    void scale(int u, int v) {
        x = (x * u) >> 16;
        y = (y * v) >> 16;
    }
};
 
struct QuadStrip {
    enum {
        MAX_VERTICES = 70
    };
 
    uint8 numVertices = 0;
    Point vertices[MAX_VERTICES];
};
 
struct Color {
    byte rgb[3];
    uint8 &r = rgb[0];
    uint8 &g = rgb[1];
    uint8 &b = rgb[2];
 
    Color() {
        clear();
    }
    void clear() {
        r = g = b = 0;
    }
};
 
struct Frac {
    static const int BITS = 16;
    static const int MASK = (1 << BITS) - 1;
    uint32 inc = 0;
    uint64 offset = 0;
 
    void reset(int n, int d) {
        inc = (((int64)n) << BITS) / d;
        offset = 0;
    }
 
    uint32 getInt() const {
        return offset >> BITS;
    }
    uint32 getFrac() const {
        return offset & MASK;
    }
    int interpolate(int sample1, int sample2) const {
        const int fp = getFrac();
        return (sample1 * (MASK - fp) + sample2 * fp) >> BITS;
    }
};
 
} // namespace Awe
 
#endif