ShaderProgram::ShaderProgram(const std::string& vs_path, const std::string& gs_path, const std::string& ps_path) : m_refCounter(0)
{
std::string vertSource;
std::string geomSource;
std::string fragSource;
LoadTextFromFile(vs_path, vertSource);
LoadTextFromFile(gs_path, geomSource);
LoadTextFromFile(ps_path, fragSource);
const char* tmpVertSource = vertSource.c_str();
const char* tmpGeomSource = geomSource.c_str();
const char* tmpFragSource = fragSource.c_str();
if(!Compile(&tmpVertSource, NULL, NULL, &tmpGeomSource, &tmpFragSource))
{
std::cerr << "vs path: " << vs_path << std::endl;
std::cerr << "gs path: " << gs_path << std::endl;
std::cerr << "ps path: " << ps_path << std::endl;
throw std::runtime_error("shader compilation failed!");
}
if(!Link())
throw std::runtime_error("shader linkage failed!");
m_refCounter++;
}
bool
Shader::loadAndCompile(
const char* acVertexFilename,
const char* acFragmentFilename)
{
char *acResource = 0;
uint uiLength = 0;
char *acVertexPgmSrc = 0;
size_t uiVertexPgmLength = 0;
char *acFragmentPgmSrc = 0;
size_t uiFragmentPgmLength = 0;
FindResourcePath(acVertexFilename, &acResource, &uiLength);
LoadTextFromFile(acResource, &acVertexPgmSrc, &uiVertexPgmLength);
if(acResource)
free(acResource);
FindResourcePath(acFragmentFilename, &acResource, &uiLength);
LoadTextFromFile(acResource, &acFragmentPgmSrc, &uiFragmentPgmLength);
if(acResource)
free(acResource);
bool bSuccess = compile(acVertexPgmSrc, acFragmentPgmSrc);
if(acVertexPgmSrc)
free(acVertexPgmSrc);
if(acFragmentPgmSrc)
free(acFragmentPgmSrc);
return bSuccess;
}
/**
* Load GUI slope selection sprites.
* @param rcd_file RCD file being loaded.
* @param sprites Sprites loaded from this file.
* @param texts Texts loaded from this file.
* @return Load was successful.
*/
bool GuiSprites::LoadGSLP(RcdFileReader *rcd_file, const ImageMap &sprites, const TextMap &texts)
{
const uint8 indices[] = {TSL_STRAIGHT_DOWN, TSL_STEEP_DOWN, TSL_DOWN, TSL_FLAT, TSL_UP, TSL_STEEP_UP, TSL_STRAIGHT_UP};
/* 'indices' entries of slope sprites, bends, banking, 4 triangle arrows,
* 4 entries with rotation sprites, 2 button sprites, one entry with a text block.
*/
if (rcd_file->version != 7 || rcd_file->size != (lengthof(indices) + TBN_COUNT + TPB_COUNT + 4 + 2 + 2 + 1 + TC_END + 1 + WES_COUNT + 4 + 2) * 4 + 4) return false;
for (uint i = 0; i < lengthof(indices); i++) {
if (!LoadSpriteFromFile(rcd_file, sprites, &this->slope_select[indices[i]])) return false;
}
for (uint i = 0; i < TBN_COUNT; i++) {
if (!LoadSpriteFromFile(rcd_file, sprites, &this->bend_select[i])) return false;
}
for (uint i = 0; i < TPB_COUNT; i++) {
if (!LoadSpriteFromFile(rcd_file, sprites, &this->bank_select[i])) return false;
}
if (!LoadSpriteFromFile(rcd_file, sprites, &this->triangle_left)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->triangle_right)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->triangle_up)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->triangle_down)) return false;
for (uint i = 0; i < 2; i++) {
if (!LoadSpriteFromFile(rcd_file, sprites, &this->platform_select[i])) return false;
}
for (uint i = 0; i < 2; i++) {
if (!LoadSpriteFromFile(rcd_file, sprites, &this->power_select[i])) return false;
}
if (!LoadSpriteFromFile(rcd_file, sprites, &this->disabled)) return false;
for (uint i = 0; i < TC_END; i++) {
if (!LoadSpriteFromFile(rcd_file, sprites, &this->compass[i])) return false;
}
if (!LoadSpriteFromFile(rcd_file, sprites, &this->bulldozer)) return false;
for (uint i = 0; i < WES_COUNT; i++) {
if (!LoadSpriteFromFile(rcd_file, sprites, &this->weather[i])) return false;
}
if (!LoadSpriteFromFile(rcd_file, sprites, &this->rot_2d_pos)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->rot_2d_neg)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->rot_3d_pos)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->rot_3d_neg)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->close_sprite)) return false;
if (!LoadSpriteFromFile(rcd_file, sprites, &this->dot_sprite)) return false;
if (!LoadTextFromFile(rcd_file, texts, &this->text)) return false;
_language.RegisterStrings(*this->text, _gui_strings_table, STR_GUI_START);
return true;
}
bool my_glObject::LoadShaders(std::string vs,std::string fs)
{
bool fail=0;
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
std::string vShaderCode;
std::string fShaderCode;
vShaderCode = LoadTextFromFile(vs);
//can check for error later
fShaderCode = LoadTextFromFile(fs);
//can check for error later
GLint Result = GL_FALSE;
int InfoLogLength;
//compiling vs
const char *VertexSourcePointer = vShaderCode.c_str();
glShaderSource(VertexShaderID,1,&VertexSourcePointer,NULL);
glCompileShader(VertexShaderID);
// Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> VertexShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
printf("%s\n", &VertexShaderErrorMessage[0]);
}
char const * FragmentSourcePointer = fShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
glCompileShader(FragmentShaderID);
// Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> FragmentShaderErrorMessage(InfoLogLength+1);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
printf("%s\n", &FragmentShaderErrorMessage[0]);
}
programID = glCreateProgram();
glAttachShader(programID, VertexShaderID);
glAttachShader(programID, FragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &Result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ){
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
glGetProgramInfoLog(programID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
printf("%s\n", &ProgramErrorMessage[0]);
}
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
return fail;
}
static int
SetupComputeKernels(void)
{
int err = 0;
char *source = 0;
size_t length = 0;
printf(SEPARATOR);
printf("Loading kernel source from file '%s'...\n", COMPUTE_KERNEL_FILENAME);
err = LoadTextFromFile(COMPUTE_KERNEL_FILENAME, &source, &length);
if (err)
return -8;
// Create the compute program from the source buffer
//
ComputeProgram = clCreateProgramWithSource(ComputeContext, 1, (const char **) & source, NULL, &err);
if (!ComputeProgram || err != CL_SUCCESS)
{
printf("Error: Failed to create compute program! %d\n", err);
return EXIT_FAILURE;
}
// Build the program executable
//
printf(SEPARATOR);
printf("Building compute program...\n");
err = clBuildProgram(ComputeProgram, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS)
{
size_t len;
char buffer[2048];
printf("Error: Failed to build program executable!\n");
clGetProgramBuildInfo(ComputeProgram, ComputeDeviceId, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
return EXIT_FAILURE;
}
// Create the compute kernel from within the program
//
int i = 0;
for(i = 0; i < COMPUTE_KERNEL_COUNT; i++)
{
printf("Creating kernel '%s'...\n", ComputeKernelMethods[i]);
ComputeKernels[i] = clCreateKernel(ComputeProgram, ComputeKernelMethods[i], &err);
if (!ComputeKernels[i] || err != CL_SUCCESS)
{
printf("Error: Failed to create compute kernel!\n");
return EXIT_FAILURE;
}
// Get the maximum work group size for executing the kernel on the device
//
size_t max = 1;
err = clGetKernelWorkGroupInfo(ComputeKernels[i], ComputeDeviceId, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &max, NULL);
if (err != CL_SUCCESS)
{
printf("Error: Failed to retrieve kernel work group info! %d\n", err);
return EXIT_FAILURE;
}
ComputeKernelWorkGroupSizes[i] = (max > 1) ? FloorPow2(max) : max; // use nearest power of two (less than max)
printf("%s MaxWorkGroupSize: %d\n", ComputeKernelMethods[i], (int)ComputeKernelWorkGroupSizes[i]);
}
return CreateComputeResult();
}
static int
SetupComputeKernel(void)
{
int err = 0;
char *source = 0;
size_t length = 0;
if(ComputeKernel)
clReleaseKernel(ComputeKernel);
ComputeKernel = 0;
if(ComputeProgram)
clReleaseProgram(ComputeProgram);
ComputeProgram = 0;
printf(SEPARATOR);
printf("Loading kernel source from file '%s'...\n", COMPUTE_KERNEL_FILENAME);
err = LoadTextFromFile(COMPUTE_KERNEL_FILENAME, &source, &length);
if (!source || err)
{
printf("Error: Failed to load kernel source!\n");
return EXIT_FAILURE;
}
#if (DEBUG_INFO)
printf("%s", source);
#endif
// Create the compute program from the source buffer
//
ComputeProgram = clCreateProgramWithSource(ComputeContext, 1, (const char **) & source, NULL, &err);
if (!ComputeProgram || err != CL_SUCCESS)
{
printf("Error: Failed to create compute program!\n");
return EXIT_FAILURE;
}
free(source);
// Build the program executable
//
// err = clBuildProgram(ComputeProgram, 0, NULL, "-x clc++", NULL, NULL);
err = clBuildProgram(ComputeProgram, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS)
{
size_t len;
char buffer[2048];
printf("Error: Failed to build program executable!\n");
clGetProgramBuildInfo(ComputeProgram, ComputeDeviceId, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
return EXIT_FAILURE;
}
// Create the compute kernel from within the program
//
printf("Creating kernel '%s'...\n", COMPUTE_KERNEL_MATMUL_NAME);
ComputeKernel = clCreateKernel(ComputeProgram, COMPUTE_KERNEL_MATMUL_NAME, &err);
if (!ComputeKernel || err != CL_SUCCESS)
{
printf("Error: Failed to create compute kernel!\n");
return EXIT_FAILURE;
}
// Get the maximum work group size for executing the kernel on the device
//
err = clGetKernelWorkGroupInfo(ComputeKernel, ComputeDeviceId, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &MaxWorkGroupSize, NULL);
if (err != CL_SUCCESS)
{
printf("Error: Failed to retrieve kernel work group info! %d\n", err);
exit(1);
}
#if (DEBUG_INFO)
printf("MaxWorkGroupSize: %d\n", MaxWorkGroupSize);
printf("WorkGroupItems: %d\n", WorkGroupItems);
#endif
WorkGroupSize[0] = (MaxWorkGroupSize > 1) ? (MaxWorkGroupSize / WorkGroupItems) : MaxWorkGroupSize;
// WorkGroupSize[1] = MaxWorkGroupSize / WorkGroupSize[0];
printf(SEPARATOR);
// Setup several arguments that won't change
// DataBodyCount
err = clSetKernelArg(
ComputeKernel,
2,
sizeof(int),
(void *)&DataBodyCount);
if (err != CL_SUCCESS)
{
printf("Error: Failed to set kernel arg 2: DataBodyCount! %d\n", err);
exit(1);
}
// time step
err = clSetKernelArg(
ComputeKernel,
3,
sizeof(float),
(void *)&delT);
if (err != CL_SUCCESS)
{
printf("Error: Failed to set kernel arg 3: delT! %d\n", err);
exit(1);
}
// upward Pseudoprobability
err = clSetKernelArg(
ComputeKernel,
4,
sizeof(float),
(void *)&espSqr);
if (err != CL_SUCCESS)
{
printf("Error: Failed to set kernel arg 4: espSqr! %d\n", err);
exit(1);
}
return CL_SUCCESS;
}
static int
SetupComputeKernel(void)
{
int err = 0;
char *source = 0;
size_t length = 0;
if(ComputeKernel)
clReleaseKernel(ComputeKernel);
ComputeKernel = 0;
if(ComputeProgram)
clReleaseProgram(ComputeProgram);
ComputeProgram = 0;
printf(SEPARATOR);
printf("Loading kernel source from file '%s'...\n", COMPUTE_KERNEL_FILENAME);
err = LoadTextFromFile(COMPUTE_KERNEL_FILENAME, &source, &length);
if (!source || err)
{
printf("Error: Failed to load kernel source!\n");
return EXIT_FAILURE;
}
#if (DEBUG_INFO)
printf("%s", source);
#endif
// Create the compute program from the source buffer
//
ComputeProgram = clCreateProgramWithSource(ComputeContext, 1, (const char **) & source, NULL, &err);
if (!ComputeProgram || err != CL_SUCCESS)
{
printf("Error: Failed to create compute program!\n");
return EXIT_FAILURE;
}
free(source);
// Build the program executable
//
err = clBuildProgram(ComputeProgram, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS)
{
size_t len;
char buffer[2048];
printf("Error: Failed to build program executable!\n");
clGetProgramBuildInfo(ComputeProgram, ComputeDeviceId, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
return EXIT_FAILURE;
}
// Create the compute kernel from within the program
//
printf("Creating kernel '%s'...\n", COMPUTE_KERNEL_MATMUL_NAME);
ComputeKernel = clCreateKernel(ComputeProgram, COMPUTE_KERNEL_MATMUL_NAME, &err);
if (!ComputeKernel || err != CL_SUCCESS)
{
printf("Error: Failed to create compute kernel!\n");
return EXIT_FAILURE;
}
return CL_SUCCESS;
}
