raze-gles/source/core/palette.h

// "Build Engine & Tools" Copyright (c) 1993-1997 Ken Silverman
// Ken Silverman's official web site: "http://www.advsys.net/ken"
// See the included license file "BUILDLIC.TXT" for license info.
//
// This file has been modified from Ken Silverman's original release
// by Jonathon Fowler (jf@jonof.id.au)
// by the EDuke32 team (development@voidpoint.com)

#pragma once

#ifndef palette_h_
#define palette_h_

#include "renderstyle.h"
#include "filesystem.h"
#include "zstring.h"
#include "palentry.h"
#include "templates.h"

enum
{
    MAXBASEPALS = 256,
    MAXPALOOKUPS = 256,
    MAXBLENDTABS = 256,
    
    RESERVEDPALS = 4, // don't forget to increment this when adding reserved pals
    DETAILPAL   = (MAXPALOOKUPS - 1),
    GLOWPAL     = (MAXPALOOKUPS - 2),
    SPECULARPAL = (MAXPALOOKUPS - 3),
    NORMALPAL   = (MAXPALOOKUPS - 4),
    BRIGHTPAL	= (MAXPALOOKUPS),

    MAXREALPAL = MAXPALOOKUPS - RESERVEDPALS
};

// fixme: should use the flags from the PRSFlags enum directly
enum
{
    TINTF_GRAYSCALE = 1,
    TINTF_INVERT = 2,
    TINTF_COLORIZE = 4,
    TINTF_USEONART = 8,
    TINTF_APPLYOVERPALSWAP = 16,
    TINTF_APPLYOVERALTPAL = 32,

    TINTF_BLEND_MULTIPLY = 0 << 6,
    TINTF_BLEND_SCREEN = 1 << 6,
    TINTF_BLEND_OVERLAY = 2 << 6,
    TINTF_BLEND_HARDLIGHT = 3 << 6,

    TINTF_BLENDMASK = 64 | 128,
    TINTF_ALWAYSUSEART = 256,
    TINTF_PRECOMPUTED = TINTF_COLORIZE | TINTF_BLENDMASK,
    TINTF_ENABLE = 32768
};

struct LookupTable
{
    FString Shades;
    PalEntry FadeColor = 0;
    float ShadeFactor = 1.f;
    float Visibility = 0;
    bool hasBrightmap = false;
    bool noFloorPal = false;

    int tintFlags = 0;
    PalEntry tintColor = 0xffffff;
    PalEntry tintShade = 0;
};

struct LookupTableInfo
{
    LookupTable tables[MAXPALOOKUPS];

    const uint8_t* getTable(int num)
    {
        if (tables[num].Shades.Len() == 0) num = 0;
        return (const uint8_t*)tables[num].Shades.GetChars();
    }

    bool checkTable(int num)
    {
        return tables[num].Shades.IsNotEmpty();
    }

    void copyTable(int dest, int src)
    {
        tables[dest].Shades = tables[src].Shades;
    }

    void clearTable(int dest)
    {
        tables[dest].Shades = "";
    }

    void makeTable(int palnum, const uint8_t* remapbuf, int r, int g, int b, bool noFloorPal);
    int setTable(int palnum, const uint8_t* remap);
    void postLoadTables();
    int loadTable(FileReader& fp);
    void postLoadLookups();
    void setupDefaultFog();

    void setFadeColor(int num, int r, int g, int b)
    {
        tables[num].FadeColor = PalEntry(1, r, g, b);
    }

    PalEntry getFade(int num)
    {
        return tables[num].FadeColor;
    }

    bool noFloorPal(int num) const
    {
        return tables[num].noFloorPal;
    }

    void setPaletteTint(int palnum, int r, int g, int b, int sr, int sg, int sb, int flags);


};

extern LookupTableInfo lookups;

enum
{
    Translation_BasePalettes = 1,
    Translation_Remap,
};

extern uint8_t curbasepal;
extern int32_t r_scenebrightness;

struct palette_t 
{
    uint8_t r, g, b, f;
};

extern PalEntry palfadergb;

void paletteSetColorTable(int32_t id, uint8_t const* table, bool notransparency, bool twodonly);

#include "tflags.h"
enum ESetPalFlag
{
    Pal_DontResetFade = 1,
};

inline void videoSetBrightness(int brightness)
{
    r_scenebrightness = clamp(brightness, 0, 15);
}

typedef TFlags<ESetPalFlag> ESetPalFlags;
    DEFINE_TFLAGS_OPERATORS(ESetPalFlags)

void videoSetPalette(int dapalid);
inline void videoFadePalette(uint8_t r, uint8_t g, uint8_t b, uint8_t offset)
{
    palfadergb.r = r;
    palfadergb.g = g;
    palfadergb.b = b;
    palfadergb.a = offset;
}
inline void videoclearFade()
{
    palfadergb.d = 0;
}


void videoTintBlood(int32_t r, int32_t g, int32_t b);

extern int numshades;
extern void paletteLoadFromDisk(void);


struct glblenddef_t
{
    float alpha;
    uint8_t src, dst, flags;
};

struct glblend_t
{
    glblenddef_t def[2];
};

extern glblend_t const nullglblend, defaultglblend;
extern glblend_t glblend[MAXBLENDTABS];

FRenderStyle GetRenderStyle(int blend, int def);
extern void SetRenderStyleFromBlend(uint8_t enable, uint8_t blend, uint8_t def);
float GetAlphaFromBlend(uint32_t maskprops, uint32_t blend);
void DrawFullscreenBlends();

#endif