gfx_def.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/>.
 *
 */
 
//=============================================================================
//
// Graphic definitions and type/unit conversions.
//
//=============================================================================
 
#ifndef AGS_SHARED_GFX_GFX_DEF_H
#define AGS_SHARED_GFX_GFX_DEF_H
 
namespace AGS3 {
namespace AGS {
namespace Shared {
 
enum GraphicFlip {
    kFlip_None,
    kFlip_Horizontal, // this means - mirror over horizontal middle line
    kFlip_Vertical,   // this means - mirror over vertical middle line
    kFlip_Both        // mirror over diagonal (horizontal and vertical)
};
 
enum BlendMode {
    // free blending (ARGB -> ARGB) modes
    kBlendMode_NoAlpha = 0, // ignore alpha channel
    kBlendMode_Alpha,              // alpha-blend src to dest, combining src & dest alphas
    // NOTE: add new modes here
 
    kNumBlendModes
};
 
namespace GfxDef {
 
// Converts percentage of transparency into alpha
inline int Trans100ToAlpha255(int transparency) {
    return ((100 - transparency) * 255) / 100;
}
 
// Converts alpha into percentage of transparency
inline int Alpha255ToTrans100(int alpha) {
    return 100 - ((alpha * 100) / 255);
}
 
// Special formulae to reduce precision loss and support flawless forth &
// reverse conversion for multiplies of 10%
inline int Trans100ToAlpha250(int transparency) {
    return ((100 - transparency) * 25) / 10;
}
 
inline int Alpha250ToTrans100(int alpha) {
    return 100 - ((alpha * 10) / 25);
}
 
// Convert correct 100-ranged transparency into legacy 255-ranged
// transparency; legacy inconsistent transparency value range:
// 0   = opaque,
// 255 = invisible,
// 1 -to- 254 = barely visible -to- mostly visible (as proper alpha)
inline int Trans100ToLegacyTrans255(int transparency) {
    switch (transparency) {
    case 0:
        return 0; // this means opaque
    case 100:
        return 255; // this means invisible
    default:
        // the rest of the range works as alpha
        return Trans100ToAlpha250(transparency);
    }
}
 
// Convert legacy 255-ranged "incorrect" transparency into proper
// 100-ranged transparency.
inline int LegacyTrans255ToTrans100(int legacy_transparency) {
    switch (legacy_transparency) {
    case 0:
        return 0; // this means opaque
    case 255:
        return 100; // this means invisible
    default:
        // the rest of the range works as alpha
        return Alpha250ToTrans100(legacy_transparency);
    }
}
 
// Convert legacy 100-ranged transparency into proper 255-ranged alpha
// 0      => alpha 255
// 100    => alpha 0
// 1 - 99 => alpha 1 - 244
inline int LegacyTrans100ToAlpha255(int legacy_transparency) {
    switch (legacy_transparency) {
    case 0:
        return 255; // this means opaque
    case 100:
        return 0; // this means invisible
    default:
        // the rest of the range works as alpha (only 100-ranged)
        return legacy_transparency * 255 / 100;
    }
}
 
// Convert legacy 255-ranged transparency into proper 255-ranged alpha
inline int LegacyTrans255ToAlpha255(int legacy_transparency) {
    switch (legacy_transparency) {
    case 0:
        return 255; // this means opaque
    case 255:
        return 0; // this means invisible
    default:
        // the rest of the range works as alpha
        return legacy_transparency;
    }
}
 
// Convert 255-ranged alpha into legacy 255-ranged transparency
inline int Alpha255ToLegacyTrans255(int alpha) {
    switch (alpha) {
    case 255:
        return 0; // this means opaque
    case 0:
        return 255; // this means invisible
    default:
        // the rest of the range works as alpha
        return alpha;
    }
}
 
} // namespace GfxDef
 
} // namespace Shared
} // namespace AGS
} // namespace AGS3
 
#endif