MonitorTypes.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// This file is part of VirtualC64
//
// Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
// This FILE is dual-licensed. You are free to choose between:
//
//     - The GNU General Public License v3 (or any later version)
//     - The Mozilla Public License v2
//
// SPDX-License-Identifier: GPL-3.0-or-later OR MPL-2.0
// -----------------------------------------------------------------------------
 
#pragma once
 
#include "Reflection.h"
 
namespace vc64 {
 
//
// Enumerations
//
 
enum_long(PALETTE)
{
    PALETTE_COLOR,                      
    PALETTE_BLACK_WHITE,                
    PALETTE_PAPER_WHITE,                
    PALETTE_GREEN,                      
    PALETTE_AMBER,                      
    PALETTE_SEPIA                       
};
typedef PALETTE Palette;
 
struct PaletteEnum : util::Reflection<PaletteEnum, Palette> {
 
    static constexpr long minVal = 0;
    static constexpr long maxVal = PALETTE_SEPIA;
    static bool isValid(auto value) { return value >= minVal && value <= maxVal; }
 
    static const char *prefix() { return "PALETTE"; }
    static const char *key(long value)
    {
        switch (value) {
 
            case PALETTE_COLOR:        return "COLOR";
            case PALETTE_BLACK_WHITE:  return "BLACK_WHITE";
            case PALETTE_PAPER_WHITE:  return "PAPER_WHITE";
            case PALETTE_GREEN:        return "GREEN";
            case PALETTE_AMBER:        return "AMBER";
            case PALETTE_SEPIA:        return "SEPIA";
        }
        return "???";
    }
};
 
enum_long(UPSCALER)
{
    UPSCALER_NONE,                      
    UPSCALER_EPX_2X,                    
    UPSCALER_XBR_4X                     
};
typedef UPSCALER Upscaler;
 
struct UpscalerEnum : util::Reflection<UpscalerEnum, Upscaler> {
 
    static constexpr long minVal = 0;
    static constexpr long maxVal = UPSCALER_XBR_4X;
    static bool isValid(auto value) { return value >= minVal && value <= maxVal; }
 
    static const char *prefix() { return "UPSCALER"; }
    static const char *key(long value)
    {
        switch (value) {
 
            case UPSCALER_NONE:     return "NONE";
            case UPSCALER_EPX_2X:   return "EPX_2X";
            case UPSCALER_XBR_4X:   return "XBR_4X";
        }
        return "???";
    }
};
 
enum_long(DOTMASK)
{
    DOTMASK_NONE,                       
    DOTMASK_BISECTED,                   
    DOTMASK_TRISECTED,                  
    DOTMASK_BISECTED_SHIFTED,           
    DOTMASK_TRISECTED_SHIFTED           
};
typedef DOTMASK Dotmask;
 
struct DotmaskEnum : util::Reflection<DotmaskEnum, Dotmask> {
 
    static constexpr long minVal = 0;
    static constexpr long maxVal = DOTMASK_TRISECTED_SHIFTED;
    static bool isValid(auto value) { return value >= minVal && value <= maxVal; }
 
    static const char *prefix() { return "DOTMASK"; }
    static const char *key(long value)
    {
        switch (value) {
 
            case DOTMASK_NONE:              return "NONE";
            case DOTMASK_BISECTED:          return "BISECTED";
            case DOTMASK_TRISECTED:         return "TRISECTED";
            case DOTMASK_BISECTED_SHIFTED:  return "BISECTED_SHIFTED";
            case DOTMASK_TRISECTED_SHIFTED: return "TRISECTED_SHIFTED";
        }
        return "???";
    }
};
 
enum_long(SCANLINES)
{
    SCANLINES_NONE,                     
    SCANLINES_EMBEDDED,                 
    SCANLINES_SUPERIMPOSE               
};
typedef SCANLINES Scanlines;
 
struct ScanlinesEnum : util::Reflection<ScanlinesEnum, Scanlines> {
 
    static constexpr long minVal = 0;
    static constexpr long maxVal = SCANLINES_SUPERIMPOSE;
    static bool isValid(auto value) { return value >= minVal && value <= maxVal; }
 
    static const char *prefix() { return "SCANLINES"; }
    static const char *key(long value)
    {
        switch (value) {
 
            case SCANLINES_NONE:            return "NONE";
            case SCANLINES_EMBEDDED:        return "EMBEDDED";
            case SCANLINES_SUPERIMPOSE:     return "SUPERIMPOSE";
        }
        return "???";
    }
};
 
//
// Structures
//
 
typedef struct
{
    // Colors
    Palette palette;
    isize brightness;
    isize contrast;
    isize saturation;
 
    // Geometry
    isize hCenter;
    isize vCenter;
    isize hZoom;
    isize vZoom;
 
    // Effects
    Upscaler upscaler;
 
    bool blur;
    isize blurRadius;
 
    bool bloom;
    isize bloomRadius;
    isize bloomBrightness;
    isize bloomWeight;
 
    Dotmask dotmask;
    isize dotMaskBrightness;
 
    Scanlines scanlines;
    isize scanlineBrightness;
    isize scanlineWeight;
 
    bool disalignment;
    isize disalignmentH;
    isize disalignmentV;
}
MonitorConfig;
 
}