src/FcTest_Space.h - master - vTech/FcApps

src/FcTest_Space.h
361 строка12 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#ifndef _FC_TEST_SPACE_H_
#define _FC_TEST_SPACE_H_

#include "FcLibs.h"
#include "FcMath.h"
//#include "FcGame/src/FcObject.h"
#include "GL/glcorearb.h"
#include <FcUI_Algo/FcUI_Fortune.h>

const char* FcSpace_vertex = R"glsl(
#version 330 core
layout(location=0) in vec4 aPosition;
uniform mat4 model;
uniform mat4 mMVP;
out float lightIntensity;
void main() {
    gl_Position = mMVP * model * aPosition;
    vec3 worldPos = (model * aPosition).xyz;
    vec3 normal = normalize(aPosition.xyz);
    vec3 dirToCenter = normalize(-worldPos);
    lightIntensity = max(dot(normal, dirToCenter), 0.25);})glsl";

const char* FcSpace_fragment = R"glsl(
#version 330 core
in float lightIntensity;
out vec4 FragColor;
uniform vec4 uObjectColor;
void main() {
   
        FragColor = vec4(uObjectColor.rgb, uObjectColor.a);
        //float fade = smoothstep(0.0, 1.0, lightIntensity*10);
       // FragColor = vec4(uObjectColor.rgb * fade, uObjectColor.a);
})glsl";

typedef struct _FcTest_Space_t{
	FcUI_t						mUI;
	FcUI_Camera_t				mCamera;

	FcPlatform_t*               mPlatform;
	FcImage_RGBA_t*             mImage;
	FcFont_t					mFont;
	FcGL_Program_t				mProgram;
	FcGL_Texture_2D_t			mTexture;
	uint32_t					mLineCurve;

	FcUI_Buffer_Array_v1_GL_t			mBufferGrid, mBufferCube;
	GLuint								mGridLength, mCubeLength;

	GLint						mModelID;
	GLint						mMVP_ID;
	GLint						mColorID;
	GLint						mMouse_uniform;

	size_t mNumberObjects;
    //FcObject_Sphere_t mObjects[3];
}FcTest_Space_t;



FcError_t FcTest_Space(FcPlatform_t* pPlatform);
FcError_t FcTest_Space_free(FcTest_Space_t* pSpace);

void FcTest_CreateSphere_free(FcVec4f_t** mVertices);
void FcTest_Space_UI_Input(FcUI_Input_data_t* pInput, void* pUI); 
void FcTest_Space_UI_Func(FCUI_OBJECT type, void* pUI, void* pData1, void* pData2);



void CreateGridVertices(FcVec4f_t** mVertex, size_t* length, float size) {
	ptrdiff_t x, y, z, i= 0;
	float halfSize = size / 2.0f;
	float mStep = 1.f;
	*mVertex = (FcVec4f_t*)malloc(size * size * size * sizeof(FcVec4f_t));
	*length = 0;
	if (*mVertex) {
		for (z = -halfSize; z < halfSize; z += 1) {
			for (y = -halfSize; y < halfSize; y += 1) {
				for (x = -halfSize; x < halfSize; x += 1) {
					(*mVertex)[i++] = FcVec4f(x * mStep, 0, z * mStep, 1);
				}
			}
		}
		*length = size * size * size;
	}

}

void FcTest_CreateSphere_free(FcVec4f_t** mVertices){
    free(*mVertices);
}

FCDEF FcWindow_Error_t FcSpace_initGL(FcWindow_t* pWindow, void* pSpace) {
	FcVec4f_t mCube[36];
	FcVec4f_t* mGrid;
	size_t mLength;
	FcWindow_Error_t	mWindowError;
	const FcPlatform_GL_t* pPlatform_GL;
    FcUI_Buffer_Array_v1_GL_config_t mBufferConfig;
	FcUI_Triangulation_t mTriangulation = { 0 };
	FcTest_Space_t* mTest = (FcTest_Space_t*)pSpace;
	mGrid = NULL;
	pPlatform_GL = FcUI_Window_getPlatform_GL(&mTest->mUI.mWindow);
	FCUISAFECALLF(mWindowError, FcGL_Program(pPlatform_GL, FcSpace_vertex, NULL, NULL, FcSpace_fragment, NULL, &mTest->mProgram));
	

    mTest->mModelID = FcGL_Program_getUniformLocation(pPlatform_GL, &mTest->mProgram, "model");
    mTest->mMVP_ID = FcGL_Program_getUniformLocation(pPlatform_GL, &mTest->mProgram, "mMVP");
	mTest->mColorID		= FcGL_Program_getUniformLocation(pPlatform_GL, &mTest->mProgram, "uObjectColor");

	mTest->mCamera = FcUI_Camera_default(&mTest->mUI.mWindow);

	mTest->mNumberObjects = 2;

    //FcObject_Sphere(mTest->mObjects + 0, &mTest->mUI.mWindow, &mTest->mProgram, FcVec3f(0, 0, 0), FcVec3f(0, 0, 0), FcVec3f(1.0f, 1.0f, 1.0f), 2.00 * pow(10, 30), 1.409);
    //FcObject_Sphere(mTest->mObjects + 1, &mTest->mUI.mWindow, &mTest->mProgram, FcVec3f(1.496 * pow(10, 11), 0, 1), FcVec3f(0, 0, 0), FcVec3f(0.9f, 1.0f, 0.7f), 5.97219 * pow(10, 24), 1.409);


    CreateGridVertices(&mGrid, &mLength, 4.0f);

	mBufferConfig.mWindow = FcUI_Window_getWindow(&mTest->mUI.mWindow);
	mBufferConfig.mNameAttrib[0] = "aPosition";
	mBufferConfig.mAttribVectorLength[0] = 4;
    mBufferConfig.mProgram = &mTest->mProgram;
	mBufferConfig.mData = (float*)mGrid;
	mBufferConfig.mDataSize = mLength * sizeof(*mGrid);

	FCUISAFECALLF(mWindowError, FcUI_Buffer_Array_v1_GL(&mTest->mBufferGrid, &mBufferConfig));	
	
	FcUI_Cube(&mCube, 0.2);

    mBufferConfig.mWindow = FcUI_Window_getWindow(&mTest->mUI.mWindow);
    mBufferConfig.mNameAttrib[0] = "aPosition";
    mBufferConfig.mAttribVectorLength[0] = 4;
    mBufferConfig.mProgram = &mTest->mProgram;
    mBufferConfig.mData = (float*)mCube;
    mBufferConfig.mDataSize = sizeof(mCube);

    FCUISAFECALLF(mWindowError, FcUI_Buffer_Array_v1_GL(&mTest->mBufferCube, &mBufferConfig));


    mTest->mCubeLength = sizeof(FcUI_Cube_vertex) / sizeof(FcVec4f_t);
	mTest->mGridLength = mLength;
	//FcWindow_hideCursor(pWindow);
gError:
	free(mGrid);
	FcUI_Triangulation_free(&mTriangulation);
	return mWindowError;
}

FCDEF FcWindow_Error_t FcSpace_freeGL(FcWindow_t* pWindow, void* pSpace) {
	size_t i;
	FcWindow_Error_t	mWindowError = FCWINDOW_ERROR_NOERROR;
	const FcPlatform_GL_t* pPlatform_GL;
	FcTest_Space_t* mSpace = (FcTest_Space_t*)pSpace;
	pPlatform_GL = FcUI_Window_getPlatform_GL(&mSpace->mUI.mWindow);
    FcGL_Program_free(pPlatform_GL, &mSpace->mProgram);
	//for (i = 0; i < mSpace->mNumberObjects; i++)
	//	FcObject_Sphere_free(mSpace->mObjects + i);

	return mWindowError;
}


size_t FcTest_Space_draw(FcWindow_t* pWindow, void* data){
	FcMatrix4x4f_t mMatrix0, mMatrix1;
	size_t i, j;
	FcTest_Space_t* mTest = (FcTest_Space_t*)data;
	const FcPlatform_GL_t* pPlatform_GL = FcWindow_getPlatform_GL(pWindow);

	FcGL_Program_use(pPlatform_GL, &mTest->mProgram);


	FcUI_Camera_updateCameraVectors(&mTest->mCamera);


	glUniformMatrix4fv(mTest->mMVP_ID, 1, GL_FALSE, FcUI_Camera_GetMVP(&mTest->mCamera).ml);

	//for (ptrdiff_t i = -3; i < 4; i+=1){

		mMatrix0 = FcMatrix4x4f_identity();

	//	mMatrix0 = FcMatrix4x4f_gl_translate(&mMatrix0, FcVec4f(i, 0, 0, 0) );
	//	glUniform4f(mTest->mColorID, 0.7, 0.5, 1, 1);

		glUniformMatrix4fv(mTest->mModelID, 1, GL_FALSE, mMatrix0.ml);
		FcUI_Buffer_Array_v1_GL_bind_queue(pWindow, &mTest->mBufferCube);

		glDrawArrays(GL_TRIANGLES, 0, mTest->mCubeLength);
	//}


	
	glUniform4f(mTest->mColorID, 0.5, 0.5, 1, 1);

	FcUI_Buffer_Array_v1_GL_bind_queue(pWindow, &mTest->mBufferGrid);

    glDrawArrays(GL_POINTS, 0, mTest->mGridLength);


	/*for (i = 0; i < mTest->mNumberObjects; i++) {
        for (j = 0; j < mTest->mNumberObjects; j++) {
            float dx = mTest->mObjects[i].mObject.mPosition.m[0] - mTest->mObjects[j].mObject.mPosition.m[0];
            float dy = mTest->mObjects[i].mObject.mPosition.m[1] - mTest->mObjects[j].mObject.mPosition.m[1];
            float dz = mTest->mObjects[i].mObject.mPosition.m[2] - mTest->mObjects[j].mObject.mPosition.m[2];
            float distance = sqrt(dx * dx + dy * dy + dz * dz);

            if (distance > 0) {
                FcVec3f_t direction = {dx / distance, dy / distance, dz / distance};
                distance *= 1000;
                double Gforce = (6.6743e-11 * mTest->mObjects[i].mObject.mMass * mTest->mObjects[j].mObject.mMass) /
                                (distance * distance);


                float acc1 = Gforce / mTest->mObjects[i].mObject.mMass;
                FcVec3f_t acc = {direction.m[0] * acc1, direction.m[1] * acc1, direction.m[2] * acc1};

                FcObject_Sphere_Accelerate(&mTest->mObjects[i], acc.m[0], acc.m[1], acc.m[2]);


                float mCollision = FcObject_Sphere_CheckCollision(&mTest->mObjects[i], &mTest->mObjects[j]);
                mTest->mObjects[i].mObject.mVelocity.m[0] *= mCollision;
                mTest->mObjects[i].mObject.mVelocity.m[1] *= mCollision;
                mTest->mObjects[i].mObject.mVelocity.m[2] *= mCollision;
            }
        }

        FcObject_Sphere_UpdatePos(&mTest->mObjects[i]);
    }
		
	for (i = 0; i < mTest->mNumberObjects; i++) {
		glUniform4f(mTest->mColorID, mTest->mObjects[i].mObject.mColor.m[0], mTest->mObjects[i].mObject.mColor.m[1], mTest->mObjects[i].mObject.mColor.m[2], mTest->mObjects[i].mObject.mColor.m[3]);
		mMatrix0 = FcMatrix4x4f_identity();

		mMatrix0 = FcMatrix4x4f_gl_translate(&mMatrix0, mTest->mObjects[i].mObject.mPosition);


		glUniformMatrix4fv(mTest->mModelID, 1, GL_FALSE, mMatrix0.ml);
		FcUI_Buffer_Array_v1_GL_bind_queue(pWindow, &mTest->mObjects[i].mBuffer);
		glDrawArrays(GL_TRIANGLES, 0, mTest->mObjects[i].mVertexLength);
	}*/

	return 0;
}

void FcTest_Space_UI_Func(FCUI_OBJECT type, void* pUI, void* pData1, void* pData2){
	FcUI_t* mUI = (FcUI_t*)pUI;
	FcUI_Button_t* mButton;
	FcUI_TextView_t* mTextView;
	FcUI_RadioButton_t* mRadioButton;
	switch (type) {
	case FCUI_OBJECT_BUTTON:
		mButton = (FcUI_Button_t*)pData1;
		break;
	case FCUI_OBJECT_TEXTVIEW:
		mTextView = (FcUI_TextView_t*)pData1;
		break;
	case FCUI_OBJECT_RADIOBUTTON:
		mRadioButton = (FcUI_RadioButton_t*)pData1;
		break;
	}


	return;
}

void FcTest_Space_UI_Input(FcUI_Input_data_t* pInput, void* pSpace) {
	int i;
	FcTest_Space_t* mTest = (FcTest_Space_t*)pSpace;
	//FcImage_RGBA_t* mImage;
	size_t							mWidth, mHeight;
	TCHAR* mText = TEXT("Hello World!");

	//mImage = FcImage_RGBA(mWidth, mHeight);

	switch (pInput->mType) {
	case FCUI_INPUT_DEVICE_MOUSE:			

			FcUI_Camera_ProcessMouseMovement(&mTest->mCamera, pInput->mEvent.mMouse.x, pInput->mEvent.mMouse.y);	
			//FcWindow_setCursorPos(&mTest->mUI.mWindow.mWindow, FcWindow_getClientWidth(&mTest->mUI.mWindow.mWindow) / 2, FcWindow_getClientHeight(&mTest->mUI.mWindow.mWindow) / 2);

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

					FcUI_Camera_Scroll(&mTest->mCamera, 1.f);
				break;
			case FCWINDOW_MOUSE_ScrollDown:
					FcUI_Camera_Scroll(&mTest->mCamera, -1.f);

				break;
			}
		break;
	case FCUI_INPUT_DEVICE_KEYBOARD:
		if (pInput->mEvent.mKeyboard.keyEvent == FCWINDOW_KEYBOARD_PRESS) {

			FcUI_Camera_Keyboard(&mTest->mCamera, pInput->mEvent.mKeyboard.keyCode, 1);

			break;
		}
	}
	//FcImage_RGBA_free(mImage);
}

FcError_t FcTest_Space(FcPlatform_t* pPlatform){
    
	FcUI_Setting_t mUI_Config;
	FcUI_Font_Config_t mFontConfig;
	//FcUI_Object_TextView_t mTextView;
	//FcUI_Object_Button_t mButton;

    FcTest_Space_t mTest = { 0 };
    FcError_t mError = FCERROR_NOERROR;

    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_Space_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, FcSpace_initGL, &mTest));
        FCUISAFECALLF(mError, FcUI_set_drawSceneGL(&mTest.mUI, FcTest_Space_draw, &mTest));
		FCUISAFECALLF(mError, FcUI_dispatch(&mTest.mUI));
        FCUISAFECALLF(mError, FcTest_Space_free(&mTest));
		FCUISAFECALLF(mError, FcUI_free(&mTest.mUI));

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

FcError_t FcTest_Space_free(FcTest_Space_t* pSpace){
    FcError_t mError = FCERROR_NOERROR;
    FCUISAFECALLF(mError, FcUI_GraphicsQueue_push_funcGL(&pSpace->mUI, FcSpace_freeGL, pSpace));
gError:
    return mError;
}


#endif //_FC_TEST_SPACE_H_