RendererHUDClassic::RendererHUDClassic( Instance* instance, Font* font )
: RendererHUD( instance, font )
, mSmoothRPY( Vector3f() )
, mShader{ 0 }
, mColorShader{ 0 }
{
LoadVertexShader( &mShader, hud_vertices_shader, sizeof(hud_vertices_shader) + 1 );
LoadFragmentShader( &mShader, hud_fragment_shader, sizeof(hud_fragment_shader) + 1 );
createPipeline( &mShader );
glUseProgram( mShader.mShader );
glEnableVertexAttribArray( mShader.mVertexTexcoordID );
glEnableVertexAttribArray( mShader.mVertexPositionID );
glUseProgram( 0 );
LoadVertexShader( &mColorShader, hud_color_vertices_shader, sizeof(hud_color_vertices_shader) + 1 );
LoadFragmentShader( &mColorShader, hud_color_fragment_shader, sizeof(hud_color_fragment_shader) + 1 );
createPipeline( &mColorShader );
glUseProgram( mColorShader.mShader );
glEnableVertexAttribArray( mColorShader.mVertexTexcoordID );
glEnableVertexAttribArray( mColorShader.mVertexColorID );
glEnableVertexAttribArray( mColorShader.mVertexPositionID );
glUseProgram( 0 );
Compute();
}
int32_t PS3Graphics::InitCg()
{
cgRTCgcInit();
_cgContext = cgCreateContext();
if (_cgContext == NULL)
return 1;
if (strlen(_curFragmentShaderPath.c_str()) > 0)
return LoadFragmentShader(_curFragmentShaderPath.c_str());
else
{
_curFragmentShaderPath = DEFAULT_SHADER_FILE;
return LoadFragmentShader(_curFragmentShaderPath.c_str());
}
}
bool ILine::Load(IDirect3DDevice9 * i_direct3dDevice
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
, std::string* o_errorMessage
#endif
)
{
if (!LoadFragmentShader(s_FragmentShaderPath, i_direct3dDevice,
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
o_errorMessage
#endif
))
{
return false;
}
if (!LoadVertexShader(s_VertexShaderPath, i_direct3dDevice,
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
o_errorMessage
#endif
))
{
return false;
}
return true;
}
ShaderProgram_t *InitProgram (const char *vsName, const char *fsName)
{
char buf[1024];
VertexShader_t *vsh = 0;
FragmentShader_t *fsh = 0;
ShaderProgram_t *prog;
if (vsName != 0) {
// load the vertex shader
if ((vsh = LoadVertexShader (vsName)) == 0)
exit (1);
}
if (fsName != 0) {
// load the vertex shader
if ((fsh = LoadFragmentShader (fsName)) == 0)
exit (1);
}
if ((prog = CreateShaderProgram (vsh, fsh)) == 0)
exit (1);
FreeVertexShader (vsh);
FreeFragmentShader (fsh);
return prog;
}
/*
================================================================================================
idRenderProgManager::FindFragmentShader
================================================================================================
*/
int idRenderProgManager::FindFragmentShader( const char* name )
{
for( int i = 0; i < fragmentShaders.Num(); i++ )
{
if( fragmentShaders[i].name.Icmp( name ) == 0 )
{
LoadFragmentShader( i );
return i;
}
}
fragmentShader_t shader;
shader.name = name;
int index = fragmentShaders.Append( shader );
LoadFragmentShader( index );
currentFragmentShader = index;
return index;
}
void Shader::Compile(const std::string &pVSName, const std::string &pFSName, const std::string &pGSName){
std::string all = String(pVSName)+pFSName+pGSName;
Shader* tmp = ResourceManager::Call().Get<Shader>(all);
if(tmp != 0){
//Shader existe deja, on copie ses identifiants dans celui ci
mProgram = tmp->mProgram;
}else{
//Shader n'existe pas, on le cree
// Ajout du shader au ResourceManager
ResourceManager::Call().Add(all, this);
// Chargement des fichiers shaders
LoadVertexShader(pVSName);
LoadFragmentShader(pFSName);
if(!pGSName.empty())
LoadGeometryShader(pGSName);
// Creation du shader mProgram
mProgram = glCreateProgram();
// Linkage des deux shaders précédemment créés
glAttachShader(mProgram, mVShader);
glAttachShader(mProgram, mFShader);
if(mGShader)
glAttachShader(mProgram, mGShader);
// Linkage du mProgramme a OGL
glLinkProgram(mProgram);
GLint error;
glGetProgramiv(mProgram, GL_LINK_STATUS, &error);
if(!error){
char log[1024];
glGetProgramInfoLog(mProgram, 1024, NULL, log);
if(mVShader)
glDeleteShader(mVShader);
if(mFShader)
glDeleteShader(mFShader);
if(mGShader)
glDeleteShader(mGShader);
throw Exception(String("Shader Link Error :\n")+log);
}
// Destruction des Shaders. ils sont maintenant dans le program
glDeleteShader(mVShader);
glDeleteShader(mFShader);
if(mGShader)
glDeleteShader(mGShader);
// Attribution des texCoords
glUseProgram(mProgram);
glUniform1i(glGetUniformLocation(mProgram, "tex"), 0);
glBindFragDataLocation(mProgram, 0, "finalColor");
glUseProgram(0);
}
}
//////////////////////////////////////////////////////////////////////
// powi¹zanie shadera fragmentów, reprezentowanego przez kod
// Ÿród³owy, z obiektem programu; w razie potrzeby tworzony
// jest nowy obiekt programu
//////////////////////////////////////////////////////////////////////
void AttachFragmentShader( GLuint &program, const char **src )
{
// odczyt kodu shadera i jego kompilacja
GLuint shader = LoadFragmentShader( src );
// w razie potrzeby tworzymy obiekt programu
if( !glIsProgram( program ) )
program = glCreateProgram();
// do³¹czenie obiektu shadera do obiektu programu
glAttachShader( program, shader );
}
bool Sprite::Load(const char* i_TexturePath, const sRectangle &i_texcoords, const sSprite &i_spriteDetails, IDirect3DDevice9* i_direct3dDevice
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
, std::string* o_errorMessage
#endif
)
{
assert(i_TexturePath && s_FragmentShaderPath && s_VertexShaderPath && s_SamplerName && i_direct3dDevice);
//Load the shader from the path
if (!LoadFragmentShader(s_FragmentShaderPath, m_direct3dDevice
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
, o_errorMessage
#endif
))
{
return false;
}
//Load the shader from the path
if (!LoadVertexShader(s_VertexShaderPath, m_direct3dDevice
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
, o_errorMessage
#endif
))
{
return false;
}
if (!LoadTextureAndSamplerRegister(i_TexturePath, s_SamplerName, m_direct3dDevice
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
, o_errorMessage
#endif
))
{
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
#endif
return false;
}
if (!CreateSpriteDrawInfoandFillVertexBuffer(i_spriteDetails, i_texcoords))
{
#ifdef EAE2014_SHOULDALLRETURNVALUESBECHECKED
#endif
return false;
}
return true;
}
int32_t FceuGraphics::InitCg()
{
LOG_DBG("FceuGraphics::InitCg()\n");
cgRTCgcInit();
LOG_DBG("FceuGraphics::InitCg() - About to create CgContext\n");
_cgContext = cgCreateContext();
if (_cgContext == NULL)
{
LOG_DBG("Error Creating Cg Context\n");
return 1;
}
if (strlen(_curFragmentShaderPath.c_str()) > 0)
{
return LoadFragmentShader(_curFragmentShaderPath.c_str());
}
else
{
_curFragmentShaderPath = DEFAULT_SHADER_FILE;
return LoadFragmentShader(_curFragmentShaderPath.c_str());
}
}
Cross2d_update()
{
GLuint programID = LoadFragmentShader( "simple.fs" );
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(programID);
triangle.createConfigure(0);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableVertexAttribArray(0);
}
// powi¹zanie shadera wierzcho³ków i shadera fragmentów,
// reprezentowanego przez kod Ÿród³owy, z obiektem programu;
// w razie potrzeby tworzony jest nowy obiekt programu
//////////////////////////////////////////////////////////////////////
void AttachVertexFragmentShader( GLuint &program, const char **vsSrc, const char **fsSrc )
{
// odczyt kodu shadera wierzcho³ków i jego kompilacja
GLuint vShader = LoadVertexShader( vsSrc );
// odczyt kodu shadera fragmentów i jego kompilacja
GLuint fShader = LoadFragmentShader( fsSrc );
// w razie potrzeby tworzymy obiekt programu
if( !glIsProgram( program ) )
program = glCreateProgram();
// do³¹czenie obiektów shaderów do obiektu programu
glAttachShader( program, vShader );
glAttachShader( program, fShader );
}
//////////////////////////////////////////////////////////////////////
// powi¹zanie shadera wierzcho³ków, shadera geometrii i shadera
// fragmentów, reprezentowanego przez kod Ÿród³owy w plikach, z obiektem
// programu; w razie potrzeby tworzony jest nowy obiekt programu
//////////////////////////////////////////////////////////////////////
void AttachVertexGeometryFragmentShader( GLuint &program, const char *vsName, const char *gsName, const char *fsName )
{
// odczyt kodu shadera wierzcho³ków z pliku i jego kompilacja
GLuint vShader = LoadVertexShader( vsName );
// odczyt kodu shadera geometrii z pliku i jego kompilacja
GLuint gShader = LoadGeometryShader( gsName );
// odczyt kodu shadera fragmentów z pliku i jego kompilacja
GLuint fShader = LoadFragmentShader( fsName );
// w razie potrzeby tworzymy obiekt programu
if( !glIsProgram( program ) )
program = glCreateProgram();
// do³¹czenie obiektów shaderów do obiektu programu
glAttachShader( program, vShader );
glAttachShader( program, gShader );
glAttachShader( program, fShader );
}
/*
================================================================================================
idRenderProgManager::LoadAllShaders()
================================================================================================
*/
void idRenderProgManager::LoadAllShaders()
{
for( int i = 0; i < vertexShaders.Num(); i++ )
{
LoadVertexShader( i );
}
for( int i = 0; i < fragmentShaders.Num(); i++ )
{
LoadFragmentShader( i );
}
for( int i = 0; i < glslPrograms.Num(); ++i )
{
if( glslPrograms[i].vertexShaderIndex == -1 || glslPrograms[i].fragmentShaderIndex == -1 )
{
// RB: skip reloading because we didn't load it initially
continue;
}
LoadGLSLProgram( i, glslPrograms[i].vertexShaderIndex, glslPrograms[i].fragmentShaderIndex );
}
}
void CShader::Create()
{
DEBUG(3, __FUNCTION__, "Compiling");
Compile(LoadVertexShader(), LoadFragmentShader());
}
void
GLSLProgram::Create( char *vfile, char *gfile, char *ffile )
{
CanDoFragmentShader = IsExtensionSupported( "GL_ARB_fragment_shader" );
CanDoGeometryShader = IsExtensionSupported( "GL_EXT_geometry_shader4" );
CanDoVertexShader = IsExtensionSupported( "GL_ARB_vertex_shader" );
InputTopology = GL_TRIANGLES;
OutputTopology = GL_TRIANGLE_STRIP;
Vshader = Gshader = Fshader = 0;
Program = 0;
AttributeLocs.clear();
UniformLocs.clear();
Verbose = false;
this->Program = glCreateProgram();
CheckGlErrors( "glCreateProgram" );
if( vfile != NULL && vfile[0] != '\0' )
{
if( ! CanDoVertexShader )
{
fprintf( stderr, "Warning: this system cannot handle vertex shaders\n" );
}
this->Vshader = LoadVertexShader( vfile );
int status = CompileShader( this->Vshader );
if( status != 0 )
{
if( this->Verbose )
fprintf( stderr, "Shader '%s' compiled.\n", vfile );
AttachShader( this->Vshader );
}
else
{
fprintf( stderr, "Shader '%s' did not compile.\n", vfile );
}
}
if( gfile != NULL && gfile[0] != '\0' )
{
if( ! CanDoGeometryShader )
{
fprintf( stderr, "Warning: this system cannot handle geometry shaders\n" );
}
this->Gshader = LoadGeometryShader( gfile );
int status = CompileShader( this->Gshader );
if( status != 0 )
{
if( this->Verbose )
fprintf( stderr, "Shader '%s' compiled.\n", gfile );
AttachShader( Gshader );
}
else
{
fprintf( stderr, "Shader '%s' did not compile.\n", gfile );
}
}
if( ffile != NULL && ffile[0] != '\0' )
{
if( ! CanDoFragmentShader )
{
fprintf( stderr, "Warning: this system cannot handle fragment shaders\n" );
}
this->Fshader = LoadFragmentShader( ffile );
int status = CompileShader( this->Fshader );
if( status != 0 )
{
if( this->Verbose )
fprintf( stderr, "Shader '%s' compiled.\n", ffile );
AttachShader( Fshader );
}
else
{
fprintf( stderr, "Shader '%s' did not compile.\n", ffile );
}
}
LinkProgram();
};
bool ShaderManager :: LoadFragmentShader ( const char * filename, const char * prefix )
{
return LoadFragmentShader ( &filename, 1, prefix );
}
/*
================================================================================================
idRenderProgManager::Init()
================================================================================================
*/
void idRenderProgManager::Init()
{
common->Printf( "----- Initializing Render Shaders -----\n" );
for( int i = 0; i < MAX_BUILTINS; i++ )
{
builtinShaders[i] = -1;
}
// RB: added checks for GPU skinning
struct builtinShaders_t
{
int index;
const char* name;
const char* nameOutSuffix;
uint32 shaderFeatures;
bool requireGPUSkinningSupport;
} builtins[] =
{
{ BUILTIN_GUI, "gui.vfp", 0, false },
{ BUILTIN_COLOR, "color.vfp", 0, false },
// RB begin
{ BUILTIN_COLOR_SKINNED, "color", "_skinned", BIT( USE_GPU_SKINNING ), true },
{ BUILTIN_VERTEX_COLOR, "vertex_color.vfp", "", 0, false },
// RB end
// { BUILTIN_SIMPLESHADE, "simpleshade.vfp", 0, false },
{ BUILTIN_TEXTURED, "texture.vfp", 0, false },
{ BUILTIN_TEXTURE_VERTEXCOLOR, "texture_color.vfp", 0, false },
{ BUILTIN_TEXTURE_VERTEXCOLOR_SKINNED, "texture_color_skinned.vfp", 0, true },
{ BUILTIN_TEXTURE_TEXGEN_VERTEXCOLOR, "texture_color_texgen.vfp", 0, false },
// RB begin
{ BUILTIN_INTERACTION, "interaction.vfp", "", 0, false },
{ BUILTIN_INTERACTION_SKINNED, "interaction", "_skinned", BIT( USE_GPU_SKINNING ), true },
{ BUILTIN_INTERACTION_AMBIENT, "interactionAmbient.vfp", 0, false },
{ BUILTIN_INTERACTION_AMBIENT_SKINNED, "interactionAmbient_skinned.vfp", 0, true },
{ BUILTIN_INTERACTION_SHADOW_MAPPING_SPOT, "interactionSM", "_spot", 0, false },
{ BUILTIN_INTERACTION_SHADOW_MAPPING_SPOT_SKINNED, "interactionSM", "_spot_skinned", BIT( USE_GPU_SKINNING ), true },
{ BUILTIN_INTERACTION_SHADOW_MAPPING_POINT, "interactionSM", "_point", BIT( LIGHT_POINT ), false },
{ BUILTIN_INTERACTION_SHADOW_MAPPING_POINT_SKINNED, "interactionSM", "_point_skinned", BIT( USE_GPU_SKINNING ) | BIT( LIGHT_POINT ), true },
{ BUILTIN_INTERACTION_SHADOW_MAPPING_PARALLEL, "interactionSM", "_parallel", BIT( LIGHT_PARALLEL ), false },
{ BUILTIN_INTERACTION_SHADOW_MAPPING_PARALLEL_SKINNED, "interactionSM", "_parallel_skinned", BIT( USE_GPU_SKINNING ) | BIT( LIGHT_PARALLEL ), true },
// RB end
{ BUILTIN_ENVIRONMENT, "environment.vfp", 0, false },
{ BUILTIN_ENVIRONMENT_SKINNED, "environment_skinned.vfp", 0, true },
{ BUILTIN_BUMPY_ENVIRONMENT, "bumpyenvironment.vfp", 0, false },
{ BUILTIN_BUMPY_ENVIRONMENT_SKINNED, "bumpyenvironment_skinned.vfp", 0, true },
{ BUILTIN_DEPTH, "depth.vfp", 0, false },
{ BUILTIN_DEPTH_SKINNED, "depth_skinned.vfp", 0, true },
{ BUILTIN_SHADOW, "shadow.vfp", 0, false },
{ BUILTIN_SHADOW_SKINNED, "shadow_skinned.vfp", 0, true },
{ BUILTIN_SHADOW_DEBUG, "shadowDebug.vfp", 0, false },
{ BUILTIN_SHADOW_DEBUG_SKINNED, "shadowDebug_skinned.vfp", 0, true },
{ BUILTIN_BLENDLIGHT, "blendlight.vfp", 0, false },
{ BUILTIN_FOG, "fog.vfp", 0, false },
{ BUILTIN_FOG_SKINNED, "fog_skinned.vfp", 0, true },
{ BUILTIN_SKYBOX, "skybox.vfp", 0, false },
{ BUILTIN_WOBBLESKY, "wobblesky.vfp", 0, false },
{ BUILTIN_POSTPROCESS, "postprocess.vfp", 0, false },
{ BUILTIN_STEREO_DEGHOST, "stereoDeGhost.vfp", 0, false },
{ BUILTIN_STEREO_WARP, "stereoWarp.vfp", 0, false },
// { BUILTIN_ZCULL_RECONSTRUCT, "zcullReconstruct.vfp", 0, false },
{ BUILTIN_BINK, "bink.vfp", 0, false },
{ BUILTIN_BINK_GUI, "bink_gui.vfp", 0, false },
{ BUILTIN_STEREO_INTERLACE, "stereoInterlace.vfp", 0, false },
{ BUILTIN_MOTION_BLUR, "motionBlur.vfp", 0, false },
// RB begin
{ BUILTIN_DEBUG_SHADOWMAP, "debug_shadowmap.vfp", "", 0, false },
// RB end
};
int numBuiltins = sizeof( builtins ) / sizeof( builtins[0] );
vertexShaders.SetNum( numBuiltins );
fragmentShaders.SetNum( numBuiltins );
glslPrograms.SetNum( numBuiltins );
for( int i = 0; i < numBuiltins; i++ )
{
vertexShaders[i].name = builtins[i].name;
vertexShaders[i].nameOutSuffix = builtins[i].nameOutSuffix;
vertexShaders[i].shaderFeatures = builtins[i].shaderFeatures;
vertexShaders[i].builtin = true;
fragmentShaders[i].name = builtins[i].name;
fragmentShaders[i].nameOutSuffix = builtins[i].nameOutSuffix;
fragmentShaders[i].shaderFeatures = builtins[i].shaderFeatures;
fragmentShaders[i].builtin = true;
builtinShaders[builtins[i].index] = i;
if( builtins[i].requireGPUSkinningSupport && !glConfig.gpuSkinningAvailable )
{
// RB: don't try to load shaders that would break the GLSL compiler in the OpenGL driver
continue;
}
LoadVertexShader( i );
LoadFragmentShader( i );
LoadGLSLProgram( i, i, i );
}
// special case handling for fastZ shaders
/*
switch( glConfig.driverType )
{
case GLDRV_OPENGL32_CORE_PROFILE:
case GLDRV_OPENGL_ES2:
case GLDRV_OPENGL_ES3:
case GLDRV_OPENGL_MESA:
{
builtinShaders[BUILTIN_SHADOW] = FindVertexShader( "shadow.vp" );
int shadowFragmentShaderIndex = FindFragmentShader( "shadow.fp" );
FindGLSLProgram( "shadow.vp", builtinShaders[BUILTIN_SHADOW], shadowFragmentShaderIndex );
if( glConfig.gpuSkinningAvailable )
{
builtinShaders[BUILTIN_SHADOW_SKINNED] = FindVertexShader( "shadow_skinned.vp" );
int shadowFragmentShaderIndex = FindFragmentShader( "shadow_skinned.fp" );
FindGLSLProgram( "shadow_skinned.vp", builtinShaders[BUILTIN_SHADOW_SKINNED], shadowFragmentShaderIndex );
break;
}
}
default:
{
// fast path on PC
builtinShaders[BUILTIN_SHADOW] = FindVertexShader( "shadow.vp" );
FindGLSLProgram( "shadow.vp", builtinShaders[BUILTIN_SHADOW], -1 );
if( glConfig.gpuSkinningAvailable )
{
builtinShaders[BUILTIN_SHADOW_SKINNED] = FindVertexShader( "shadow_skinned.vp" );
FindGLSLProgram( "shadow_skinned.vp", builtinShaders[BUILTIN_SHADOW_SKINNED], -1 );
}
}
}
*/
glslUniforms.SetNum( RENDERPARM_USER + MAX_GLSL_USER_PARMS, vec4_zero );
if( glConfig.gpuSkinningAvailable )
{
vertexShaders[builtinShaders[BUILTIN_TEXTURE_VERTEXCOLOR_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_INTERACTION_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_INTERACTION_AMBIENT_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_ENVIRONMENT_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_BUMPY_ENVIRONMENT_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_DEPTH_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_SHADOW_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_SHADOW_DEBUG_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_FOG_SKINNED]].usesJoints = true;
// RB begin
vertexShaders[builtinShaders[BUILTIN_INTERACTION_SHADOW_MAPPING_SPOT_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_INTERACTION_SHADOW_MAPPING_POINT_SKINNED]].usesJoints = true;
vertexShaders[builtinShaders[BUILTIN_INTERACTION_SHADOW_MAPPING_PARALLEL_SKINNED]].usesJoints = true;
// RB end
}
cmdSystem->AddCommand( "reloadShaders", R_ReloadShaders, CMD_FL_RENDERER, "reloads shaders" );
}
int VulkanRenderer::LoadFragmentShader( const std::string& file )
{
size_t size = 0;
void* data = loadShader( file, &size );
return LoadFragmentShader( data, size );
}
