void ShaderManager::LoadShader(ShaderName shaderName, const char* vshFilename, const char *fshFilename, const char *gshFilename)
{
std::string vShaderSrc = ReadShaderFromFile(vshFilename);
std::string fShaderSrc = ReadShaderFromFile(fshFilename);
CompileShader(&m_shaderProgram[shaderName].vertShader, GL_VERTEX_SHADER, vShaderSrc.c_str());
if (strlen(gshFilename) > 0)
{
std::string gShaderSrc = ReadShaderFromFile(gshFilename);
CompileShader(&m_shaderProgram[shaderName].geomShader, GL_GEOMETRY_SHADER, gShaderSrc.c_str());
}
CompileShader(&m_shaderProgram[shaderName].fragShader, GL_FRAGMENT_SHADER, fShaderSrc.c_str());
LinkShader(&m_shaderProgram[shaderName].id,
m_shaderProgram[shaderName].vertShader,
m_shaderProgram[shaderName].fragShader,
m_shaderProgram[shaderName].geomShader);
glUniform1i(glGetUniformLocation(m_shaderProgram[shaderName].id, "sTexture"), 0); // Texture unit 0 is the primary texture.
// Store the location of uniforms for later use
for (int j = 0; j < NUM_UNIFORMS; ++j)
{
m_shaderProgram[shaderName].uniforms[j] = glGetUniformLocation(m_shaderProgram[shaderName].id, uniformNames[j]);
}
}
GLuint Shader::Compile(const std::string& fsshader, const std::string& vsshader) {
errorLinesVS.clear();
GLuint vsh = CompileShader(GLSL_VS, vsshader.c_str(), &errorLinesVS);
if (vsh == 0) {
std::cerr << "Vertex Shader Error." << std::endl;
return 0;
}
errorLinesFS.clear();
GLuint fsh = CompileShader(GLSL_FS, fsshader.c_str(), &errorLinesFS);
if (fsh == 0) {
std::cerr << "Fragment Shader Error." << std::endl;
glDeleteShader(vsh);
return 0;
}
GLuint program = LinkShader(vsh, fsh);
if (program != 0) {
OK = true;
if (shaderProgram != 0)
glDeleteProgram(shaderProgram);
shaderProgram = program;
glDeleteShader(vsh);
glDeleteShader(fsh);
} else
return 0;
// 新しくシェーダープログラムセットされたらここにくる
return shaderProgram;
}
bool RendererBase::Compile(const std::vector <char> &vtxShaderSource,const std::vector <char> &fragShaderSource)
{
bool res=true;
vertexShaderIdent=glCreateShader(GL_VERTEX_SHADER);
fragmentShaderIdent=glCreateShader(GL_FRAGMENT_SHADER);
programIdent=glCreateProgram();
const char *vtxShaderSourcePtr=vtxShaderSource.data();
const char *fragShaderSourcePtr=fragShaderSource.data();
glShaderSource(vertexShaderIdent,1,&vtxShaderSourcePtr,NULL);
glShaderSource(fragmentShaderIdent,1,&fragShaderSourcePtr,NULL);
if(true!=CompileShader(vertexShaderIdent))
{
res=false;
}
if(true!=CompileShader(fragmentShaderIdent))
{
res=false;
}
if(true!=LinkShader())
{
res=false;
}
CacheAttributeAndUniformIdent();
return res;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Loads, compiles, and links the shader for the given file and returns the programs id
GLuint LoadShader( const char* ShaderFileName )
{
GLuint ProgramHandle;
// Open files
char* pData = NULL;
unsigned int Size = 0;
ReadFile( ShaderFileName, &pData, &Size );
// Load and compile the vertex shader
GLuint VertexShader = CompileShader( GL_VERTEX_SHADER, pData, Size );
if( VertexShader == 0 )
{
// Couldn't load the shader for the give file
assert( 0 );
return 0;
}
// Load and compiler the fragment shader
GLuint FragmentShader = CompileShader( GL_FRAGMENT_SHADER, pData, Size );
if( FragmentShader == 0 )
{
glDeleteShader( VertexShader );
// Couldn't load the shader for the give file
assert( 0 );
return 0;
}
// Create the program handle
ProgramHandle = LinkShader( VertexShader, FragmentShader );
if( ProgramHandle == 0 )
{
// Failed to link the program
assert( 0 );
return 0;
}
// Free the shader resources
glDeleteShader( VertexShader );
glDeleteShader( FragmentShader );
return ProgramHandle;
}
//----------------------------------------------
Shader::ShaderPtr Shader::Create(const char* vs, const char* fs)
{
ShaderPtr shader(new Shader());
std::vector<GLuint> stages;
stages.push_back(CompileShader(vs, GL_VERTEX_SHADER));
stages.push_back(CompileShader(fs, GL_FRAGMENT_SHADER));
if (LinkShader(shader->impl->obj, stages))
{
shader->Activate();
GetUniforms(shader->impl->obj, shader->impl->paramList);
shader->Deactivate();
}
else
{
shader.reset();
shader = NULL;
}
std::for_each(stages.begin(), stages.end(), glDeleteShader);
return shader;
}
BOOL XShader::LoadShaderFromStr( const GLchar *cVertShader
, const GLchar *cFragShader
, const char *cszTag )
{
GLuint vertShader, fragShader;
BOOL bRet = FALSE;
do {
// Create shader program.
m_glProgram = glCreateProgram();
// Create and compile vertex shader.
if( !CompileShaderFromString( &vertShader, GL_VERTEX_SHADER, cVertShader, cszTag ) ) {
XBREAKF( 1, "Failed to compile vertex shader" );
bRet = FALSE;
break;
}
// Create and compile fragment shader.
if( !CompileShaderFromString( &fragShader, GL_FRAGMENT_SHADER, cFragShader, cszTag ) ) {
XBREAKF( 1, "Failed to compile fragment shader" );
bRet = FALSE;
break;
}
// Attach vertex shader to program.
glAttachShader( m_glProgram, vertShader );
// Attach fragment shader to program.
glAttachShader( m_glProgram, fragShader );
// Bind attribute locations.
// This needs to be done prior to linking.
glBindAttribLocation( m_glProgram, XE::ATTRIB_POS, "position" );
glBindAttribLocation( m_glProgram, XE::ATTRIB_TEXTURE, "texture" );
glBindAttribLocation( m_glProgram, XE::ATTRIB_COLOR, "color" );
glBindAttribLocation( m_glProgram, XE::ATTRIB_SIZE, "size" );
// Link program.
if( !LinkShader( m_glProgram, cszTag ) ) {
XTRACE( "Failed to link program: %d %s", m_glProgram, C2SZ(cszTag) );
if( vertShader ) {
glDeleteShader( vertShader );
vertShader = 0;
}
if( fragShader ) {
glDeleteShader( fragShader );
fragShader = 0;
}
if( m_glProgram ) {
glDeleteProgram( m_glProgram );
m_glProgram = 0;
}
bRet = FALSE;
break;
}
// Get uniform locations.
// 세이더내 유저변수의 로케이션값을 받아둔다. 이 변수에다 값을 쓰려면 이 로케이션 값을 이용해야 한다.
m_locUniforms[UNIFORM_MVP_MATRIX] = glGetUniformLocation( m_glProgram, "mMVP" );
m_locUniforms[UNIFORM_COLOR] = glGetUniformLocation( m_glProgram, "col" );
m_locUniforms[UNIFORM_FLOAT] = glGetUniformLocation( m_glProgram, "value" );
// m_locUniforms[UNIFORM_MODEL_MATRIX] = glGetUniformLocation(m_glProgram, "worldMatrix");
// Release vertex and fragment shaders.
if( vertShader ) {
glDetachShader( m_glProgram, vertShader );
glDeleteShader( vertShader );
}
if( fragShader ) {
glDetachShader( m_glProgram, fragShader );
glDeleteShader( fragShader );
}
bRet = TRUE;
} while( 0 );
// if( bRet )
// BTRACE("success.");
// else
// XTRACE("failed.");
return bRet;
}
