FrameGraphics.hh

[詳解]

 
//
// Copyright (C) 2011-2024 Yokokura, Yuki
// MIT License. For details, see the LICENSE file.
 
#ifndef FRAMEGRAPHICS
#define FRAMEGRAPHICS
 
#include <linux/fb.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <png.h>
#include <cassert>
#include <cstdint>
#include <array>
#include <string>
#include <cstring>
#include <cmath>
#include "FrameFontSmall.hh"
 
// ARCS組込み用マクロ
#ifdef ARCS_IN
    // ARCSに組み込まれる場合
    #include "ARCSassert.hh"
    #include "ARCSeventlog.hh"
#else
    // ARCSに組み込まれない場合
    #define arcs_assert(a) (assert(a))
    #define PassedLog()
    #define EventLog(a)
    #define EventLogVar(a)
#endif
 
// 下記の警告の抑制のためのプラグマ (-Wno-error=strict-overflow と同値)
// "warning: assuming signed overflow does not occur when assuming that (X - c) > X is always false"
#pragma GCC diagnostic ignored "-Wstrict-overflow"
 
namespace ARCS {    // ARCS名前空間
 
enum class FGcolors {
    RED,    
    GREEN,  
    BLUE,   
    CYAN,   
    MAGENTA,
    YELLOW, 
    ORANGE, 
    WHITE,  
    GRAY75, 
    GRAY50, 
    GRAY25, 
    BLACK,  
    ALPHA   
};
 
enum class FGsize {
    PX_1,   
    PX_2,   
    PX_3    
};
 
enum class FGalign {
    ALIGN_LEFT,     
    ALIGN_CENTER,   
    ALIGN_RIGHT     
};
 
class FrameGraphics {
    public:
        FrameGraphics(int Width, int Height) :
            Frame(nullptr),
            Screen(nullptr),
            Background(nullptr),
            width(Width),
            height(Height),
            depth(32),                              // [bit] 色深度は32bitに固定
            length((size_t)width*(size_t)height),   // [-] 画像配列の長さを計算
            size(length*(size_t)(32/8)),            // [bytes] 1画面データの大きさを計算
            fbfd(0),
            finfo(),
            vinfo(),
            xofst(0),
            yofst(0),
            xlen(0),
            bppx(0),
            IsFontDataLocked(true),
            FontPrepared()
        {
            Screen = (uint32_t*) malloc(length*sizeof(uint32_t));       // 画面バッファ用配列
            Background = (uint32_t*) malloc(length*sizeof(uint32_t));   // 背景バッファ用配列
            ClearScreen();      // 画面バッファのクリア
            ClearBackground();  // 背景バッファのクリア
            PrepareFontData(FGcolors::WHITE, FGcolors::BLACK);          // フォントデータの準備（初期値は白文字に黒背景）
        }
        
        explicit FrameGraphics(const std::string& DeviceName) :
            Frame(nullptr),
            Screen(nullptr),
            Background(nullptr),
            width(0),
            height(0),
            depth(0),
            length(0),
            size(0),
            fbfd(0),
            finfo(),
            vinfo(),
            xofst(0),
            yofst(0),
            xlen(0),
            bppx(0),
            IsFontDataLocked(true),
            FontPrepared()
        {
            // フレームバッファデバイスを開く
            fbfd = open(DeviceName.c_str(), O_RDWR, 0);
            if(fbfd != -1){
                // フレームバッファが開けたとき
                // 固定画面情報の取得
                ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo);
                xlen = finfo.line_length;
                
                // 変動画面情報の取得
                ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo);
                width = xlen/4;                         // padding対策のため width = vinfo.xres は使用しない
                height = vinfo.yres;
                depth = vinfo.bits_per_pixel;
                xofst = vinfo.xoffset;
                yofst = vinfo.yoffset;
                bppx = vinfo.bits_per_pixel;
                length = (size_t)width*(size_t)height;  // フレームバッファの長さを計算
                size = length*(size_t)depth/8;          // 1画面データの大きさを計算 [bytes]
                arcs_assert(depth == 32 && "[ERROR] FrameGraphics : Not supported color depth of display settings.");
                
                Frame = (uint32_t*) mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fbfd, 0);// フレームバッファをマッピング
                arcs_assert(Frame != MAP_FAILED && "[ERROR] FrameGraphics : mmap(...)");        // マッピングできないとき
            }else{
                // フレームバッファが開けなかったとき
                EventLog("Could not open the frame buffer device. Trying to use a dummy buffer.");
                xlen = 1920;    // とりあえず画面サイズをFullHDに設定
                width = 1920;
                height = 1080;
                depth = 32;
                xofst = 0;
                yofst = 0;
                bppx = 32;
                length = (size_t)width*(size_t)height;  // フレームバッファの長さを計算
                size = length*(size_t)depth/8;          // 1画面データの大きさを計算 [bytes]
                Frame = (uint32_t*) malloc(length*sizeof(uint32_t));    // ダミーフレームバッファ配列
            }
            
            Screen = (uint32_t*) malloc(length*sizeof(uint32_t));       // 画面バッファ用配列
            Background = (uint32_t*) malloc(length*sizeof(uint32_t));   // 背景画面バッファ用配列
            ClearScreen();      // 画面バッファのクリア
            ClearBackground();  // 背景バッファのクリア
            PrepareFontData(FGcolors::WHITE, FGcolors::BLACK);          // フォントデータの準備（初期値は白文字に黒背景）
        }
    
        ~FrameGraphics(){
            free(Background); Background = nullptr;
            free(Screen); Screen = nullptr;
            if(fbfd != -1){
                // フレームバッファが開けたとき
                munmap(Frame, size); Frame = nullptr;
                close(fbfd); fbfd = 0;
            }else{
                // フレームバッファが開けなかったとき
                free(Frame); Frame = nullptr;
            }
        }
        
        void SavePngImageFile(const std::string& FileName){
            // 初期化処理
            FILE *fp;               // PNGファイルポインタ
            png_structp png_ptr;    // PNG画像ポインタ
            png_infop info_ptr;     // PNG情報ポインタ
            fp = fopen(FileName.c_str(), "wb"); // ファイルを開く
            arcs_assert(fp != nullptr);         // ファイルが開けるかチェック
            png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);    // png_ptr構造体を確保・初期化
            info_ptr = png_create_info_struct(png_ptr); // info_ptr構造体を確保・初期化
            png_init_io(png_ptr, fp);           // libpngにファイルポインタを知らせる
            png_set_IHDR(                       // IHDRチャンク情報を設定
                png_ptr,
                info_ptr,
                width,
                height,
                8,
                PNG_COLOR_TYPE_RGB_ALPHA,
                PNG_INTERLACE_NONE,
                PNG_COMPRESSION_TYPE_DEFAULT,
                PNG_FILTER_TYPE_DEFAULT
            );
            png_write_info(png_ptr, info_ptr);  // PNGファイルのヘッダを書き込む
            png_set_invert_alpha(png_ptr);      // αチャネルをFFで透過にする(デフォは00で透過)
            png_set_bgr(png_ptr);               // uint32_tデータの順序をABGRからARGBに変更
            
            // 画像書き出し
            for(size_t y = 0; y < static_cast<size_t>(height); ++y) png_write_row(png_ptr, (png_bytep)(&(Screen[width*y])));
            
            // 終了処理
            png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
            png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
            info_ptr = nullptr;
            png_ptr = nullptr;
            fclose(fp); fp = nullptr;
        }
        
        void RefreshFrame(void){
            memcpy(Frame, Screen, size);
        }
        
        void RefreshFrame(int x, int y, int w, int h){
            size_t i = ConvCoordinateToIndex(x, y);         // 座標からフレームバッファの要素番号を計算
            for(int j = 0; j < h; ++j){
                // 1ラインずつフレームバッファへ書き込む
                memcpy(Frame + i + width*j, Screen + i + width*j, sizeof(uint32_t)*w);
            }
        }
        
        void StoreScreenAsBackground(void){
            memcpy(Background, Screen, size);
        }
        
        void StoreScreenAsBackground(int x, int y, int w, int h){
            size_t i = ConvCoordinateToIndex(x, y);         // 座標からフレームバッファの要素番号を計算
            for(int j = 0; j < h; ++j){
                // 1ラインずつフレームバッファへ書き込む
                memcpy(Background + i + width*j, Screen + i + width*j, sizeof(uint32_t)*w);
            }
        }
        
        void LoadBackgroundToScreen(void){
            memcpy(Screen, Background, size);
        }
        
        void LoadBackgroundToScreen(int x, int y, int w, int h){
            size_t i = ConvCoordinateToIndex(x, y);         // 座標からフレームバッファの要素番号を計算
            for(int j = 0; j < h; ++j){
                // 1ラインずつフレームバッファへ書き込む
                memcpy(Screen + i + width*j, Background + i + width*j, sizeof(uint32_t)*w);
            }
        }
        
        void LoadFrameToScreen(void){
            memcpy(Screen, Frame, size);
        }
        
        void FillFrame(uint32_t ColorData){
            std::fill(Frame, Frame + length, ColorData);
        }
        
        void FillScreen(uint32_t ColorData){
            std::fill(Screen, Screen + length, ColorData);
        }
        
        void FillBackground(uint32_t ColorData){
            std::fill(Background, Background + length, ColorData);
        }
        
        void ClearFrame(void){
            FillFrame(0);
        }
        
        void ClearScreen(void){
            FillScreen(0);
        }
        
        void ClearBackground(void){
            FillBackground(0);
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawPoint(int x, int y, uint32_t ColorData){
            // 点の太さに従ってコンパイル時条件分岐
            switch(T){
                case FGsize::PX_1:  // 1[px] の場合
                    DrawDot(x, y, ColorData);
                    break;
                case FGsize::PX_2:  // 2[px] の場合
                    DrawDot(x    , y    , ColorData);
                    DrawDot(x    , y + 1, ColorData);
                    DrawDot(x + 1, y    , ColorData);
                    DrawDot(x + 1, y + 1, ColorData);
                    break;
                case FGsize::PX_3:  // 3[px] の場合
                    DrawDot(x    , y    , ColorData);
                    DrawDot(x    , y + 1, ColorData);
                    DrawDot(x + 1, y    , ColorData);
                    DrawDot(x + 1, y + 1, ColorData);
                    DrawDot(x    , y - 1, ColorData);
                    DrawDot(x - 1, y    , ColorData);
                    DrawDot(x - 1, y - 1, ColorData);
                    DrawDot(x + 1, y - 1, ColorData);
                    DrawDot(x - 1, y + 1, ColorData);
                    break;
                default:
                    arcs_assert(false); // ここには来ない
                    break;
            }
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawPoint(int x, int y, FGcolors color){
            DrawPoint<T>(x, y, ColorNameToData(color)); // バイナリ色データに変換して点描画関数を呼び出し
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawPoint(int x, int y, double r, double g, double b){
            DrawPoint<T>(x, y, RGBcolorToData(r,g,b));      // バイナリ色データに変換して点描画関数を呼び出し
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawPoint(int x, int y, double a, double r, double g, double b){
            DrawPoint<T>(x, y, ARGBcolorToData(a,r,g,b));   // バイナリ色データに変換して点描画関数を呼び出し
        }
        
        void DrawCross(int x, int y, uint32_t ColorData){
            DrawDot(x + 2, y, ColorData);
            DrawDot(x - 2, y, ColorData);
            DrawDot(x + 1, y, ColorData);
            DrawDot(x - 1, y, ColorData);
            DrawDot(x, y    , ColorData);
            DrawDot(x, y + 1, ColorData);
            DrawDot(x, y - 1, ColorData);
            DrawDot(x, y + 2, ColorData);
            DrawDot(x, y - 2, ColorData);
        }
        
        void DrawCross(int x, int y, FGcolors color){
            DrawCross(x, y, ColorNameToData(color));
        }
        
        void DrawCross(int x, int y, double r, double g, double b){
            DrawCross(x, y, RGBcolorToData(r, g ,b));
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawLine(int x1, int y1, int x2, int y2, uint32_t ColorData){
            // 垂直の線のとき(ブレゼンハムのアルゴリズムでは描けないので，別に実装)
            if(x1 == x2){
                DrawVerticalLine<T>(x1, y1, y2, ColorData);
                return;
            }
            
            // 水平の線のとき(ブレゼンハムのアルゴリズムでも描けるが，高速化のために別に実装)
            if( y1 == y2 ){
                DrawHorizontalLine<T>(x1, x2, y1, ColorData);
                return;
            }
            
            // 以下はブレゼンハムのアルゴリズム
            bool IsHighGradient = std::abs(x2 - x1) < std::abs(y2 - y1);    // 直線の傾きが45度を境に急勾配かどうかのフラグ
            if(IsHighGradient == true){     // 45度を境に急勾配のとき
                std::swap(x1, y1);  // x1とy1を入れ替え
                std::swap(x2, y2);  // x2とy2を入れ替え
            }
            if(x2 < x1){    // 始点の方が終点よりも右のとき
                std::swap(x1, x2);
                std::swap(y1, y2);
            }
            int Dx = x2 - x1;
            int Dy = std::abs(y2 - y1);
            int Error = Dx/2;
            int ystep;
            if(y1 < y2){
                ystep = 1;
            }else{
                ystep = -1;
            }
            int y = y1;
            for(int x = x1; x <= x2; ++x){
                if(IsHighGradient == true){
                    DrawPoint<T>(y, x, ColorData);
                }else{
                    DrawPoint<T>(x, y, ColorData);
                }
                Error -= Dy;
                if(Error < 0){
                    y += ystep;
                    Error += Dx;
                }
            }
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawVerticalLine(int x, int y1, int y2, uint32_t ColorData){
            int ysta, yend;
            if(y1 < y2){
                // y1→y2で増加する場合
                ysta = y1;
                yend = y2;
            }else{
                // y2→y1で増加する場合
                ysta = y2;
                yend = y1;
            }
            for(int y = ysta; y <= yend;y ++)
                DrawPoint<T>(x, y, ColorData);      // 直線に沿って点を描画
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawHorizontalLine(int x1, int x2, int y, uint32_t ColorData){
            int xsta, xend;
            if(x1 < x2){
                // x1→x2で増加する場合
                xsta = x1;
                xend = x2;
            }else{
                // x2→x1で増加する場合
                xsta = x2;
                xend = x1;
            }
            for(int x = xsta; x <= xend; x++)
                DrawPoint<T>(x, y, ColorData);  // 直線に沿って点を描画
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawLine(int x1, int y1, int x2, int y2, FGcolors color){
            DrawLine<T>(x1, y1, x2, y2, ColorNameToData(color));
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawLine(int x1, int y1, int x2, int y2, double r, double g, double b){
            DrawLine<T>(x1, y1, x2, y2, RGBcolorToData(r,g,b));
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawStairs(int x1, int y1, int x2, int y2, uint32_t ColorData){
            DrawLine<T>(x1, y1, x2, y1, ColorData);
            DrawLine<T>(x2, y1, x2, y2, ColorData);
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawStairs(int x1, int y1, int x2, int y2, FGcolors color){
            DrawStairs<T>(x1, y1, x2, y2, ColorNameToData(color));
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawStairs(int x1, int y1, int x2, int y2, double r, double g, double b){
            DrawStairs<T>(x1, y1, x2, y2, RGBcolorToData(r,g,b));
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawRect(int x, int y, int w, int h, uint32_t ColorData){
            DrawHorizontalLine<T>(x  , x+w, y  , ColorData);
            DrawHorizontalLine<T>(x+w, x  , y+h, ColorData);
            DrawVerticalLine<T>(x+w, y  , y+h, ColorData);
            DrawVerticalLine<T>(x  , y+h, y  , ColorData);
        }
        
        template <FGsize T = FGsize::PX_1>
        void DrawRect(int x, int y, int w, int h, FGcolors color){
            DrawRect<T>(x, y, w, h, ColorNameToData(color));
        }
 
        template <FGsize T = FGsize::PX_1>
        void DrawRect(int x, int y, int w, int h, double r, double g, double b){
            DrawRect<T>(x, y, w, h, RGBcolorToData(r,g,b));
        }
        
        void DrawRectFill(int x, int y, int w, int h, uint32_t ColorData){
            size_t i = ConvCoordinateToIndex(x, y); // 座標からフレームバッファの要素番号を計算
            for(int j = 0; j < h; ++j){
                // バイナリ色データを1ラインずつフレームバッファへ書き込む
                size_t sta = i + width*j;
                size_t end = sta + w;
                if(end < length) std::fill(Screen + sta, Screen + end, ColorData);
            }
        }
        
        void DrawRectFill(int x, int y, int w, int h, FGcolors color){
            DrawRectFill(x, y, w, h, ColorNameToData(color));
        }
        
        void DrawRectFill(int x, int y, int w, int h, double r, double g, double b){
            DrawRectFill(x, y, w, h, RGBcolorToData(r,g,b));
        }
        
        void DrawRectFill(int x, int y, int w, int h, double r, double g, double b, double a){
            DrawRectFill(x, y, w, h, ARGBcolorToData(a,r,g,b));
        }
        
        void DrawCircle(int cx, int cy, int radius, unsigned int N, uint32_t ColorData){
            // 気が向いたらブレゼンハム・ミッチェナーのアルゴリズムに変更する予定
            const double TwoPIdivN = 2.0*M_PI/(double)N;
            int x_prev = (double)radius + cx;
            int y_prev = cy;
            for(unsigned int i=0;i<=N;i++){
                double theta = TwoPIdivN*(double)i;
                int x = (double)radius*cos(theta) + cx;
                int y = (double)radius*sin(theta) + cy;
                DrawLine(x_prev,y_prev, x,y, ColorData);
                x_prev = x;
                y_prev = y;
            }
        }
        
        void DrawCircle(int cx, int cy, int radius, unsigned int N, FGcolors color){
            DrawCircle(cx, cy, radius, N, ColorNameToData(color));
        }
        
        void DrawCircle(int cx, int cy, int radius, unsigned int N, double r, double g, double b){
            DrawCircle(cx, cy, radius, N, RGBcolorToData(r,g,b));
        }
        
        void PrepareFontData(FGcolors fore_color, FGcolors back_color){
            // この関数は結構遅いはずなので注意。アホっぽいので設計から見直す必要あり。
            unsigned int i,j,k;
            IsFontDataLocked = true;    // フォントデータスピンロック
            // フォントデータの中身を書き換え
            for(i=0;i<FrameFontSmall::NUM;i++){
                for(j=0;j<FrameFontSmall::HEIGHT;j++){
                    for(k=0;k<FrameFontSmall::WIDTH;k++){
                        if(FrameFontSmall::DATA[i][j][k] == 1){
                            FontPrepared[i][j][k] = ColorNameToData(fore_color);    // 前景色
                        }else{
                            FontPrepared[i][j][k] = ColorNameToData(back_color);    // 背景色
                        }
                    }
                }
            }
            IsFontDataLocked = false;   // フォントデータスピンロック解除
        }
        
        void PrintText(int x, int y, FGalign align, std::string text){
            // 文字列の揃え指定に従って座標にオフセットを持たせる
            switch(align){
                case FGalign::ALIGN_LEFT:
                    // 左揃えのときはなにもしない
                    break;
                case FGalign::ALIGN_CENTER:
                    // 中央揃えのときは横位置から文字列の長さの半分を引く
                    x = x - text.length()*(FrameFontSmall::WIDTH + TEXT_INTERVAL)/2;
                    break;
                case FGalign::ALIGN_RIGHT:
                    // 右揃えのときは横位置から文字列の長さを引く
                    x = x - text.length()*(FrameFontSmall::WIDTH + TEXT_INTERVAL);
                    break;
            }
            
            // 1文字ずつ描画
            for(size_t i = 0; i < text.length();i ++){
                WriteFont(x + i*(FrameFontSmall::WIDTH + TEXT_INTERVAL), y, (unsigned int)text.at(i));
            }
        }
        
        void PrintValue(int x, int y, FGalign align, std::string format, double val){
            char str[TEXT_MAXLEN] = {'\0'};
            sprintf(str, format.c_str(), val);
            PrintText(x, y, align, str);
        }
        
        void DrawTestPattern(void){
            DrawRect(4*width/6, 1*height/6, width/6, height/6, FGcolors::WHITE);
            DrawRectFill(3*width/6, 2*height/6, width/6, height/6, FGcolors::RED);
            DrawRectFill(4*width/6, 2*height/6, width/6, height/6, FGcolors::GREEN);
            DrawRectFill(5*width/6, 2*height/6, width/6, height/6, FGcolors::BLUE);
            DrawRectFill(12*width/2/12, 0, width/2/12, height/6, FGcolors::RED);
            DrawRectFill(13*width/2/12, 0, width/2/12, height/6, FGcolors::GREEN);
            DrawRectFill(14*width/2/12, 0, width/2/12, height/6, FGcolors::BLUE);
            DrawRectFill(15*width/2/12, 0, width/2/12, height/6, FGcolors::CYAN);
            DrawRectFill(16*width/2/12, 0, width/2/12, height/6, FGcolors::MAGENTA);
            DrawRectFill(17*width/2/12, 0, width/2/12, height/6, FGcolors::YELLOW);
            DrawRectFill(18*width/2/12, 0, width/2/12, height/6, FGcolors::ORANGE);
            DrawRectFill(19*width/2/12, 0, width/2/12, height/6, FGcolors::WHITE);
            DrawRectFill(20*width/2/12, 0, width/2/12, height/6, FGcolors::GRAY75);
            DrawRectFill(21*width/2/12, 0, width/2/12, height/6, FGcolors::GRAY50);
            DrawRectFill(22*width/2/12, 0, width/2/12, height/6, FGcolors::GRAY25);
            DrawRectFill(23*width/2/12, 0, width/2/12, height/6, FGcolors::BLACK);
 
            size_t N = width/2;
            for(size_t i = 0; i < N; ++i){
                double beta = (double)i/(double)N;
                DrawLine(i+N, 3*height/6, i+N, 4*height/6, beta, 0, 0);
                DrawLine(i+N, 4*height/6, i+N, 5*height/6, 0, beta, 0);
                DrawLine(i+N, 5*height/6, i+N, 6*height/6, 0, 0, beta);
                DrawLine(i, 3*height/6, i, 4*height/6, beta, beta, beta);
            }
            
            N = width/2/3;
            for(size_t i = 0; i < N; ++i){
                double beta = (double)i/(double)N;
                DrawLine(i,       4*height/6, i,       height - 1, beta,       0,          1.0 - beta);
                DrawLine(i + N,   4*height/6, i + N,   height - 1, 1.0 - beta, beta,       0         );
                DrawLine(i + 2*N, 4*height/6, i + 2*N, height - 1,          0, 1.0 - beta, beta      );
            }
            
            DrawCircle(3*width/4, height/4, height/6, 100, FGcolors::GRAY50);
            
            DrawLine(width/2, height/2, width - 1, 0, FGcolors::GRAY75);
            DrawLine(width/2, 0, width - 1, height/2, FGcolors::GRAY75);
            DrawLine(0, height/2, width - 1, height/2, FGcolors::WHITE);
            DrawLine(width/2, 0, width/2, height - 1, FGcolors::WHITE);
            
            PrintAllFontData();
            PrintValue(10, 20, FGalign::ALIGN_LEFT, "WIDTH  = %15.0f [px]", width);
            PrintValue(10, 30, FGalign::ALIGN_LEFT, "HEIGHT = %15.0f [px]", height);
            PrintValue(10, 40, FGalign::ALIGN_LEFT, "DEPTH  = %15.0f [bit]", depth);
            PrintValue(10, 50, FGalign::ALIGN_LEFT, "LENGTH = %15.0f [-]", length);
            PrintValue(10, 60, FGalign::ALIGN_LEFT, "SIZE   = %15.0f [byte]", size);
            PrintValue(10, 70, FGalign::ALIGN_LEFT, "XOFST  = %15.0f [-]", xofst);
            PrintValue(10, 80, FGalign::ALIGN_LEFT, "YOFST  = %15.0f [-]", yofst);
            PrintValue(10, 90, FGalign::ALIGN_LEFT, "XLEN   = %15.0f [-]", xlen);
            PrintValue(10,100, FGalign::ALIGN_LEFT, "BPPX   = %15.0f [bit/px]", bppx);
            PrintText(10, 120, FGalign::ALIGN_LEFT, "FRAME GRAPHICS TEST PATTERN");
            PrintText(10, 140, FGalign::ALIGN_LEFT, "frame graphics test pattern");
        }
        
        void PrintAllFontData(void){
            for(unsigned int i = FrameFontSmall::FST_ASCII; i <= FrameFontSmall::END_ASCII; ++i){
                WriteFont((i - FrameFontSmall::FST_ASCII)*(FrameFontSmall::WIDTH + TEXT_INTERVAL), 0, i);
            }
        }
        
        
        uint32_t ColorNameToData(FGcolors color){
            return ColorSet[static_cast<size_t>(color)];
        }
        
        uint32_t RGBcolorToData(double Red, double Green, double Blue){
            uint32_t r = 0, g = 0, b = 0;
            r = DoubleToRedIntensity(Red);      // 赤を変換
            g = DoubleToGreenIntensity(Green);  // 緑を変換
            b = DoubleToBlueIntensity(Blue);    // 青を変換
            return r | g | b;                   // ORをとって返す
        }
        
        uint32_t ARGBcolorToData(double Alpha, double Red, double Green, double Blue){
            uint32_t r = 0, g = 0, b = 0, a = 0;
            a = DoubleToAlphaIntensity(Alpha);  // 透過チャネルを変換
            r = DoubleToRedIntensity(Red);      // 赤を変換
            g = DoubleToGreenIntensity(Green);  // 緑を変換
            b = DoubleToBlueIntensity(Blue);    // 青を変換
            return a | r | g | b;               // ORをとって返す
        }
 
    private:
        FrameGraphics(const FrameGraphics& r) = delete;                 
        FrameGraphics(FrameGraphics&& r) = delete;                      
        const FrameGraphics& operator=(const FrameGraphics&) = delete;  
        
        // 色の定義
        static constexpr size_t NUM_COLOR_SET = 13; 
        
        static constexpr std::array<uint32_t, NUM_COLOR_SET> ColorSet = {
            0x00FF0000, 
            0x0000FF00, 
            0x000000FF, 
            0x0000FFFF, 
            0x00FF00FF, 
            0x00FFFF00, 
            0x00FF8000, 
            0x00FFFFFF, 
            0x00C0C0C0, 
            0x00808080, 
            0x00404040, 
            0x00000000, 
            0xFF000000  
        };
        
        // 共通画像情報関連
        uint32_t *Frame;        
        uint32_t *Screen;       
        uint32_t *Background;   
        int width;              
        int height;             
        int depth;              
        size_t length;          
        size_t size;            
        
        // フレームバッファ関連
        int fbfd;           
        struct fb_fix_screeninfo finfo; 
        struct fb_var_screeninfo vinfo; 
        int xofst;          
        int yofst;          
        int xlen;           
        int bppx;           
        
        // 文字列関連
        static constexpr unsigned int TEXT_INTERVAL = 1;    
        static constexpr unsigned int TEXT_MAXLEN = 256;    
        bool IsFontDataLocked;                              
        uint32_t FontPrepared[FrameFontSmall::NUM][FrameFontSmall::HEIGHT][FrameFontSmall::WIDTH];  
        
        inline size_t ConvCoordinateToIndex(int x, int y){
            return (size_t)width*(size_t)y + (size_t)x;
        }
        
        inline void DrawDot(int x, int y, uint32_t ColorData){
            size_t i = ConvCoordinateToIndex(x, y); // 座標からフレームバッファの要素番号を計算
            if(length <= i) return;                 // 範囲外のときは何もせず終了
            Screen[i] = ColorData;                  // 画面バッファに書き込み
        }
        
        uint32_t DoubleToIntensity(double u){
            if(1 < u) u = 1;
            if(u < 0) u = 0;
            return (uint32_t)((double)0x00FFFFFF*u);
        }
        
        uint32_t DoubleToRedIntensity(double u){
            if(1 < u) u = 1;
            if(u < 0) u = 0;
            return ((uint32_t)((double)0x000000FF*u)) << 16;
        }
        
        uint32_t DoubleToGreenIntensity(double u){
            if(1 < u) u = 1;
            if(u < 0) u = 0;
            return ((uint32_t)((double)0x000000FF*u)) << 8;
        }
        
        uint32_t DoubleToBlueIntensity(double u){
            if(1 < u) u = 1;
            if(u < 0) u = 0;
            return ((uint32_t)((double)0x000000FF*u));
        }
        
        uint32_t DoubleToAlphaIntensity(double u){
            if(1 < u) u = 1;
            if(u < 0) u = 0;
            return ((uint32_t)((double)0x000000FF*u)) << 24;
        }
 
        unsigned int ConvAsciiToIndex(unsigned int ascii){
            // アスキーコードが範囲外のときは範囲外用のフォントを使用
            if(ascii < FrameFontSmall::FST_ASCII || FrameFontSmall::END_ASCII < ascii){
                ascii = FrameFontSmall::END_ASCII + 1;
            }
            return ascii - FrameFontSmall::FST_ASCII;
        }
        
        void WriteFont(int x, int y, unsigned int ascii){
            if(IsFontDataLocked == true)return;             // フォントデータが準備中のときは何もせずに抜ける
            size_t i = ConvCoordinateToIndex(x, y);         // 座標からフレームバッファの要素番号を計算
            unsigned int index = ConvAsciiToIndex(ascii);   // アスキーコードから要素番号へ変換
            for(unsigned int j = 0; j < FrameFontSmall::HEIGHT; ++j){
                // フォントデータを1ラインずつフレームバッファへ書き込む
                memcpy(Screen + i + width*j, FontPrepared[index][j], FrameFontSmall::LINEBYTE32);
            }
        }
        
    };
 
}
 
#endif