FcLibs/FcWindow/src/FcWindowGL/FcWindowGL_WINAPI/FcWindowGL_WINAPI_Definition.h - master - vTech/FcApps

FcLibs/FcWindow/src/FcWindowGL/FcWindowGL_WINAPI/FcWindowGL_WINAPI_Definition.h
612 строк20 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#include "FcWindowGL_WINAPI.h"
#if defined(_WIN32) || defined(_WIN64)
#ifndef __FCWINDOWGL_WINAPI_DEFENITION_H__
#define __FCWINDOWGL_WINAPI_DEFENITION_H__

FCDEF void FcWindowGL_WINAPI_callbackResize_default() {

}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI(FcPlatform_WINAPI_t* pPlatform_WINAPI, FcPlatform_GL_t* pPlatform_GL, FcWindowGL_WINAPI_t* pWindow, FcWindow_config_t* pConfig);

FCDEF size_t FcWindowGL_WINAPI_getHeight(const FcWindowGL_WINAPI_t* pWindow);
FCDEF size_t FcWindowGL_WINAPI_getWidth(const FcWindowGL_WINAPI_t* pWindow);
FCDEF size_t FcWindowGL_WINAPI_getClientHeight(const FcWindowGL_WINAPI_t* pWindow);
FCDEF size_t FcWindowGL_WINAPI_getClientWidth(const FcWindowGL_WINAPI_t* pWindow);
FCDEF const FcPlatform_GL_t* FcWindowGL_WINAPI_getPlatform_GL(const FcWindowGL_WINAPI_t* pWindow);
FCDEF FcWindow_Error_t FcWindowGL_WINAPI_dispatch(FcWindowGL_WINAPI_t* pWindow);
FCDEF FcWindow_Error_t FcWindowGL_WINAPI_free(FcWindowGL_WINAPI_t* pWindow);

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_setTitle(FcWindowGL_WINAPI_t* pWindow, const TCHAR* pText);
FCDEF FcWindow_Error_t FcWindowGL_WINAPI_show(FcWindowGL_WINAPI_t* pWindow);

FCDEF void FcWindowGL_WINAPI_setCallbackResizeWindow(FcWindowGL_WINAPI_t* pWindow, void (*callbackResizeWindow)(unsigned int width, unsigned int height, void* data_0, void* data_1), void* data_0, void* data_1);
FCDEF void FcWindowGL_WINAPI_setCallbackKeyboard(FcWindowGL_WINAPI_t* pWindow, void (*callbackKeyboard)(unsigned int keyCode, unsigned int keyEvent, void* data_1, void* data_2), void* data_0, void* data_1);
FCDEF void FcWindowGL_WINAPI_setCallbackMouse(FcWindowGL_WINAPI_t* pWindow, void (*callbackMouse)(unsigned int x, unsigned int y, unsigned int mouseKeyCode, void* data_0), void* data_0);
FCDEF void FcWindowGL_WINAPI_setDraw(FcWindowGL_WINAPI_t* pWindow, PFNFCWINDOWGLDRAWCALLBACKPROC callbackDrawWindow, void* data_0, void* data_1, void* data_2);

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_vSync_Enable(FcWindowGL_WINAPI_t* pWindow);
FCDEF FcWindow_Error_t FcWindowGL_WINAPI_vSync_Disable(FcWindowGL_WINAPI_t* pWindow);
FCDEF FcWindow_Error_t FcWindowGL_WINAPI_vSync_Adaptive(FcWindowGL_WINAPI_t* pWindow);

FCDEF size_t FcWindowGL_WINAPI_callbackResize_GL(void* pWindow);
FCDEF size_t FcWindowGL_WINAPI_DrawQueue_init(void* pWindow);
FCDEF size_t FcWindowGL_WINAPI_DrawQueue_free(void* pWindow);

FCDEF size_t FcWindowGL_WINAPI_callbackResize_GL(void* pWindow) {
	FcPlatform_GL_t* pPlatform_GL;
	FcWindowGL_WINAPI_t* mWindow = (FcWindowGL_WINAPI_t*) pWindow;
	pPlatform_GL = mWindow->mPlatform_GL;
	glViewport(0, 0, mWindow->mWidthClient, mWindow->mHeightClient);
	return 0;
}

FCDEF void FcWindowGL_WINAPI_callbackMouse_empty(unsigned x, unsigned y, unsigned c, void* v0) {};
FCDEF void FcWindowGL_WINAPI_callbackKeyboard_empty(unsigned k, unsigned e, void* v0, void* v1) {};
FCDEF void FcWindowGL_WINAPI_callbackResize_empty(unsigned h, unsigned w, void* v0, void* v1) {
	FcAlgo_ProducerConsumer_Data_t mData;
	FcWindowGL_WINAPI_t* pWindow = (FcWindowGL_WINAPI_t*)v0;
	mData.id = e_FcAlgo_callFunction_fp;
	mData.s0.p_v = FcWindowGL_WINAPI_callbackResize_GL;
	mData.s1.v = v0;
	FcWindowGL_DrawQueue_push(&pWindow->mDrawQueue, &mData);
};

FCDEF size_t FcWindowGL_WINAPI_callbackDraw_empty(FcWindowGL_WINAPI_t* pW, void* v0, void* v1, void* v2) { return 0; };

FCDEF int FcWindowGL_WINAPI_callback_error(size_t error, void* pWindow) {
	FcWindowGL_WINAPI_t* mWindow = (FcWindowGL_WINAPI_t*)pWindow;
	FcWindowGL_DrawQueue_Queue_free(&mWindow->mDrawQueue);
	if (error) {
		FcWindowGL_WINAPI_DrawQueue_free(pWindow);
		SendMessage(mWindow->mWindow, FCWINDOWGL_ATOM_WM_GL_ERROR, error, 0);
	}
	return error;
}


FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_setErrorFunction(FcWindowGL_WINAPI_t* pWindow, int (*pFunction)(size_t error, void* data), void* data);
FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_push(FcWindowGL_WINAPI_t* pWindow, size_t(*pFunction)(FcWindowGL_WINAPI_t* pWindow, void* data), void* data);
FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_pushCallback(FcWindowGL_WINAPI_t* pWindow, size_t(*pFunction)(FcWindowGL_WINAPI_t* pWindow, void* data), void* data);

FCDEF const FcPlatform_GL_t* FcWindowGL_WINAPI_getPlatform_GL(const FcWindowGL_WINAPI_t* pWindow) { if (!pWindow) return NULL; else return pWindow->mPlatform_GL; }

FCDEF size_t FcWindowGL_getMouse_X_WINAPI(FcWindowGL_WINAPI_t* pWindow) { return pWindow ? pWindow->mMouseX : 0; }
FCDEF size_t FcWindowGL_getMouse_Y_WINAPI(FcWindowGL_WINAPI_t* pWindow) { return pWindow ? pWindow->mMouseY : 0; }

FCDEF FcWindow_Error_t FcWindowGL_WINAPI(
	FcPlatform_WINAPI_t* pPlatform_WINAPI,
	FcPlatform_GL_t* pPlatform_GL,
	FcWindowGL_WINAPI_t* pWindow,
	FcWindow_config_t* pConfig
) {
	FcWindow_Error_t mError;
	RECT mWindowRect;
	FcAlgo_ProducerConsumer_Data_t mData = { 0 };
	if (!pPlatform_WINAPI ||
		!pPlatform_GL ||
		!pWindow ||
		!pConfig) {
		if (!pConfig)
			mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_pConfig;
		if (!pWindow)
			mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_pWindow;
		if (!pPlatform_GL)
			mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_pPlatform_GL;
		if (!pPlatform_WINAPI)
			mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_pPlatform_WINAPI;
		goto gError;
	}
	mData.id = e_FcAlgo_callFunction_fp;
	mData.s0.p_v = FcWindowGL_WINAPI_DrawQueue_init;
	mData.s1.v = pWindow;
	mData.s2.v = NULL;


	pWindow->mWindow = CreateWindow(FCWINDOWGL_REGISTER_CLASS, NULL, WS_OVERLAPPEDWINDOW, pConfig->mX, pConfig->mY, pConfig->mWidth, pConfig->mHeight, HWND_DESKTOP, NULL, pPlatform_WINAPI->mInstance, pWindow);

	if (!pWindow->mWindow) {
		mError = FCWINDOW_ERROR_WINAPI;
		goto gError;
	}

	pWindow->mPlatform_WINAPI = pPlatform_WINAPI;
	pWindow->mPlatform_GL = pPlatform_GL;
	//pWindow->mWidth = FcWindowGL_WINAPI_getWidth(pWindow);
	//pWindow->mHeight = FcWindowGL_WINAPI_getHeight(pWindow);

	FcWindowGL_WINAPI_setCallbackResizeWindow(pWindow, FcWindowGL_WINAPI_callbackResize_empty, pWindow, NULL);
	FcWindowGL_WINAPI_setCallbackMouse(pWindow, FcWindowGL_WINAPI_callbackMouse_empty, NULL);
	FcWindowGL_WINAPI_setCallbackKeyboard(pWindow, FcWindowGL_WINAPI_callbackKeyboard_empty, NULL, NULL);
	FcWindowGL_WINAPI_setDraw(pWindow, FcWindowGL_WINAPI_callbackDraw_empty, NULL, NULL, NULL);



	//HACCEL hAccelTable = LoadAccelerators(pPlatform_WINAPI->mInstance, MAKEINTRESOURCE(109));
	//ShowWindow(pWindow->mWindow, SW_SHOWNORMAL);
	//MSG msg;
	//while (GetMessage(&msg, NULL, 0, 0))
	//{
	//	if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
	//	{
	//		TranslateMessage(&msg);
	//		DispatchMessage(&msg);
	//	}
	//}




	mError = FcWindowGL_DrawQueue(&pWindow->mDrawQueue);
	if (mError) {
		goto gError;
	}
	mError = FcWindowGL_DrawQueue_push(&pWindow->mDrawQueue, &mData);
	if (mError) {
		goto gError;
	}

	mError = FcWindowGL_WINAPI_GraphicsQueue_setErrorFunction(pWindow, FcWindowGL_WINAPI_callback_error, pWindow);
	if (mError)
		goto gError;
	
	if (!GetClientRect(pWindow->mWindow, &mWindowRect)) {
		mError = FCWINDOW_ERROR_WINAPI;
		goto gError;
	}

	pWindow->mHeight = pConfig->mHeight;
	pWindow->mWidth = pConfig->mWidth;
	pWindow->mHeightClient = mWindowRect.bottom - mWindowRect.top;
	pWindow->mWidthClient = mWindowRect.right - mWindowRect.left;

	//mError = FcWindowGL_WINAPI_vSync_Enable(pWindow);
	//if (mError) {
	//	goto gError;
	//}

	return mError;
gError:
	FcWindowGL_WINAPI_free(pWindow);
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_setTimer1(FcWindowGL_WINAPI_t* pWindow, size_t mTime_msec, PFNFCWINDOWGLCALLBACKPROC pFunc, void* pData){
	USER_TIMER_MINIMUM;
	pWindow->mTimer1 = SetTimer(pWindow->mWindow, 1, mTime_msec, NULL);
	if (!pWindow->mTimer1)
		return FCWINDOW_ERROR_WINAPI;
	pWindow->mCallbackTimer1Window = pFunc;
	pWindow->mTimer1Data[0] = pData;

	return FCWINDOW_ERROR_NOERROR;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_killTimer1(FcWindowGL_WINAPI_t* pWindow){
	USER_TIMER_MINIMUM;
	if (pWindow->mTimer1)
		if (!KillTimer(pWindow->mWindow, pWindow->mTimer1))
			return FCWINDOW_ERROR_WINAPI;
	pWindow->mCallbackTimer1Window = NULL;
	pWindow->mTimer1Data[0] = 0;
	return FCWINDOW_ERROR_NOERROR;
}

FCDEF size_t FcWindowGL_WINAPI_getWindowDPI(const FcWindowGL_WINAPI_t* pWindow) {
	return pWindow ? GetDpiForWindow(pWindow->mWindow) : 0;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_hideCursor(FcWindowGL_WINAPI_t *pWindow) {
    FcWindow_Error_t mError = FCWINDOW_ERROR_NOERROR;
    if (!pWindow) {
        mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_hideCursor_pWindow_NULL;
        goto gError;
	}
    pWindow->mHideCursor = FALSE;
    ShowCursor(FALSE);
gError:
    return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_setCursorPosition(FcWindowGL_WINAPI_t* pWindow, size_t x, size_t y) {
    RECT mRect;
    FcWindow_Error_t mError = FCWINDOW_ERROR_NOERROR;
    if (!pWindow) {
        mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_setCursorPosition_pWindow_NULL;
        goto gError;
    }
    GetWindowRect(pWindow->mWindow, &mRect);
    SetCursorPos(mRect.left + x, mRect.top + y);
gError:
    return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_setTitle(FcWindowGL_WINAPI_t* pWindow, const TCHAR* pText)
{
	FcWindow_Error_t mError;
	if (!pWindow ||
		!pText) {
		if (!pText)
			mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_setTitle_pText;
		if (!pWindow)
			mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_setTitle_pWindow;
		goto gError;
	}
	mError = FCWINDOW_ERROR_NOERROR;
	if (!SetWindowText(pWindow->mWindow, pText)) {
		mError = FCWINDOW_ERROR_WINAPI;
		goto gError;
	}
gError:
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_show(FcWindowGL_WINAPI_t* pWindow) {
	FcWindow_Error_t mError;
	if (!pWindow) {
		mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_show_pWindow;
		goto gError;
	}
	mError = FCWINDOW_ERROR_NOERROR;
	if (IsWindow(pWindow->mWindow)) {
		ShowWindow(pWindow->mWindow, SW_SHOWNORMAL);
		SetForegroundWindow(pWindow->mWindow);
		UpdateWindow(pWindow->mWindow);
		SetFocus(pWindow->mWindow);
	}
gError:
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_fullscreen(FcWindowGL_WINAPI_t* pWindow) {
	FcWindow_Error_t mError;
	DWORD mStyle;
	MONITORINFO mMonitor = { 0 };
	if (!pWindow) {
		mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_fullscreen_pWindow;
		goto gError;
	}
	mError = FCWINDOW_ERROR_NOERROR;
	mMonitor.cbSize = sizeof(mMonitor);
	mStyle = GetWindowLong(pWindow->mWindow, GWL_STYLE);

	if (mStyle & WS_OVERLAPPEDWINDOW) {
		if (GetWindowPlacement(pWindow->mWindow, &pWindow->mWindowPlace_Prev) && GetMonitorInfo(MonitorFromWindow(pWindow->mWindow, MONITOR_DEFAULTTOPRIMARY), &mMonitor)) {
			SetWindowLong(pWindow->mWindow, GWL_STYLE, mStyle & ~WS_OVERLAPPEDWINDOW);
			SetWindowPos(pWindow->mWindow, HWND_TOP,
				mMonitor.rcMonitor.left, mMonitor.rcMonitor.top,
				mMonitor.rcMonitor.right - mMonitor.rcMonitor.left,
				mMonitor.rcMonitor.bottom - mMonitor.rcMonitor.top,
				SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
		}
	}
	else {
		SetWindowLong(pWindow->mWindow, GWL_STYLE, mStyle | WS_OVERLAPPEDWINDOW);
		SetWindowPlacement(pWindow->mWindow, &pWindow->mWindowPlace_Prev);
		SetWindowPos(pWindow->mWindow, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
	}

	pWindow->mFullscreen = true;

gError:
	return mError;
}

FCDEF void FcWindowGL_WINAPI_setCallbackResizeWindow(
	FcWindowGL_WINAPI_t* pWindow,
	void (*callbackResizeWindow)(unsigned int width, unsigned int height, void* data_0, void* data_1),
	void* data_0,
	void* data_1)
{
	pWindow->mCallbackResizeWindow = callbackResizeWindow;
	pWindow->mDataResizeCallback[0] = data_0;
	pWindow->mDataResizeCallback[1] = data_1;
}

FCDEF void FcWindowGL_WINAPI_setCallbackKeyboard(
	FcWindowGL_WINAPI_t* pWindow,
	void (*callbackKeyboard)(unsigned int keyCode, unsigned int keyEvent, void* data_1, void* data_2),
	void* data_0, void* data_1)
{
	pWindow->mCallbackKeyboard = callbackKeyboard;
	pWindow->mDataKeyboardCallback[0] = data_0;
	pWindow->mDataKeyboardCallback[1] = data_1;
}

FCDEF void FcWindowGL_WINAPI_setCallbackMouse(
	FcWindowGL_WINAPI_t* pWindow,
	void (*callbackMouse)(unsigned int x, unsigned int y,
		unsigned int mouseKeyCode,
		void* data_0),
	void* data_0) {
	pWindow->mCallbackMouse = callbackMouse;
	pWindow->mDataMouseCallback = data_0;
}

FCDEF void FcWindowGL_WINAPI_setDraw(FcWindowGL_WINAPI_t* pWindow,
	PFNFCWINDOWGLDRAWCALLBACKPROC callbackDrawWindow,
	void* data_0, void* data_1, void* data_2) {
	pWindow->mDraw = callbackDrawWindow;
	pWindow->mDrawData[0] = data_0;
	pWindow->mDrawData[1] = data_1;
	pWindow->mDrawData[2] = data_2;
}

FCDEF size_t FcWindowGL_WINAPI_getHeight(const FcWindowGL_WINAPI_t* pWindow) {
	RECT mSize;
	if (!pWindow) return 0;
	if (GetWindowRect(pWindow->mWindow, &mSize))
		return mSize.bottom - mSize.top;
	else
		return 0;
}

FCDEF size_t FcWindowGL_WINAPI_getWidth(const FcWindowGL_WINAPI_t* pWindow) {
	RECT mSize;
	if (!pWindow) return 0;
	if (GetWindowRect(pWindow->mWindow, &mSize))
		return mSize.right - mSize.left;
	else
		return 0;
}

FCDEF size_t FcWindowGL_WINAPI_getClientHeight(const FcWindowGL_WINAPI_t* pWindow) {
	RECT mRect;
	if (!pWindow) return 0;
	if (GetClientRect(pWindow->mWindow, &mRect))
		return mRect.bottom - mRect.top;
	else
		return 0;
}

FCDEF size_t FcWindowGL_WINAPI_getClientWidth(const FcWindowGL_WINAPI_t* pWindow) {
	RECT mRect;
	if (!pWindow) return 0;
	if (GetClientRect(pWindow->mWindow, &mRect))
		return mRect.right - mRect.left;
	else
		return 0;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_vSync_Enable(FcWindowGL_WINAPI_t* pWindow) {
	FcWindow_Error_t mError;
	FcAlgo_ProducerConsumer_Data_t mData = { 0 };

	if (pWindow == NULL) {
		mError = FCWINDOW_ERROR_PARAMETER_0;
		goto gError;
	}

	mData.id = e_FcAlgo_callFunction_fpp;
	mData.s0.p_vv = (FcWindow_Error_t (*)(void*, void*))FcWGL_vSync_Enable;
	mData.s1.v = pWindow->mPlatform_GL;
	mData.s2.v = &pWindow->mContext.mContext;

	mError = FcWindowGL_DrawQueue_push(&pWindow->mDrawQueue, &mData);
	if (mError)
		goto gError;
gError:
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_vSync_Disable(FcWindowGL_WINAPI_t* pWindow) {
	FcWindow_Error_t mError;
	FcAlgo_ProducerConsumer_Data_t mData = { 0 };

	if (pWindow == NULL) {
		mError = FCWINDOW_ERROR_PARAMETER_0;
		goto gError;
	}

	mData.id = e_FcAlgo_callFunction_fpp;
	mData.s0.p_vv = (FcWindow_Error_t(*)(void*, void*))FcWGL_vSync_Disable;
	mData.s1.v = pWindow->mPlatform_GL;
	mData.s2.v = &pWindow->mContext.mContext;

	mError = FcWindowGL_DrawQueue_push(&pWindow->mDrawQueue, &mData);
	if (mError)
		goto gError;
gError:
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_vSync_Adaptive(FcWindowGL_WINAPI_t* pWindow) {
	FcWindow_Error_t mError;
	FcAlgo_ProducerConsumer_Data_t mData = { 0 };

	if (pWindow == NULL) {
		mError = FCWINDOW_ERROR_PARAMETER_0;
		goto gError;
	}

	mData.id = e_FcAlgo_callFunction_fpp;
	mData.s0.p_vv = (FcWindow_Error_t(*)(void*, void*))FcWGL_vSync_Adaptive;
	mData.s1.v = pWindow->mPlatform_GL;
	mData.s2.v = &pWindow->mContext.mContext;

	mError = FcWindowGL_DrawQueue_push(&pWindow->mDrawQueue, &mData);
	if (mError)
		goto gError;
gError:
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_dispatch(FcWindowGL_WINAPI_t* pWindow) {
	FcWindow_Error_t mError;
	MSG msg;
	LRESULT mStatus = true;
	if (NULL == pWindow) {
		mError = FCWINDOW_ERROR_FcWindowGL_WINAPI_dispatch_pWindow;
		goto gError;
	}
	mError = FcWindowGL_WINAPI_show(pWindow);
	if (mError)
		goto gError;
	/*HACCEL hAccel = LoadAccelerators(pWindow->mPlatform->mWindowPlatform.mInstance, MAKEINTRESOURCE(IDR_ACCELERATOR));

	while ((result = GetMessage(&msg, pWindow->mWindow, 0, 0)) > 0) {
		if (!TranslateAccelerator(pWindow->mWindow, hAccel, &msg))
		{
			if (!IsDialogMessage(pWindow->mWindow, &msg))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
	}*/
	
	while ((mStatus = GetMessage(&msg, NULL, 0, 0)) > 0) {

		if (!IsDialogMessage(pWindow->mWindow, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
	if (msg.message == WM_QUIT) {
		mError = msg.wParam;
	}
gError:

	//FcWindowGL_WINAPI_free(pWindow);
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_free(FcWindowGL_WINAPI_t* pWindow) {
	FcWindow_Error_t mError;
	FcAlgo_ProducerConsumer_Data_t mData = { 0 };

	mData.id = e_FcAlgo_callFunction_fp;
	mData.s0.p_v = FcWindowGL_WINAPI_DrawQueue_free;
	mData.s1.v = pWindow;
	mData.s2.v = NULL;

	if (pWindow == NULL) {
		mError = FCWINDOW_ERROR_PARAMETER_0;
		goto gError;
	}

	//if (!FcThread_running(&pWindow->mDrawThread.mThread)) {
	//mError = FCWINDOWGL_ERRORS_FUNCTION_PARAMETERS;
	//    goto gError;
	//}
	mError = FcWindowGL_WINAPI_killTimer1(pWindow);
	if (mError)
		goto gError;
	mError = FcWindowGL_DrawQueue_push(&pWindow->mDrawQueue, &mData);
	if (mError)
		goto gError;
	mError = FcWindowGL_DrawQueue_free(&pWindow->mDrawQueue);
	if (mError)
		goto gError;

	if (IsWindow(pWindow->mWindow))
		if (!DestroyWindow(pWindow->mWindow))
			mError = FCWINDOW_ERROR_WINAPI;

gError:
	if (pWindow)
		memset(pWindow, 0, sizeof(*pWindow));
	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_setErrorFunction(FcWindowGL_WINAPI_t* pWindow,
	int (*pFunction)(size_t error, void* data),
	void* data) {
	return FcWindowGL_DrawQueue_setErrorFunction(&pWindow->mDrawQueue, pFunction, data);
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_Callback_free(FcWindowGL_WINAPI_t* pWindow) {
	return FcWindowGL_DrawQueue_Callback_free(&pWindow->mDrawQueue);
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_push(FcWindowGL_WINAPI_t* pWindow,
	size_t(*pFunction)(FcWindowGL_WINAPI_t* pWindow, void* data),
	void* data) {
	FcWindow_Error_t mError;
	FcAlgo_ProducerConsumer_Data_t mData = { 0 };
	mData.id = e_FcAlgo_callFunction_fpp;
	mData.s0.p_vv = (size_t(*)(void*, void*))(pFunction);
	mData.s1.v = pWindow;
	mData.s2.v = data;
	mError = FcWindowGL_DrawQueue_push(&pWindow->mDrawQueue, &mData);

	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_sync(FcWindowGL_WINAPI_t* pWindow){
	FcWindow_Error_t mError;
	mError = FcWindowGL_DrawQueue_sync(&pWindow->mDrawQueue);

	return mError;
}

FCDEF FcWindow_Error_t FcWindowGL_WINAPI_GraphicsQueue_pushCallback(FcWindowGL_WINAPI_t* pWindow,
	size_t(*pFunction)(FcWindowGL_WINAPI_t* pWindow, void* data),
	void* data) {
	FcWindow_Error_t mError;
	FcAlgo_ProducerConsumer_Data_t mData = { 0 };
	mData.id = e_FcAlgo_callbackFunction_fpp;
	mData.s0.p_vv = (size_t(*)(void*, void*))pFunction;
	mData.s1.v = pWindow;
	mData.s2.v = data;
	mError = FcWindowGL_DrawQueue_Callback_init(&pWindow->mDrawQueue, &mData);

	return mError;
}

FCDEF size_t FcWindowGL_WINAPI_DrawQueue_init(void* pWindow) {
	FcWindow_Error_t mError;
	GLint mFlags;
	FcPlatform_GL_t* pPlatform_GL;
	FcWindowGL_WINAPI_t* mWindow;
	FcGL_Context_Window_Options_t mOptions = { 0 };
	mWindow = (FcWindowGL_WINAPI_t*)pWindow;

	mOptions.mOptions.sRGB = true;
	mOptions.mOptions.mDebug = true;
	mOptions.mOptions.mMajor = 4;
	mOptions.mOptions.mMinor = 6;
	mOptions.mOptions.mWindow = mWindow->mWindow;
	pPlatform_GL = mWindow->mPlatform_GL;
	mError = FcGL_Context_Window_Native(mWindow->mPlatform_GL, &mWindow->mContext, &mOptions);
	if (mError)
		goto gError;

	printf("%s\n", glGetString(GL_VENDOR));
	printf("%s\n", glGetString(GL_RENDERER));
	printf("%s\n", glGetString(GL_VERSION));

	glGetIntegerv(GL_CONTEXT_FLAGS, &mFlags);
	if (mFlags & GL_CONTEXT_FLAG_DEBUG_BIT) {
		glEnable(GL_DEBUG_OUTPUT);
		glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
		glDebugMessageCallback(glCallback, NULL);
		glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
	}

	return mError;
gError:
	if (mError)
		SendMessage(mWindow->mWindow, mWindow->mPlatform_WINAPI->mAtom_GL_ERROR, mError, 0);

	*((FcWindow_Error_t*)& mWindow->mDrawQueue.mErrorStatus) = mError;
	return mError;
}

FCDEF size_t FcWindowGL_WINAPI_DrawQueue_free(void* pWindow) {
	FcWindowGL_WINAPI_t* mWindow = (FcWindowGL_WINAPI_t*)pWindow;
	FcWindow_Error_t mError = FcGL_Context_Window_Native_free(mWindow->mPlatform_GL, &mWindow->mContext);
	if (mError) {
		goto gError;
	}
	return mError;
gError:
	if (mError)
		SendMessage(mWindow->mWindow, mWindow->mPlatform_WINAPI->mAtom_GL_ERROR, mError, 0);
	*((FcWindow_Error_t*)&mWindow->mDrawQueue.mErrorStatus) = mError;
	return mError;
}

#endif //__FCWINDOWGL_WINAPI_DEFENITION_H__
#endif //_WIN32