src/FcTest_Triangulation.h - master - vTech/FcApps

src/FcTest_Triangulation.h
277 строк10 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#ifndef _FCTEST_TRIANGULATION_H_
#define _FCTEST_TRIANGULATION_H_

const char* FcTriangulation_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* FcTriangulation_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 _FcTest_Triangulation_t {
    FcUI_t						mUI;
    FcGL_Program_t				mProgram;
    FcGL_Texture_2D_t			mTexture;
    FcGL_Buffer_Array_v2_t      mPointBuffer;

    //FcUI_Buffer_Array_v1_GL_t			mGridBuffer;
    //GLuint								mGridLength;
    GLuint                      mPointNumber;
    GLint						mColorID;
    GLint						mMouse_uniform;
    

    size_t                      mOffsetPoints;
    FcVec2i32_t                     mPointsCurrentXY[512];
}FcTest_Triangulation_t;

FcError_t FcTest_Triangulation(FcPlatform_t* pPlatform);
FcError_t FcTest_Triangulation_free(FcTest_Triangulation_t* pSpace);

FCDEF FcWindow_Error_t FcTriangulation_initGL(FcWindow_t* pWindow, void* pSpace) {
    FcWindow_Error_t	mWindowError;
    const FcPlatform_GL_t* pPlatform_GL;
    FcGL_Texture_2D_Config_t mConfig;
    FcGL_Buffer_Array_setting_v2_t mSetting;
    GLfloat mBuffer[4][4];
    FcTest_Triangulation_t* mTest = (FcTest_Triangulation_t*)pSpace;
    
    pPlatform_GL = FcUI_Window_getPlatform_GL(&mTest->mUI.mWindow);
    FCUISAFECALLF(mWindowError, FcGL_Program(pPlatform_GL, FcTriangulation_vertex, NULL, NULL, FcTriangulation_fragment, NULL, &mTest->mProgram));


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

    mBuffer[0][0] = -1;
    mBuffer[0][1] = -1;
    mBuffer[0][2] = 0;
    mBuffer[0][3] = 0;

    mBuffer[1][0] = -1;
    mBuffer[1][1] = 1;
    mBuffer[1][2] = 0;
    mBuffer[1][3] = 1;

    mBuffer[2][0] = 1;
    mBuffer[2][1] = -1;
    mBuffer[2][2] = 1;
    mBuffer[2][3] = 0;

    mBuffer[3][0] = 1;
    mBuffer[3][1] = 1;
    mBuffer[3][2] = 1;
    mBuffer[3][3] = 1;


    for (size_t i = 0; i < 512; i++){
        mTest->mPointsCurrentXY[i].m[0] = (float)rand() / RAND_MAX - 0.5;
        mTest->mPointsCurrentXY[i].m[1] = (float)rand() / RAND_MAX - 0.5;
    }

    mSetting.mArrayData = mBuffer;
    mSetting.mSizeArray = sizeof(mBuffer);

    mSetting.mVertexAttrib[0] = "aPosition";
    mSetting.mVertexOffset[0] = 0;
    mSetting.mVertexStride[0] = 4 * sizeof(GLfloat);
    mSetting.mVertexVectorLength[0] = 2;

    mSetting.mVertexAttrib[1] = "aTexCoord";
    mSetting.mVertexOffset[1] = 2 * sizeof(GLfloat);
    mSetting.mVertexStride[1] = 4 * sizeof(GLfloat);
    mSetting.mVertexVectorLength[1] = 2;

    FcGL_Buffer_Array_v2(pPlatform_GL, &mTest->mProgram, &mTest->mPointBuffer, &mSetting);

    mConfig.mWrap = FcGL_Texture_WRAP_EDGE;
    mConfig.mFormat = FcGL_Texture_Format_RGBA;
    mConfig.mFilter = FcGL_Texture_Filter_NEAREST;
    mConfig.mData = NULL;
    mConfig.mWidth = FcUI_Window_getClientWidth(&mTest->mUI.mWindow);
    mConfig.mHeight = FcUI_Window_getClientHeight(&mTest->mUI.mWindow);

    FcGL_Texture_2D(pPlatform_GL, &mTest->mTexture, &mConfig);

    mTest->mPointNumber = sizeof(mTest->mPointsCurrentXY) / sizeof(*mTest->mPointsCurrentXY);
    
gError:
    return mWindowError;
}

FCDEF FcWindow_Error_t FcTriangulation_freeGL(FcWindow_t* pWindow, void* pSpace) {
    size_t i;
    FcWindow_Error_t	mWindowError = FCWINDOW_ERROR_NOERROR;
    const FcPlatform_GL_t* pPlatform_GL;
    FcTest_Triangulation_t* mTest = (FcTest_Triangulation_t*)pSpace;
    pPlatform_GL = FcUI_Window_getPlatform_GL(&mTest->mUI.mWindow);
    FcGL_Program_free(pPlatform_GL, &mTest->mProgram);
    FcGL_Texture_2D_free(pPlatform_GL, &mTest->mTexture);

    //FcUI_Buffer_Array_v1_GL_free(&mTest->mGridBuffer);
    FcGL_Buffer_Array_free_v2(pPlatform_GL, &mTest->mPointBuffer);
    return mWindowError;
}

size_t FcTest_Triangulation_drawGL(FcWindow_t* pWindow, void* data) {
    FcTest_Triangulation_t* mTest = (FcTest_Triangulation_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);
    //FcUI_Buffer_Array_v1_GL_bind_queue(pWindow, &mTest->mGridBuffer);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

        

    return 0;
}

size_t FcTriangulation_addPointGL(FcWindow_t* pWindow, void* data) {
    size_t i, j;
    FcImage_RGBA_t* mImage;
    FcImage_RGBA_t* mImageTriangulation;
    const FcPlatform_GL_t* pPlatform_GL = FcWindow_getPlatform_GL(pWindow);
    FcWindow_Error_t	mWindowError = FCWINDOW_ERROR_NOERROR;
    FcTest_Triangulation_t* mTest = (FcTest_Triangulation_t*)data;

    FcUI_Triangulation_greedy_t* mTriangulation;

    FcUI_Voronoi_Image(&mImage, mTest->mPointsCurrentXY, mTest->mOffsetPoints, FcUI_Window_getClientWidth(&mTest->mUI.mWindow), FcUI_Window_getClientHeight(&mTest->mUI.mWindow));
    FcGL_Texture_2D_copy(pPlatform_GL, &mTest->mTexture, mImage->mData, mImage->mWidth, mImage->mHeight);
    

    //for (size_t i = 0; i < 256; i++) {
    //    mTest->mPointsCurrentXY[i].m[0] = FcUI_Window_getClientWidth(&mTest->mUI.mWindow) * (float)rand() / RAND_MAX;
    //    mTest->mPointsCurrentXY[i].m[1] = FcUI_Window_getClientHeight(&mTest->mUI.mWindow) * (float)rand() / RAND_MAX;
    //}

    FcUI_Triangulation_greedy(&mTriangulation, mTest->mPointsCurrentXY, mTest->mOffsetPoints);

    FcUI_Triangulation_Image_g(&mImageTriangulation, mTriangulation, FcUI_Window_getClientWidth(&mTest->mUI.mWindow), FcUI_Window_getClientHeight(&mTest->mUI.mWindow));
    FcGL_Texture_2D_copy(pPlatform_GL, &mTest->mTexture, mImageTriangulation->mData, mImageTriangulation->mWidth, mImageTriangulation->mHeight);
    //mTest->mGridLength = mTest->mOffsetPoints;
    //FcUI_Buffer_Array_v1_GL_queue(pWindow, &mTest->mGridBuffer);
gError:
    //FcUI_Triangulation_free_d(&mTriangulation);
    FcUI_Triangulation_greedy_free(&mTriangulation);
    FcUI_Voronoi_Image_free(&mImage);
    FcUI_Triangulation_Image_g_free(&mImageTriangulation);
    return mWindowError;
}

void FcTest_Triangulation_UI_Input(FcUI_Input_data_t* pInput, void* pSpace) {
    int i;
    FcTest_Triangulation_t* mTest = (FcTest_Triangulation_t*)pSpace;
    
    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:
            mTest->mPointsCurrentXY[mTest->mOffsetPoints].m_i[0] = pInput->mEvent.mMouse.x;
            mTest->mPointsCurrentXY[mTest->mOffsetPoints].m_i[1] = pInput->mEvent.mMouse.y;
            mTest->mOffsetPoints++;
            FcUI_GraphicsQueue_push_funcGL(&mTest->mUI, FcTriangulation_addPointGL, mTest);

            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;
}

FcError_t FcTest_Triangulation(FcPlatform_t* pPlatform) {

    FcUI_Setting_t mUI_Config;
    FcUI_Font_Config_t mFontConfig;
    FcTest_Triangulation_t mTest = {0};
    FcError_t mError = FCERROR_NOERROR;

    memset(&mTest, 0, sizeof(mTest));
    memset(&mUI_Config, 0, sizeof(mUI_Config));
    memset(&mFontConfig, 0, sizeof(mFontConfig));

    FCUISAFECALL(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 = 1;
    mUI_Config.mWindowConfig.mFullscreen = false;
    mUI_Config.mGraphicsSetting.mTypeConfig = FCUI_CONFIG_GRAPHICS_GL_0;
    mUI_Config.mGraphicsSetting.pResizeWindow = NULL;
    mUI_Config.mGraphicsSetting.mData = NULL;

    FCUISAFECALLF(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.mFontName, TEXT("C:\\Windows\\Fonts\\Inkfree.ttf"), sizeof(TEXT("C:\\Windows\\Fonts\\Inkfree.ttf")));

    FcUI_Object_add_font(&mUI_Config.mObjects, &mFontConfig);

    FcUI_Input_t mInput;
    mInput.mFunction = &FcTest_Triangulation_UI_Input;
    mInput.mData0 = &mTest;
    for (size_t i = 0; i < 1; i++) {
        FCUISAFECALLF(mError, FcUI(&mTest.mUI, pPlatform, &mUI_Config));
        FCUISAFECALLF(mError, FcUI_set_Input(&mTest.mUI, &mInput));
        FCUISAFECALLF(mError, FcUI_GraphicsQueue_push_funcGL(&mTest.mUI, FcTriangulation_initGL, &mTest));
        FCUISAFECALLF(mError, FcUI_set_drawSceneGL(&mTest.mUI, FcTest_Triangulation_drawGL, &mTest));
        FCUISAFECALLF(mError, FcUI_dispatch(&mTest.mUI));
        FCUISAFECALLF(mError, FcTest_Triangulation_free(&mTest));
        FCUISAFECALLF(mError, FcUI_free(&mTest.mUI));

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

FcError_t FcTest_Triangulation_free(FcTest_Triangulation_t* pSpace) {
    FcError_t mError = FCERROR_NOERROR;
    FCUISAFECALLF(mError, FcUI_GraphicsQueue_push_funcGL(&pSpace->mUI, FcTriangulation_freeGL, pSpace));
gError:
    return mError;
}



#endif //_FCTEST_TRIANGULATION_H_