src/FcTest_Pixel.h - master - vTech/FcApps

src/FcTest_Pixel.h
376 строк13 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#ifndef _FCTEST_FONT_PIXEL_H_
#define _FCTEST_FONT_PIXEL_H_

//#include "FcUI_Mouse.h"
#include "FcTest_pixelField.h"

#define SAVE_BUTTON 1
#define DRAW_CURVE 3
#define DRAW_LINE 2 

const char* mFcTest_Font_Pixel_vertex = "#version 430\n"
"in vec2 aPosition;"
"in vec2 aTexCoord;"
"uniform mat4 uMVP;"
"uniform vec2 uMouse;"
"out mat4 fView;"
"out vec2 fMouse;"
"out vec2 fTexCoord;"
"void main(){"
"fMouse = uMouse;"
"fTexCoord = aTexCoord;"
"gl_Position = uMVP * vec4(aPosition, 0, 1);"
"}";

const char* FcTest_Font_Pixel_fragment = "#version 430\n"
"#define STEP 16.0\n"
"#define FSTEP (1.0 / (STEP))\n"
"in vec2 fTexCoord;"
"in vec2 fMouse;"
"uniform sampler2D sTexture;"
"out vec4 FragColor;"
"void main(){"
"	vec2 blockFrag = ceil(gl_FragCoord.xy * FSTEP);\n"
"	vec2 mMouse = ceil(fMouse / STEP); mMouse = mMouse * STEP - STEP / 2.;\n"
"	float mDist = smoothstep(STEP / 2., 0., length(gl_FragCoord.xy - mMouse));\n"
"	vec2 stepLine = step(vec2(FSTEP), fract(gl_FragCoord.xy * FSTEP));\n"
"	FragColor.rgba = texture(sTexture, fTexCoord).rgba;\n"
"	FragColor.rgba += vec4(stepLine.x + stepLine.y) * FSTEP;\n"
"	FragColor.rgba += vec4(mDist);\n"
"}";


typedef struct _FcTest_Font_Pixel_t {
	FcPlatform_t* mPlatform;
	FcImage_RGBA_t* mImage;
	FcFont_t					mFont;
	FcUI_t						mUI;
	FcGL_Program_t				mProgram;
	FcGL_Texture_2D_t			mTexture;
	FcUI_Buffer_v2_GL_t			mBuffer;
	uint32_t					mLineCurve;

	GLint						mMVP_uniform;
	GLint						mMouse_uniform;

	//FcUI_Mouse_Model_t			mModelMouse;

	FcUI_Raster_Primitive_pixelPoints_t	mPointData;

}FcTest_Font_Pixel_t;

FCDEF FcError_t FcTest_Font_Pixel(FcPlatform_t* pPlatform, FcTest_Font_Pixel_t* pFont);
FCDEF FcError_t FcTest_Font_Pixel_free(FcTest_Font_Pixel_t* pFont);
FCDEF size_t FcTest_Font_Pixel_initGL(FcWindow_t* pWindow, void* pFont);
FCDEF size_t FcTest_Font_Pixel_sceneGL(FcWindow_t* pWindow, void* pFont);
FCDEF size_t FcTest_Font_Pixel_updateTextureGL(FcWindow_t* pWindow, void* pFont);

void FcTest_Font_Pixel_Input(FcUI_Input_data_t* pInput, void* pUI) {
	FcUI_Error_t mError_UI = FCUI_ERROR_NOERROR;
	FcError_t mError = FCERROR_NOERROR;
	FcTest_Font_Pixel_t* mPixel;
	FcUI_t* mUI;
	if (!pInput || !pUI) goto gError;

	mUI = (FcUI_t*)pUI;
	mPixel = (FcTest_Font_Pixel_t*)mUI->mInput.mData0;

	if (pInput->mType == FCUI_INPUT_DEVICE_MOUSE) {
		//printf("%f %f\n", mPixel->mModelMouse.mScale.m[0], mPixel->mModelMouse.mScale.m[1]);
		if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Left_PRESS && !(pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Motion)) {
			//FcUI_Mouse_Model_LeftPress(&mPixel->mModelMouse, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
			if (mPixel->mLineCurve == DRAW_LINE) {
				FcTest_Font_pixelField_pointOnCurve(&mPixel->mPointData, mPixel->mImage, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
			}
			else if (mPixel->mLineCurve == DRAW_CURVE) {
				//FcTest_Font_pixelField_pointOnCurve(&mPixel->mPointData, mPixel->mImage, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
				FcTest_Font_pixelField_pointOffCurve(&mPixel->mPointData, mPixel->mImage, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
			}
			FcTest_Font_pixelField_draw(&mPixel->mPointData, mPixel->mImage);
			FCUISAFECALLIFF(mError, mError_UI, FcUI_GraphicsQueue_push_funcGL(&mPixel->mUI, FcTest_Font_Pixel_updateTextureGL, mPixel), FcError);
		}
		if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Right_PRESS && !(pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Motion)) {

		}
		if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Left_RELEASE) {
			//FcUI_Mouse_Model_LeftRelease(&mPixel->mModelMouse, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
		}
		if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Right_RELEASE) {
			//mUI = mUI;
		}
		/*if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_ScrollUp) {
			FcUI_Mouse_Model_ScrollUp(&mPixel->mModelMouse, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
		}
		if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_ScrollDown) {
			FcUI_Mouse_Model_ScrollDown(&mPixel->mModelMouse, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
		}
		if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Motion) {
			FcUI_Mouse_Model_Motion(&mPixel->mModelMouse, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);
		}*/
	}
gError:
	return;
}

void FcTest_Font_Save(size_t type, void* pUI, void* pData1, void* pData2) {
	size_t i, j;
	uint8_t* mDigit;
	FcTest_Font_Pixel_t* pPixel = (FcTest_Font_Pixel_t*)pData2;
	FcUI_Button_t* mButton;
	switch (type) {
	case FCUI_OBJECT_BUTTON:
		mButton = (FcUI_Button_t*)pData1;
		switch (mButton->mID) {
		case SAVE_BUTTON:
			for (j = i = 0; i <= pPixel->mPointData.mOffsetPoint; i++) {
				j += pPixel->mPointData.mFlags[i] & FCUI_RASTER_PRIMITIVE_ONCURVE ? sizeof("ON:X") : 0;
				j += pPixel->mPointData.mFlags[i] & FCUI_RASTER_PRIMITIVE_OFFCURVE ? sizeof("OFF:X") : 0;
				j += FcString_uint64(NULL, pPixel->mPointData.mPoints[i].m[0]) + 1;
				j += pPixel->mPointData.mFlags[i] & FCUI_RASTER_PRIMITIVE_ONCURVE ? sizeof("Y=") : 0;
				j += FcString_uint64(NULL, pPixel->mPointData.mPoints[i].m[1]) + 1;
			}

			mDigit = (uint8_t*)calloc(1, j + 1);
			if (mDigit) {
				for (j = i = 0; i <= pPixel->mPointData.mOffsetPoint; i++) {
					j += pPixel->mPointData.mFlags[i] & FCUI_RASTER_PRIMITIVE_ONCURVE ? FcString_strCopy(mDigit + j, (const uint8_t*)"ON:X=") : 0;
					j += pPixel->mPointData.mFlags[i] & FCUI_RASTER_PRIMITIVE_OFFCURVE ? FcString_strCopy(mDigit + j, (const uint8_t*)"OFF:X=") : 0;
					j += FcString_uint64(&mDigit[j], pPixel->mPointData.mPoints[i].m[0]) + 1; mDigit[j - 1] = ' ';
					j += pPixel->mPointData.mFlags[i] & FCUI_RASTER_PRIMITIVE_ONCURVE ? FcString_strCopy(mDigit + j, (const uint8_t*)"Y=") : 0;
					j += FcString_uint64(&mDigit[j], pPixel->mPointData.mPoints[i].m[1]) + 1; mDigit[j - 1] = ' ';
				}
				FcFile_Write("SAVE_Curve.txt", (void*)mDigit, j);
				free(mDigit);
			}
			break;
		case DRAW_LINE:
			pPixel->mLineCurve = DRAW_LINE;
			break;
		case DRAW_CURVE:
			pPixel->mLineCurve = DRAW_CURVE;
			break;
		}
		break;
	}
	mButton = NULL;
}

void FcTest_Font_resizeWindow(unsigned width, unsigned height, void* pWindow, void* pData) {
	FcWindow_t* mWindow;
	FcTest_Font_Pixel_t* pFont;
	FcUI_Error_t mError_UI = FCUI_ERROR_NOERROR;
	FcError_t mError = FCERROR_NOERROR;
	if (!pWindow && !pData) return;
	pFont = (FcTest_Font_Pixel_t*)pData;
	mWindow = (FcWindow_t*)pWindow;
	//FcWindow_GraphicsQueue_push_GL(mWindow, FcTest_Font_resizeWindowGL, pData);

	//*FcUI_Mouse_getModel(&pFont->mModelMouse) = FcMatrix4x4f_glOrtho(0, width, 0, height, 0, 1);

	if (pFont->mImage) {
		FcImage_RGBA_free(pFont->mImage);
	}
	pFont->mImage = FcImage_RGBA(width, height);
	FcTest_Font_pixelField_draw(&pFont->mPointData, pFont->mImage);
	FCUISAFECALLIFF(mError, mError_UI, FcUI_GraphicsQueue_push_funcGL(&pFont->mUI, FcTest_Font_Pixel_updateTextureGL, pFont), FcError);
	FcUI_GraphicsQueue_sync(&pFont->mUI);
gError:
	return;
}

FCDEF FcError_t FcTest_Pixel(FcPlatform_t* pPlatform) {
	FcError_t mError;
	FcTest_Font_Pixel_t mFont = { 0 };
    FCUISAFECALLF(mError, FcTest_Font_Pixel(pPlatform, &mFont));

	FCUISAFECALLF(mError, FcTest_Font_Pixel_free(&mFont));
gError:
	return mError;
}

FCDEF FcError_t FcTest_Font_Pixel(FcPlatform_t* pPlatform, FcTest_Font_Pixel_t* pFont) {
	FcUI_Setting_t mConfig;
	FcUI_Input_t  mInput;
	size_t mID[3];
	TCHAR* mText[3];
	size_t mTextLength[3];
	FcUI_Object_Button_t mButton = { 0 };
	FcUI_Error_t mError_UI = FCUI_ERROR_NOERROR;
	FcError_t mError = FCERROR_NOERROR;
	FCUISAFECALL(mError, (pFont), FCERROR_FUNCTION_PARAMETERS);

	FcUI_Object(&mConfig.mObjects);

	mID[0] = SAVE_BUTTON;
	mID[1] = DRAW_LINE;
	mID[2] = DRAW_CURVE;
	mText[0] = TEXT("Save");
	mText[1] = TEXT("Line");
	mText[2] = TEXT("Curve");
	mTextLength[0] = sizeof(TEXT("Save"));
	mTextLength[1] = sizeof(TEXT("Line"));
	mTextLength[2] = sizeof(TEXT("Curve"));

	for (size_t i = 0; i < 3; i++) {

		mButton.mID = mID[i];
		mButton.mX = 40;
		mButton.mY = 36 + i * 51;
		mButton.mWidth = 80;
		mButton.mHeight = 50;
		mButton.mFontHeight = 24;
		mButton.mTextColor = 0xffffffff;
		mButton.mDefaultColor = 0xff995577;
		mButton.mType = FCUI_OBJECT_BUTTON;
		mButton.mCallback = FcTest_Font_Save;
		mButton.mData = pFont;
		memcpy(mButton.mText, mText[i], mTextLength[i]);
		FcUI_Object_add_button(&mConfig.mObjects, &mButton);

	}


	mConfig.mWindowConfig.mWidth = 1280;
	mConfig.mWindowConfig.mHeight = 800;
	mConfig.mWindowConfig.mX = 0;
	mConfig.mWindowConfig.mY = 0;
	mConfig.mWindowConfig.mVSync = false;
	mConfig.mWindowConfig.mFullscreen = 0;
	mConfig.mGraphicsSetting.mTypeConfig = FCUI_CONFIG_GRAPHICS_GL_0;
	mConfig.mGraphicsSetting.pResizeWindow = FcTest_Font_resizeWindow;
	mConfig.mGraphicsSetting.mData = pFont;

	mInput.mFunction = FcTest_Font_Pixel_Input;
	mInput.mData0 = pFont;
	mInput.mData1 = NULL;
	mInput.mData2 = NULL;

	FcTest_Font_pixelField_init(&pFont->mPointData);

	FCUISAFECALLIFF(mError, mError_UI, FcUI(&pFont->mUI, pPlatform, &mConfig), FcError);

	//FCUISAFECALLIFF(mError, mError_UI, FcUI_Mouse_Model(&pFont->mModelMouse, FcUI_Window_getWindow(&pFont->mUI.mWindow)), FcError);

	FCUISAFECALLIFF(mError, mError_UI, FcUI_GraphicsQueue_push_funcGL(&pFont->mUI, FcTest_Font_Pixel_initGL, pFont), FcError);
	FCUISAFECALLIFF(mError, mError_UI, FcUI_set_drawSceneGL(&pFont->mUI, FcTest_Font_Pixel_sceneGL, pFont), FcError);


	FCUISAFECALLIFF(mError, mError_UI, FcUI_set_Input(&pFont->mUI, &mInput), FcError);


	FCUISAFECALLIFF(mError, mError_UI, FcUI_dispatch(&pFont->mUI), FcError);

	pFont->mPlatform = pPlatform;
	FcUI_Object_free(&mConfig.mObjects);
gError:
	return mError;
}
FCDEF size_t FcTest_Font_Pixel_initGL(FcWindow_t* pWindow, void* pFont) {
	float mVertex[16];
	int mIndex[6];
	float gl_FragCoord[2];
	ptrdiff_t mWidth, mHeight;

	FcWindow_Error_t				mWindowError;
	FcUI_Buffer_v2_GL_config_t		mBufferConfig;
	FcGL_Texture_2D_Config_t		mTextureConfig;
	const FcPlatform_GL_t* pPlatform_GL;
	FcTest_Font_Pixel_t* mFont = (FcTest_Font_Pixel_t*)pFont;
	pPlatform_GL = FcUI_Window_getPlatform_GL(&mFont->mUI.mWindow);
	FCUISAFECALLF(mWindowError, FcGL_Program(pPlatform_GL, mFcTest_Font_Pixel_vertex, NULL, NULL, FcTest_Font_Pixel_fragment, NULL, &mFont->mProgram));

	mWidth = FcWindow_getClientWidth(pWindow);
	mHeight = FcWindow_getClientHeight(pWindow);

	mBufferConfig.mWindow = pWindow;
	mBufferConfig.mNameAttrib[0] = "aPosition";
	mBufferConfig.mNameAttrib[1] = "aTexCoord";
	mBufferConfig.mProgram = &mFont->mProgram;
	mBufferConfig.mData = mVertex;
	mBufferConfig.mIndex = mIndex;
	mBufferConfig.mDataSize = 16 * sizeof(float);
	mBufferConfig.mIndexSize = 6 * sizeof(int);
	mBufferConfig.mAttribVectorLength[0] = 2;
	mBufferConfig.mAttribVectorLength[1] = 2;

	mTextureConfig.mHeight = mHeight;// mImage->mHeight; 
	mTextureConfig.mWidth = mWidth;//mImage->mWidth;
	mTextureConfig.mFormat = FcGL_Texture_Format_RGBA;
	mTextureConfig.mFilter = FcGL_Texture_Filter_NEAREST;
	mTextureConfig.mWrap = FcGL_Texture_WRAP_EDGE;
	mTextureConfig.mData = NULL;

	_FcUI_RectangleGL_v2f(&mVertex, &mIndex, 0, 0, 2, 2);
	FcUI_Buffer_v2_GL(&mFont->mBuffer, &mBufferConfig);
	FcGL_Texture_2D(pPlatform_GL, &mFont->mTexture, &mTextureConfig);

	mFont->mMVP_uniform = FcGL_Program_getUniformLocation(pPlatform_GL, &mFont->mProgram, "uMVP");
	mFont->mMouse_uniform = FcGL_Program_getUniformLocation(pPlatform_GL, &mFont->mProgram, "uMouse");

gError:
	//FcImage_RGBA_free(mImage);

	return mWindowError;
}

FCDEF size_t FcTest_Font_Pixel_freeGL(FcWindow_t* pWindow, void* pFont) {
	FcWindow_Error_t				mWindowError;
	const FcPlatform_GL_t* pPlatform_GL;
	FcTest_Font_Pixel_t* mFont = (FcTest_Font_Pixel_t*)pFont;

	pPlatform_GL = FcUI_Window_getPlatform_GL(&mFont->mUI.mWindow);

	FcGL_Program_free(pPlatform_GL, &mFont->mProgram);
	FcUI_Buffer_v2_GL_free(&mFont->mBuffer);
	FcGL_Texture_2D_free(pPlatform_GL, &mFont->mTexture);

	FcImage_RGBA_free(mFont->mImage);
	return 0;
}

FCDEF size_t FcTest_Font_Pixel_sceneGL(FcWindow_t* pWindow, void* pFont) {
	FcMatrix4x4f_t mMVP;
	const FcPlatform_GL_t* pPlatform_GL;
	FcTest_Font_Pixel_t* mFont = (FcTest_Font_Pixel_t*)pFont;

	mMVP = FcMatrix4x4f_identity();

	pPlatform_GL = FcUI_Window_getPlatform_GL(&mFont->mUI.mWindow);


	FcGL_Program_use(pPlatform_GL, &mFont->mProgram);
	//FcGL_Program_Uniform_bind_m4(pPlatform_GL, &mFont->mProgram, mFont->mMVP_uniform, &FcUI_Mouse_getModel(&mFont->mModelMouse)->ml);
	FcGL_Program_Uniform_bind_m4(pPlatform_GL, &mFont->mProgram, mFont->mMVP_uniform, &mMVP.ml);
	FcGL_Program_Uniform_bind_f2(pPlatform_GL, &mFont->mProgram, mFont->mMouse_uniform, FcWindow_getMouse_X(pWindow), FcWindow_getMouse_Y(pWindow));
	FcGL_Texture_2D_bind(pPlatform_GL, &mFont->mTexture);
	FcUI_Buffer_v2_GL_bind_queue(pWindow, &mFont->mBuffer);

	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

	return 0;
}

FCDEF size_t FcTest_Font_Pixel_updateTextureGL(FcWindow_t* pWindow, void* pFont) {
	const FcPlatform_GL_t* pPlatform_GL;
	FcTest_Font_Pixel_t* mFont = (FcTest_Font_Pixel_t*)pFont;
	pPlatform_GL = FcUI_Window_getPlatform_GL(&mFont->mUI.mWindow);
	if (mFont->mImage)
		FcGL_Texture_2D_copy(pPlatform_GL, &mFont->mTexture, mFont->mImage->mData, mFont->mImage->mWidth, mFont->mImage->mHeight);
	return 0;
}

FCDEF FcError_t FcTest_Font_Pixel_free(FcTest_Font_Pixel_t* pFont) {
	const FcPlatform_GL_t* pPlatform_GL;
	FcUI_Error_t mError_UI = FCUI_ERROR_NOERROR;
	FcError_t mError = FCERROR_NOERROR;
	FCUISAFECALL(mError, (pFont), FCERROR_FUNCTION_PARAMETERS);

	FCUISAFECALLIFF(mError, mError_UI, FcUI_GraphicsQueue_push_funcGL(&pFont->mUI, FcTest_Font_Pixel_freeGL, pFont), FcError);

	FCUISAFECALLIFF(mError, mError_UI, FcUI_free(&pFont->mUI), FcError);

gError:
	return mError;
}

#endif //_FCTEST_FONT_PIXEL_H_