src/FlapyBird.h - master - vTech/FcApps

src/FlapyBird.h
374 строки12 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#ifndef __FLAPY_BIRD_H__
#define __FLAPY_BIRD_H__

#include "FcLibs.h"

typedef enum _FlapyBird_e {
    FLAPY_BIRD_MENU_START = 1,
    FLAPY_BIRD_MENU_SETTING = 2,
    FLAPY_BIRD_MENU_EXIT = 4,
    FLAPY_BIRD_MENU_BACK,
    FLAPY_BIRD_MENU_VSYNC
}FlapyBird_e;

const char* FlapyBird_vertex = R"glsl(
#version 330 core
in vec2 aPosition;
in vec2 aTexCoord;
out vec2 fTexCoord;
void main() {
    fTexCoord = aTexCoord;
    gl_Position = vec4(aPosition, 0, 1);
}
)glsl";

const char* FlapyBird_fragment = R"glsl(
#version 330 core
out vec4 FragColor;
in vec2 fTexCoord;
uniform sampler2D mTexture;
void main() {

    FragColor = vec4(0.1,0.1,0.1,1) + texture(mTexture, fTexCoord);
})glsl";

typedef struct _Flapy_Bird_t {
	FcUI_t mUI;
    FcGL_Program_t mProgram;

}Flapy_Bird_t;

FCDEF FcError_t Flapy_Bird(FcPlatform_t* pPlatform);

FCDEF FcError_t Flapy_Bird_free(Flapy_Bird_t* pFlapyBird);
void FlapyBird_ButtonFunc(FCUI_OBJECT type, void* pUI, void* pData1, void* pData2);

FCDEF FcWindow_Error_t FlapyBird_initGL(FcWindow_t* pWindow, void* pFlapyBird) {
    FcWindow_Error_t	mWindowError;
    const FcPlatform_GL_t* pPlatform_GL;
    FcGL_Texture_2D_Config_t mConfig;
    FcGL_Buffer_Array_setting_v2_t mSetting;
    Flapy_Bird_t* mTest = (Flapy_Bird_t*)pFlapyBird;

    pPlatform_GL = FcUI_Window_getPlatform_GL(&mTest->mUI.mWindow);
    FCUISAFECALLF(mWindowError, FcGL_Program(pPlatform_GL, FlapyBird_vertex, NULL, NULL, FlapyBird_fragment, NULL, &mTest->mProgram));


    //mTest->mColorID = FcGL_Program_getUniformLocation(pPlatform_GL, &mTest->mProgram, "uObjectColor");

gError:
    return mWindowError;
}

size_t FlapyBird_drawGL(FcWindow_t* pWindow, void* data) {
    Flapy_Bird_t* mTest = (Flapy_Bird_t*)data;
    const FcPlatform_GL_t* pPlatform_GL = FcWindow_getPlatform_GL(pWindow);

    FcGL_Program_use(pPlatform_GL, &mTest->mProgram);

    //FcGL_Texture_2D_bind(pPlatform_GL, &mTest->mTexture);

    //FcGL_Buffer_Array_bind_v2(pPlatform_GL, &mTest->mPointBuffer);

    //glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    return 0;
}

FCDEF FcWindow_Error_t FlapyBird_freeGL(FcWindow_t* pWindow, void* pFlapyBird) {
    size_t i;
    FcWindow_Error_t	mWindowError = FCWINDOW_ERROR_NOERROR;
    const FcPlatform_GL_t* pPlatform_GL;
    Flapy_Bird_t* mTest = (Flapy_Bird_t*)pFlapyBird;
    pPlatform_GL = FcUI_Window_getPlatform_GL(&mTest->mUI.mWindow);
    FcGL_Program_free(pPlatform_GL, &mTest->mProgram);

    return mWindowError;
}

void FlapyBird_Input(FcUI_Input_data_t* pInput, void* pFlapyBird) {
    int i;
    Flapy_Bird_t* mTest = (Flapy_Bird_t*)pFlapyBird;

    ptrdiff_t							mWidth, mHeight;

    mWidth = FcUI_Window_getClientWidth(&mTest->mUI.mWindow);
    mHeight = FcUI_Window_getClientHeight(&mTest->mUI.mWindow);

    switch (pInput->mType) {
    case FCUI_INPUT_DEVICE_MOUSE:

        switch (pInput->mEvent.mMouse.mouseKeyCode) {
        case FCWINDOW_MOUSE_Left_PRESS:


            break;
        case FCWINDOW_MOUSE_ScrollUp:
            break;
        case FCWINDOW_MOUSE_ScrollDown:
            break;
        }
        break;
    case FCUI_INPUT_DEVICE_KEYBOARD:
        if (pInput->mEvent.mKeyboard.keyEvent == FCWINDOW_KEYBOARD_PRESS) {
            break;
        }
    }
    //FcImage_RGBA_free(mImage);
    return;
}

FcUI_Error_t FlapyBird_Menu_Setting(Flapy_Bird_t* pBird) {
    FcUI_Object_Button_t mButton;
    FcUI_Object_RadioButton_t mRadioButton;
    FcUI_Object_t mUI_Objects;
    FcUI_Config_Setting_t mConfigSetting;
    FcError_t mError;
    TCHAR* mText[] = {
        TEXT("Back"),
        TEXT("vSync")
    };
    size_t mID_MENU[] = {
        FLAPY_BIRD_MENU_BACK,
        FLAPY_BIRD_MENU_VSYNC,
    };
    size_t mLength[] = {
        sizeof(TEXT("Back")),
        sizeof(TEXT("vSync"))
    };
    memset(&mUI_Objects, 0, sizeof(mUI_Objects));
    FCLIBSSAFECALLF(mError, FcUI_Object(&mUI_Objects));

    mError = FCERROR_NOERROR;
    for (size_t i = 0; i < 1; i++) {
        mButton.mX = 100;
        mButton.mY = 50 + i * 50;
        mButton.mHeight = 34;
        mButton.mWidth = 100;
        mButton.mFontHeight = 16;
        mButton.mID = mID_MENU[i];
        mButton.mDefaultColor = 0xff4499ff;
        mButton.mSelectColor = 0x00116699;
        mButton.mTextColor = 0xffffffff;
        memcpy(mButton.mText, mText[i], mLength[i]);
        mButton.mType = FCUI_OBJECT_BUTTON;
        mButton.mCallback = FlapyBird_ButtonFunc;
        mButton.mData = pBird;
        FCLIBSSAFECALLF(mError, FcUI_Object_add_button(&mUI_Objects, &mButton));
    }

    for (size_t i = 1; i < 2; i++) {
        mRadioButton.mX = 200;
        mRadioButton.mY = 50 + i * 50;
        mRadioButton.mHeight = 30;
        mRadioButton.mFontHeight = 16;
        mRadioButton.mID = mID_MENU[i];
        mRadioButton.mDefaultColor = 0x55449911;
        mRadioButton.mSelectColor = 0x00116699;
        mRadioButton.mType = FCUI_OBJECT_BUTTON;
        mRadioButton.mCallback = FlapyBird_ButtonFunc;
        mRadioButton.mData = pBird;
        FCUISAFECALLF(mError, FcUI_Object_add_radioButton(&mUI_Objects, &mRadioButton));
    }

    mConfigSetting.mTypeConfig = FCUI_CONFIG_GRAPHICS_GL_0;
    mConfigSetting.pResizeWindow = NULL;
    mConfigSetting.mData = NULL;

    FCLIBSSAFECALLF(mError, FcUI_initUI(&pBird->mUI, &mUI_Objects, &mConfigSetting));
gError:
    FcUI_Object_free(&mUI_Objects);
    return mError;
}

FcUI_Error_t FlapyBird_Menu(Flapy_Bird_t* pBird) {
    FcUI_Object_Button_t mButton;
    FcUI_Object_t mUI_Objects;
    FcUI_Config_Setting_t mConfigSetting;
    FcError_t mError;
    TCHAR* mText[] = {
        TEXT("Start"),
        TEXT("Setting"),
        TEXT("Exit")
    };
    size_t mID_MENU[] = {
        FLAPY_BIRD_MENU_START,
        FLAPY_BIRD_MENU_SETTING,
        FLAPY_BIRD_MENU_EXIT
    };
    size_t mLength[] = {
        sizeof(TEXT("Start")),
        sizeof(TEXT("Setting")),
        sizeof(TEXT("Exit"))
    };
    memset(&mUI_Objects, 0, sizeof(mUI_Objects));

    FCLIBSSAFECALL(mError, (pBird), FCERROR_FUNCTION_PARAMETERS);

    FCLIBSSAFECALLF(mError, FcUI_Object(&mUI_Objects));

    for (size_t i = 0; i < 3; i++) {
        mButton.mX = 100;
        mButton.mY = 150 - i * 50;
        mButton.mHeight = 34;
        mButton.mWidth = 100;
        mButton.mFontHeight = 16;
        mButton.mID = mID_MENU[i];
        mButton.mDefaultColor = 0x55449911;
        mButton.mSelectColor = 0x00116699;
        mButton.mTextColor = 0xffffffff;
        memcpy(mButton.mText, mText[i], mLength[i]);
        mButton.mType = FCUI_OBJECT_BUTTON;
        mButton.mCallback = FlapyBird_ButtonFunc;
        mButton.mData = pBird;
        FCUISAFECALLF(mError, FcUI_Object_add_button(&mUI_Objects, &mButton));
    }

    mConfigSetting.mTypeConfig = FCUI_CONFIG_GRAPHICS_GL_0;
    mConfigSetting.pResizeWindow = NULL;
    mConfigSetting.mData = NULL;

    FCLIBSSAFECALLF(mError, FcUI_initUI(&pBird->mUI, &mUI_Objects, &mConfigSetting));
gError:
    FcUI_Object_free(&mUI_Objects);
    return mError;
}

void FlapyBird_ButtonFunc(FCUI_OBJECT type, void* pUI, void* pData1, void* pData2) {
    FcUI_t* mUI = (FcUI_t*)pUI;
    Flapy_Bird_t* pBird = (Flapy_Bird_t*)pData2;
    FcUI_Button_t* mButton;
    FcUI_TextView_t* mTextView;
    FcUI_RadioButton_t* mRadioButton;


    switch (type) {
    case FCUI_OBJECT_BUTTON:
        mButton = (FcUI_Button_t*)pData1;
        if (mButton->mID == FLAPY_BIRD_MENU_START) {

        }
        else if (mButton->mID == FLAPY_BIRD_MENU_SETTING) {
           FlapyBird_Menu_Setting(pBird);
        }
        else if (mButton->mID == FLAPY_BIRD_MENU_BACK) {
           FlapyBird_Menu(pBird);
        }
        else if (mButton->mID == FLAPY_BIRD_MENU_EXIT) {
           Flapy_Bird_free(pBird);
        }
        break;
    case FCUI_OBJECT_TEXTVIEW:
        mTextView = (FcUI_TextView_t*)pData1;
        break;
    case FCUI_OBJECT_RADIOBUTTON:
        mRadioButton = (FcUI_RadioButton_t*)pData1;
        if (mRadioButton->mID == FLAPY_BIRD_MENU_VSYNC) {
            if (mRadioButton->mStatus == FCUI_ACTIVITY_RADIOBUTTON_ENABLE) {
                FcUI_Window_vSync_Enable(mUI);
                mRadioButton->mStatus = FCUI_ACTIVITY_RADIOBUTTON_DISABLE;
            }
            else {
                FcUI_Window_vSync_Disable(mUI);
                mRadioButton->mStatus = FCUI_ACTIVITY_RADIOBUTTON_ENABLE;
            }
        }
        break;
    }


}


FCDEF FcError_t Flapy_Bird(FcPlatform_t* pPlatform) {
    TCHAR* mText[] = {
        TEXT("Start"),
        TEXT("Setting"),
        TEXT("Exit")
    };
    size_t mID_MENU[] = {
        FLAPY_BIRD_MENU_START,
        FLAPY_BIRD_MENU_SETTING,
        FLAPY_BIRD_MENU_EXIT
    };
    size_t mLength[] = {
        sizeof(TEXT("Start")),
        sizeof(TEXT("Setting")),
        sizeof(TEXT("Exit"))
    };
	FcUI_Setting_t mUI_Config;
    FcUI_Font_Config_t mFontConfig;
    FcUI_Object_Button_t mButton;
    FcUI_Object_RadioButton_t mRadioButton;
    Flapy_Bird_t mBird = { 0 };
	FcError_t mError = FCERROR_NOERROR;
	FCLIBSSAFECALL(mError, (pPlatform), FCERROR_FUNCTION_PARAMETERS);

    mUI_Config.mWindowConfig.mY = 100;
    mUI_Config.mWindowConfig.mX = 100;
    mUI_Config.mWindowConfig.mWidth = 1280;
    mUI_Config.mWindowConfig.mHeight = 720;
    mUI_Config.mWindowConfig.mVSync = false;
    mUI_Config.mWindowConfig.mFullscreen = false;
    mUI_Config.mGraphicsSetting.mTypeConfig = FCUI_CONFIG_GRAPHICS_GL_0;
    mUI_Config.mGraphicsSetting.pResizeWindow = NULL;
    mUI_Config.mGraphicsSetting.mData = NULL;

    FCLIBSSAFECALLF(mError, FcUI_Object(&mUI_Config.mObjects));

    mFontConfig.mType = FCUI_FONT_ATLAS_SDF;
    mFontConfig.mData.mBasic.mHeight = 2048;
    mFontConfig.mData.mBasic.mWidth = 2048;
    mFontConfig.mData.mBasic.mPixelHeight = 128;
    memcpy(mFontConfig.mDictionary, TEXT("Back"), sizeof(TEXT("Back")));
    memcpy(mFontConfig.mFontName, TEXT("C:\\Windows\\Fonts\\Inkfree.ttf"), sizeof(TEXT("C:\\Windows\\Fonts\\Inkfree.ttf")));

    FcUI_Object_add_font(&mUI_Config.mObjects, &mFontConfig);

    for (size_t i = 0; i < 3; i++) {
        mButton.mX = 100;
        mButton.mY = 150 - i * 50;
        mButton.mHeight = 34;
        mButton.mWidth = 100;
        mButton.mFontHeight = 16;
        mButton.mID = mID_MENU[i];
        mButton.mDefaultColor = 0x55449911;
        mButton.mSelectColor = 0x00116699;
        mButton.mTextColor = 0xffffffff;
        memcpy(mButton.mText, mText[i], mLength[i]);
        mButton.mType = FCUI_OBJECT_BUTTON;
        mButton.mCallback = FlapyBird_ButtonFunc;
        mButton.mData = &mBird;
        FCUISAFECALLF(mError, FcUI_Object_add_button(&mUI_Config.mObjects, &mButton));
    }
    


    FcUI_Input_t mInput;
    mInput.mFunction = &FlapyBird_Input;
    mInput.mData0 = &mBird;

    FCLIBSSAFECALLF(mError, FcUI(&mBird.mUI, pPlatform, &mUI_Config));
    FCLIBSSAFECALLF(mError, FcUI_set_Input(&mBird.mUI, &mInput));
    FCLIBSSAFECALLF(mError, FcUI_GraphicsQueue_push_funcGL(&mBird.mUI, FlapyBird_initGL, &mBird));
    FCLIBSSAFECALLF(mError, FcUI_set_drawSceneGL(&mBird.mUI, FlapyBird_drawGL, &mBird));
    FCLIBSSAFECALLF(mError, FcUI_dispatch(&mBird.mUI));
    //FCLIBSSAFECALLF(mError, Flapy_Bird_free(&mBird));

gError:
    FcUI_Object_free(&mUI_Config.mObjects);
	return mError;
}

FCDEF FcError_t Flapy_Bird_free(Flapy_Bird_t* pFlapyBird) {
    FcError_t mError = FCERROR_NOERROR;
    FCLIBSSAFECALL(mError, (pFlapyBird), FCERROR_FUNCTION_PARAMETERS);
    
    FCUISAFECALLF(mError, FcUI_GraphicsQueue_push_funcGL(&pFlapyBird->mUI, FlapyBird_freeGL, pFlapyBird));
    FCLIBSSAFECALLF(mError, FcUI_free(&pFlapyBird->mUI));
    //memset(pFlapyBird, 0, sizeof(*pFlapyBird));
gError:
    return mError;
}

#endif //__FLAPY_BIRD_H__