FcLibs/FcWindow/src/FcGL/FcGL_Program/FcGL_Program.h - master - vTech/FcApps

FcLibs/FcWindow/src/FcGL/FcGL_Program/FcGL_Program.h
211 строк8 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#ifndef __FCGL_PROGRAM_H__
#define __FCGL_PROGRAM_H__

#include "../FcPlatform/FcPlatform_GL.h"
#include "../FcError/include/FcError.h"

typedef struct FcGL_Program_t {
	GLuint mID;
}FcGL_Program_t;

FCDEF FcWindow_Error_t FcGL_Program(const FcPlatform_GL_t* pPlatform,
	const GLchar* pVertex,
	const GLchar* pTessControl,
	const GLchar* pTessEval,
	const GLchar* pFragment,
	const GLchar* pCompute,
	FcGL_Program_t* pProgram);
FCDEF GLint FcGL_Program_getUniformLocation(const FcPlatform_GL_t* pPlatform, FcGL_Program_t* pProgram, const GLchar* pName);
FCDEF GLint FcGL_Program_getAttribLocation(const FcPlatform_GL_t* pPlatform, FcGL_Program_t* pProgram, const GLchar* pName);
FCDEF void FcGL_Program_use(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram);
FCDEF void FcGL_Program_free(const FcPlatform_GL_t* pPlatform, FcGL_Program_t* pProgram);
FCDEF void FcGL_Program_Uniform_bind_f2(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, GLint mID, GLfloat f0, GLfloat f1);
FCDEF GLuint FcGL_Program_getProgram_ID(FcGL_Program_t* pProgram);

FCDEF GLuint FcGL_Program_getProgram_ID(FcGL_Program_t* pProgram) {
	if (!pProgram)
		return 0;
	else
		return pProgram->mID;
}

FCDEF FcWindow_Error_t FcGL_Program_checkErrorShader(const FcPlatform_GL_t* pPlatform_GL, GLuint shader, const char* text, GLuint status) {
	FcWindow_Error_t mError;
	GLint infoLength;
	GLint messageLength;
	mError = FCWINDOW_ERROR_NOERROR;
	glGetShaderiv(shader, status, &infoLength);
	if (infoLength == GL_FALSE) {
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLength);
		GLchar* infoLog = (GLchar*)malloc(infoLength * sizeof(GLchar));
		glGetShaderInfoLog(shader, infoLength, &messageLength, infoLog);
		fprintf(stderr, "%s - %s\n", text, infoLog);
		printf("%s - %s\n", text, infoLog);
		free(infoLog);
		mError = FCWINDOW_ERROR_GL_COMPILE_STATUS;
	}
	return mError;
}

FCDEF FcWindow_Error_t FcGL_Program_InfoLog(const FcPlatform_GL_t* pPlatform_GL, GLuint shader) {
	FcWindow_Error_t mError;
	GLint infoLength;
	GLint lengthWriteInfo;
	mError = FCWINDOW_ERROR_NOERROR;
	glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &infoLength);
	if (infoLength > 0) {
		GLchar* log = (GLchar*)malloc(infoLength * sizeof(GLchar));
		glGetProgramInfoLog(shader, infoLength, &lengthWriteInfo, log);
		fprintf(stderr, "Information - %s	\n", log);
		printf("Information - %s	\n", log);
		free(log);
		//mError = FCWINDOW_ERROR_GL_LINK_STATUS;
	}
	return mError;
}

FCDEF void FcGL_Program_ValidateLog(const FcPlatform_GL_t* pPlatform_GL, GLuint shader) {
	GLint infoLength;
	glValidateProgram(shader);
	glGetProgramiv(shader, GL_VALIDATE_STATUS, &infoLength);
	if (infoLength == GL_FALSE) {
		infoLength = 1;
		GLint messageLength = 0;
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLength);
		GLchar* infoLog = (GLchar*)malloc(infoLength * sizeof(GLchar));
		glGetShaderInfoLog(shader, infoLength, &messageLength, infoLog);
		fprintf(stderr, "%s\n", infoLog);
		free(infoLog);
	}
}

FCDEF FcWindow_Error_t FcGL_Program(const FcPlatform_GL_t* pPlatform_GL,
	const GLchar* pVertex,
	const GLchar* pTessControl,
	const GLchar* pTessEval,
	const GLchar* pFragment,
	const GLchar* pCompute,
	FcGL_Program_t* pProgram) {
	FcWindow_Error_t mError;
	GLuint mVertexShaders, mFragmentShaders, mTessControlShaders, mTessEvalShaders, mComputeShaders;
	mVertexShaders = mFragmentShaders = mTessControlShaders = mTessEvalShaders = mComputeShaders = 0;
	memset(pProgram, 0, sizeof(FcGL_Program_t));
	if (pVertex) {
		mVertexShaders = glCreateShader(GL_VERTEX_SHADER);
		if (mVertexShaders == GL_NONE) {
			mError = FCWINDOW_ERROR_GL_CREATE_VERTEX_SHADER;
			goto gError;
		}
		glShaderSource(mVertexShaders, 1, &pVertex, NULL);
		glCompileShader(mVertexShaders);
		mError = FcGL_Program_checkErrorShader(pPlatform_GL, mVertexShaders, "GL_VERTEX_SHADER", GL_COMPILE_STATUS);
		if (mError) goto gError;
	}
#ifdef GL_TESS_CONTROL_SHADER
	if (pTessControl) {
		mTessControlShaders = glCreateShader(GL_TESS_CONTROL_SHADER);
		if (mTessControlShaders == GL_NONE) {
			mError = FCWINDOW_ERROR_GL_CREATE_TESS_CONTROL_SHADER;
			goto gError;
		}
		glShaderSource(mTessControlShaders, 1, &pTessControl, NULL);
		glCompileShader(mTessControlShaders);
		mError = FcGL_Program_checkErrorShader(pPlatform_GL, mTessControlShaders, "GL_TESS_SHADER", GL_COMPILE_STATUS);
		if (mError) goto gError;
	}
#endif
	if (pTessEval) {
		mTessEvalShaders = glCreateShader(GL_VERTEX_SHADER);
		if (mTessEvalShaders == GL_NONE) {
			mError = FCWINDOW_ERROR_GL_CREATE_VERTEX_SHADER;
			goto gError;
		}
		glShaderSource(mTessEvalShaders, 1, &pVertex, NULL);
		glCompileShader(mTessEvalShaders);
		mError = FcGL_Program_checkErrorShader(pPlatform_GL, mTessEvalShaders, "GL_TESS_SHADER", GL_COMPILE_STATUS);
		if (mError) goto gError;
	}
	if (pFragment) {
		mFragmentShaders = glCreateShader(GL_FRAGMENT_SHADER);
		if (mFragmentShaders == GL_NONE) {
			mError = FCWINDOW_ERROR_GL_CREATE_FRAGMENT_SHADER;
			goto gError;
		}
		glShaderSource(mFragmentShaders, 1, &pFragment, NULL);
		glCompileShader(mFragmentShaders);
		mError = FcGL_Program_checkErrorShader(pPlatform_GL, mFragmentShaders, "GL_FRAGMENT_SHADER", GL_COMPILE_STATUS);
		if (mError) goto gError;
	}
#ifdef GL_COMPUTE_SHADER
	if (pCompute) {
		mComputeShaders = glCreateShader(GL_COMPUTE_SHADER);
		if (mComputeShaders == GL_NONE) {
			mError = FCWINDOW_ERROR_GL_CREATE_COMPUTE_SHADER;
			goto gError;
		}
		glShaderSource(mComputeShaders, 1, &pCompute, NULL);
		glCompileShader(mComputeShaders);
		mError = FcGL_Program_checkErrorShader(pPlatform_GL, mComputeShaders, "GL_COMPUTE_SHADER", GL_COMPILE_STATUS);
		if (mError) goto gError;
	}
#endif
	pProgram->mID = glCreateProgram();
	if (mFragmentShaders) glAttachShader(pProgram->mID, mFragmentShaders);
	if (mVertexShaders) glAttachShader(pProgram->mID, mVertexShaders);
	if (mTessControlShaders) glAttachShader(pProgram->mID, mTessControlShaders);
	if (mTessEvalShaders) glAttachShader(pProgram->mID, mTessEvalShaders);
	if (mComputeShaders) glAttachShader(pProgram->mID, mComputeShaders);
	glLinkProgram(pProgram->mID);
	mError = FcGL_Program_InfoLog(pPlatform_GL, pProgram->mID);
	if (mError) goto gError;
	FcGL_Program_ValidateLog(pPlatform_GL, pProgram->mID);

gError:

	if (mVertexShaders && pProgram->mID) glDetachShader(pProgram->mID, mVertexShaders);
	if (mFragmentShaders && pProgram->mID) glDetachShader(pProgram->mID, mFragmentShaders);
	if (mComputeShaders && pProgram->mID) glDetachShader(pProgram->mID, mComputeShaders);

	if (mFragmentShaders) glDeleteShader(mFragmentShaders);
	if (mVertexShaders) glDeleteShader(mVertexShaders);
	if (mComputeShaders) glDeleteShader(mComputeShaders);
	return mError;
}

FCDEF void FcGL_Program_use(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram) {
	glUseProgram(pProgram->mID);
}

FCDEF void FcGL_Program_free(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram) {
	glDeleteProgram(pProgram->mID);
	memset(pProgram, 0, sizeof(FcGL_Program_t));
}

FCDEF GLint FcGL_Program_getUniformLocation(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, const GLchar* pName) {
	return glGetUniformLocation(pProgram->mID, pName);
}

FCDEF GLint FcGL_Program_getAttribLocation(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, const GLchar* pName) {
	return glGetAttribLocation(pProgram->mID, pName);
}

FCDEF void FcGL_Program_Uniform_bind_f1(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, GLint mID, GLfloat f0) {
	glUniform1f(mID, f0);
}
FCDEF void FcGL_Program_Uniform_bind_f2(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, GLint mID, GLfloat f0, GLfloat f1) {
	glUniform2f(mID, f0, f1);
}
FCDEF void FcGL_Program_Uniform_bind_f3(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, GLint mID, GLfloat f0, GLfloat f1, GLfloat f2) {
	glUniform3f(mID, f0, f1, f2);
}
FCDEF void FcGL_Program_Uniform_bind_f4(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, GLint mID, GLfloat f0, GLfloat f1, GLfloat f2, GLfloat f3) {
	glUniform4f(mID, f0, f1, f2, f3);
}
FCDEF void FcGL_Program_Uniform_bind_m3(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, GLint mID, GLfloat(*pMatrix)[9]) {
	glUniformMatrix3fv(mID, 1, GL_FALSE, *pMatrix);
}
FCDEF void FcGL_Program_Uniform_bind_m4(const FcPlatform_GL_t* pPlatform_GL, FcGL_Program_t* pProgram, GLint mID, GLfloat(*pMatrix)[16]) {
	glUniformMatrix4fv(mID, 1, GL_FALSE, *pMatrix);
}

#endif //__FCGL_PROGRAM_H__