uint COpenGLShader::Create(const char *filename, ShaderType type)
{
m_hShader = GLDebug(glCreateShader(GetGLShaderType(type)));
m_shaderType = type;
struct stat tagStat;
int ret = stat(filename, &tagStat);
if (ret == 0)
{
std::ifstream stream;
stream.open(filename, std::ios::in | std::ios::binary);
if (!stream.fail())
{
uint size = tagStat.st_size + 1;
byte *data = new byte[size];
stream.read((char *)data, size);
data[size - 1] = 0;
const GLchar *glData = (const GLchar *)data;
GLint length = (GLint)size;
GLDebug(glShaderSource(m_hShader, 1, &glData, &length));
strncpy(m_fileName, filename, MAX_FILE_NAME - 1);
delete[]data;
}
}
return m_hShader;
}
uint COpenGLShader::CreateBySource(const char *shaderSource, ShaderType type)
{
m_hShader = GLDebug(glCreateShader(GetGLShaderType(type)));
GLchar *fsStringPtr[1];
fsStringPtr[0] = (GLchar *)shaderSource;
glShaderSource(m_hShader, 1, (const GLchar **)fsStringPtr, NULL);
return m_hShader;
}
void ShaderObject::loadFromString(const std::string& source, ShaderType type)
{
myType = type;
myShaderID = glCreateShader(GetGLShaderType(type));
const char* sourcePointer = source.c_str();
glShaderSource(myShaderID, 1, &sourcePointer, NULL);
glCompileShader(myShaderID);
GLint status = GL_FALSE;
glGetShaderiv(myShaderID, GL_COMPILE_STATUS, &status);
if (status == GL_FALSE)
{
GLint infoLogLength;
glGetShaderiv(myShaderID, GL_INFO_LOG_LENGTH, &infoLogLength);
GLchar *strInfoLog = new GLchar[infoLogLength + 1];
glGetShaderInfoLog(myShaderID, infoLogLength, NULL, strInfoLog);
throw ShaderException(myType, strInfoLog);
delete[] strInfoLog;
}
}
bool GLES2Shader::LoadShaderFromString(
ShaderContextPtr context,
const str_type::string& shaderName,
const std::string& codeAsciiString,
const Shader::SHADER_FOCUS focus,
const Shader::SHADER_PROFILE profile,
const char *entry)
{
if (m_shader != 0)
return false;
// pVideo->Message(codeAsciiString, GSMT_INFO);
const GLuint shader = glCreateShader(GetGLShaderType(focus));
if (shader)
{
if (m_shaderName == "")
m_shaderName = shaderName;
m_shaderFocus = focus;
m_logger = boost::shared_ptr<Platform::FileLogger>(
new Platform::FileLogger(Platform::FileLogger::GetLogDirectory() + Platform::GetFileName(shaderName) + ".log.txt"));
m_shader = shader;
const char *pSource = codeAsciiString.c_str();
glShaderSource(shader, 1, &pSource, NULL);
glCompileShader(shader);
GLint compiled = 0;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
m_context->Log(str_type::string("couldn't compile ") + Platform::GetFileName(shaderName), Platform::FileLogger::ERROR);
GLint infoLen = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen)
{
char* buf = new char [infoLen];
if (buf)
{
glGetShaderInfoLog(shader, infoLen, NULL, buf);
std::stringstream ss;
ss << "Error: could not compile shader " << shaderName << " ("
<< buf << ")";
m_logger->Log(ss.str(), Platform::FileLogger::ERROR);
m_context->Log(ss.str(), Platform::FileLogger::ERROR);
delete [] buf;
}
glDeleteShader(shader);
m_shader = 0;
return false;
}
}
else
{
m_context->Log(shaderName + " successfully created", Platform::FileLogger::INFO);
// TODO glReleaseShaderCompiler() ?
}
}
else
{
std::stringstream ss;
ss << "Error: could not create shader " << shaderName;
m_logger->Log(ss.str(), Platform::FileLogger::ERROR);
}
return true;
}
