void board_update()
{
cgGLEnableProfile(cg__fragmentProfile);
cgGLBindProgram(cg__fragmentProgram);
// transfer data to texture
texture_load_array(board__computeTexture, GL_TEXTURE_RECTANGLE_ARB, board__width, board__width, board__data);
// perform computation
CGparameter textureCg = cgGetNamedParameter(cg__fragmentProgram, "aBoard");
cgGLSetTextureParameter(textureCg, board__computeTexture);
cgGLEnableTextureParameter(textureCg);
CGparameter widthCg = cgGetNamedParameter(cg__fragmentProgram, "aWidth");
cgSetParameter1f(widthCg, board__width);
board_draw(); // GPGPU CONCEPT 4: Viewport-Sized Quad = Data Stream Generator.
cgGLDisableTextureParameter(textureCg);
cgGLDisableProfile(cg__fragmentProfile);
// Read back the results
glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
// The glReadBuffer function selects a color buffer source for pixels.
// void glReadBuffer(GLenum mode); mode is a color buffer
// The glReadPixels function reads a block of pixels from the framebuffer.
glReadPixels(
0, 0, // GLint x, y The window coordinates of the first pixel that is read from the framebuffer. This location is the lower-left corner of a rectangular block of pixels
board__width, // GLsizei width
board__width, // GLsizei height
GL_RGBA, // GLenum format
GL_FLOAT, // GLenum type
board__data); // GLvoid *pixels
}
void Shader::Apply()
{
if (vertex_program)
{
cgGLSetStateMatrixParameter(cgGetNamedParameter(vertex_program, "ModelViewProj"), CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLBindProgram(vertex_program);
cgGLEnableProfile(vertex_profile);
}
else
{
cgGLDisableProfile(vertex_profile);
}
if (fragment_program)
{
GLint handle;
CGparameter param;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &handle);
param = cgGetNamedParameter(fragment_program, "Decal");
cgGLSetTextureParameter(param, handle);
cgGLEnableTextureParameter(param);
cgGLBindProgram(fragment_program);
cgGLEnableProfile(fragment_profile);
}
else
{
cgGLDisableProfile(fragment_profile);
}
}
int32_t PS3Graphics::LoadFragmentShader(std::string shaderPath)
{
// store the current path
_curFragmentShaderPath = shaderPath;
_vertexProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_VP_RSX, shaderPath.c_str(), "main_vertex");
_fragmentProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_FP_RSX, shaderPath.c_str(), "main_fragment");
// bind and enable the vertex and fragment programs
cgGLEnableProfile(CG_PROFILE_SCE_VP_RSX);
cgGLEnableProfile(CG_PROFILE_SCE_FP_RSX);
cgGLBindProgram(_vertexProgram);
cgGLBindProgram(_fragmentProgram);
// acquire mvp param from vertex shader
_cgpModelViewProj = cgGetNamedParameter(_vertexProgram, "modelViewProj");
_cgpVideoSize = cgGetNamedParameter(_fragmentProgram, "IN.video_size");
_cgpTextureSize = cgGetNamedParameter(_fragmentProgram, "IN.texture_size");
_cgpOutputSize = cgGetNamedParameter(_fragmentProgram, "IN.output_size");
if (active_shader)
lib_free(active_shader);
active_shader = util_concat(shaderPath.c_str(), NULL);
return CELL_OK;
}
Cluster::Cluster (const btVector3& origin, QScriptProgram& shellProgram,
QObject* parent) :
QObject(parent),
d(new Private(origin, shellProgram, this))
{
setup();
CGprogram prog = scene->shader("fyreworks")->program();
d->shader.v0 = cgGetNamedParameter(prog, "v0");
d->shader.t = cgGetNamedParameter(prog, "t");
d->shader.nt = cgGetNamedParameter(prog, "nt");
d->shader.origin = cgGetNamedParameter(prog, "origin");
d->shader.eye = cgGetNamedParameter(prog, "eye");
// color
d->colorTable.insert("red" , btVector3(1.0f , 0.0f , 0.0f ));
d->colorTable.insert("orange" , btVector3(1.0f , 0.6f , 0.0f ));
d->colorTable.insert("gold" , btVector3(1.0f , 0.84f, 0.0f ));
d->colorTable.insert("yellow" , btVector3(1.0f , 1.0f , 0.0f ));
d->colorTable.insert("green" , btVector3(0.0f , 1.0f , 0.0f ));
d->colorTable.insert("blue" , btVector3(0.0f , 0.0f , 1.0f ));
d->colorTable.insert("purple" , btVector3(0.50f, 0.50f, 0.0f ));
d->colorTable.insert("silver" , btVector3(0.75f, 0.75f, 0.75f));
QList<btVector3> colors (d->colorTable.values());
d->color = colors[floor(randf(colors.size()))];
// sound
soundEngine->soundSystem()->playSound(
FMOD_CHANNEL_REUSE, soundEngine->sound("explosion"), false, d->channel);
d->channel->set3DAttributes(d->origin);
}
static void renderchain_bind_luts(cg_renderchain_t *chain,
Pass *pass)
{
unsigned i, index;
for (i = 0; i < chain->luts.size(); i++)
{
CGparameter vparam;
CGparameter fparam = cgGetNamedParameter(pass->fPrg, chain->luts[i].id);
int bound_index = -1;
if (fparam)
{
index = cgGetParameterResourceIndex(fparam);
bound_index = index;
cg_d3d9_renderchain_add_lut(chain, index, i);
}
vparam = cgGetNamedParameter(pass->vPrg, chain->luts[i].id);
if (vparam)
{
index = cgGetParameterResourceIndex(vparam);
if (index != (unsigned)bound_index)
cg_d3d9_renderchain_add_lut(chain, index, i);
}
}
}
void cgtk::raycasting_pass()
{
disable_renderbuffers();
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_RECTANGLE_ARB,final_image,0);
//glClearColor(0,0,0,0);
//glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
cgGLEnableProfile(vertexProfile);
cgGLEnableProfile(fragmentProfile);
cgGLBindProgram(vertex_main);
cgGLBindProgram(fragment_main);
cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"stepsize"),stepsize);
cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"width"),WINDOW_SIZE_W);
cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"heigth"),WINDOW_SIZE_H);
set_tex_param("tex",backface_buffer,fragment_main,param1);
set_tex_param("volume_tex",volume_texture,fragment_main,param2);
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//drawQuads(1,1,1,b);
drawBd();
cgGLDisableProfile(vertexProfile);
cgGLDisableProfile(fragmentProfile);
glDisable(GL_CULL_FACE);
glDisable(GL_BLEND);
}
static void set_program_base_attrib(unsigned i)
{
CGparameter param = cgGetFirstParameter(prg[i].vprg, CG_PROGRAM);
for (; param; param = cgGetNextParameter(param))
{
if (cgGetParameterDirection(param) != CG_IN || cgGetParameterVariability(param) != CG_VARYING)
continue;
const char *semantic = cgGetParameterSemantic(param);
if (!semantic)
continue;
RARCH_LOG("CG: Found semantic \"%s\" in prog #%u.\n", semantic, i);
if (strcmp(semantic, "TEXCOORD") == 0 || strcmp(semantic, "TEXCOORD0") == 0)
prg[i].tex = param;
else if (strcmp(semantic, "COLOR") == 0 || strcmp(semantic, "COLOR0") == 0)
prg[i].color = param;
else if (strcmp(semantic, "POSITION") == 0)
prg[i].vertex = param;
else if (strcmp(semantic, "TEXCOORD1") == 0)
prg[i].lut_tex = param;
}
if (!prg[i].tex)
prg[i].tex = cgGetNamedParameter(prg[i].vprg, "IN.tex_coord");
if (!prg[i].color)
prg[i].color = cgGetNamedParameter(prg[i].vprg, "IN.color");
if (!prg[i].vertex)
prg[i].vertex = cgGetNamedParameter(prg[i].vprg, "IN.vertex_coord");
if (!prg[i].lut_tex)
prg[i].lut_tex = cgGetNamedParameter(prg[i].vprg, "IN.lut_tex_coord");
}
void RenderChain::bind_orig(Pass &pass)
{
D3DXVECTOR2 video_size, texture_size;
video_size.x = passes[0].last_width;
video_size.y = passes[0].last_height;
texture_size.x = passes[0].info.tex_w;
texture_size.y = passes[0].info.tex_h;
set_cg_param(pass.vPrg, "ORIG.video_size", video_size);
set_cg_param(pass.fPrg, "ORIG.video_size", video_size);
set_cg_param(pass.vPrg, "ORIG.texture_size", texture_size);
set_cg_param(pass.fPrg, "ORIG.texture_size", texture_size);
CGparameter param = cgGetNamedParameter(pass.fPrg, "ORIG.texture");
if (param)
{
unsigned index = cgGetParameterResourceIndex(param);
dev->SetTexture(index, passes[0].tex);
dev->SetSamplerState(index, D3DSAMP_MAGFILTER,
translate_filter(passes[0].info.pass->filter));
dev->SetSamplerState(index, D3DSAMP_MINFILTER,
translate_filter(passes[0].info.pass->filter));
dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
bound_tex.push_back(index);
}
param = cgGetNamedParameter(pass.vPrg, "ORIG.tex_coord");
if (param)
{
unsigned index = pass.attrib_map[cgGetParameterResourceIndex(param)];
dev->SetStreamSource(index, passes[0].vertex_buf, 0, sizeof(Vertex));
bound_vert.push_back(index);
}
}
void RenderChain::bind_pass(Pass &pass, unsigned pass_index)
{
// We only bother binding passes which are two indices behind.
if (pass_index < 3)
return;
for (unsigned i = 1; i < pass_index - 1; i++)
{
char pass_base[64];
snprintf(pass_base, sizeof(pass_base), "PASS%u.", i);
std::string attr_texture = pass_base;
attr_texture += "texture";
std::string attr_video_size = pass_base;
attr_video_size += "video_size";
std::string attr_texture_size = pass_base;
attr_texture_size += "texture_size";
std::string attr_tex_coord = pass_base;
attr_tex_coord += "tex_coord";
D3DXVECTOR2 video_size, texture_size;
video_size.x = passes[i].last_width;
video_size.y = passes[i].last_height;
texture_size.x = passes[i].info.tex_w;
texture_size.y = passes[i].info.tex_h;
set_cg_param(pass.vPrg, attr_video_size.c_str(), video_size);
set_cg_param(pass.fPrg, attr_video_size.c_str(), video_size);
set_cg_param(pass.vPrg, attr_texture_size.c_str(), texture_size);
set_cg_param(pass.fPrg, attr_texture_size.c_str(), texture_size);
CGparameter param = cgGetNamedParameter(pass.fPrg, attr_texture.c_str());
if (param)
{
unsigned index = cgGetParameterResourceIndex(param);
bound_tex.push_back(index);
dev->SetTexture(index, passes[i].tex);
dev->SetSamplerState(index, D3DSAMP_MAGFILTER,
translate_filter(passes[i].info.pass->filter));
dev->SetSamplerState(index, D3DSAMP_MINFILTER,
translate_filter(passes[i].info.pass->filter));
dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
}
param = cgGetNamedParameter(pass.vPrg, attr_tex_coord.c_str());
if (param)
{
unsigned index = pass.attrib_map[cgGetParameterResourceIndex(param)];
dev->SetStreamSource(index, passes[i].vertex_buf, 0, sizeof(Vertex));
bound_vert.push_back(index);
}
}
}
void ParticleShaderDiskDevelop::bindCGParametersFragment()
{
// Bind the first fragment program parameters
lightPositionEC = cgGetNamedParameter(fProgram,"lightPositionEC");
diffuseColor = cgGetNamedParameter(fProgram,"diffuseColor");
diskRadius = cgGetNamedParameter(fProgram,"diskRadius");
if (!lightPositionEC || !diffuseColor || !diskRadius)
exit(-1);
}
bool ShaderTextureInterface::InitProgram() {
if (!loadVertexProgram("CG/shaderTexture.cg", "VertexMain")) return false;
if (!loadFragmentProgram("CG/shaderTexture.cg", "FragmentMain")) return false;
// build some parameters by name such that we can set them later...
vertexModelViewProj = cgGetNamedParameter(vertexProgram, "modelViewProj");
fragmentTex = cgGetNamedParameter(fragmentProgram, "tex");
return true;
}
void ParticleShaderDiskDevelop::bindCGParametersVertex()
{
// Bind the vertex program parameters
modelViewProj = cgGetNamedParameter(vProgram,"modelViewProj");
modelView = cgGetNamedParameter(vProgram,"modelView");
modelViewIT = cgGetNamedParameter(vProgram,"modelViewIT");
viewMatrix = cgGetNamedParameter(vProgram,"viewMatrix");
diskCenterWC = cgGetNamedParameter(vProgram,"diskCenterWC");
if (!modelViewProj || !modelView || !modelViewIT || !viewMatrix || !diskCenterWC)
exit(-1);
}
static void gl_cg_set_program_base_attrib(void *data, unsigned i)
{
cg_shader_data_t *cg = (cg_shader_data_t*)data;
CGparameter param = cgGetFirstParameter(
cg->prg[i].vprg, CG_PROGRAM);
for (; param; param = cgGetNextParameter(param))
{
uint32_t semantic_hash;
const char *semantic = NULL;
if (cgGetParameterDirection(param) != CG_IN
|| cgGetParameterVariability(param) != CG_VARYING)
continue;
semantic = cgGetParameterSemantic(param);
if (!semantic)
continue;
RARCH_LOG("CG: Found semantic \"%s\" in prog #%u.\n", semantic, i);
semantic_hash = djb2_calculate(semantic);
switch (semantic_hash)
{
case SEMANTIC_TEXCOORD:
case SEMANTIC_TEXCOORD0:
cg->prg[i].tex = param;
break;
case SEMANTIC_COLOR:
case SEMANTIC_COLOR0:
cg->prg[i].color = param;
break;
case SEMANTIC_POSITION:
cg->prg[i].vertex = param;
break;
case SEMANTIC_TEXCOORD1:
cg->prg[i].lut_tex = param;
break;
}
}
if (!cg->prg[i].tex)
cg->prg[i].tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.tex_coord");
if (!cg->prg[i].color)
cg->prg[i].color = cgGetNamedParameter(cg->prg[i].vprg, "IN.color");
if (!cg->prg[i].vertex)
cg->prg[i].vertex = cgGetNamedParameter(cg->prg[i].vprg, "IN.vertex_coord");
if (!cg->prg[i].lut_tex)
cg->prg[i].lut_tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.lut_tex_coord");
}
void CgInit(){
CgCtxt = cgCreateContext();
CgProg = cgCreateProgramFromFile( CgCtxt, CG_SOURCE, "shader.cg",
CgProf, NULL, NULL );
if( CgProg != NULL ){
cgGLLoadProgram( CgProg );
ModelViewProjParam = cgGetNamedParameter( CgProg, "ModelViewProj" );
LightAngle = cgGetNamedParameter( CgProg, "LA" );
LightY = cgGetNamedParameter( CgProg, "LY" );
}
}
//
// GetBindableUniform
//
void CCgShadingProgram::GetBindableUniform(
const string& Name,
Ptr<IBindableUniform> *Uniform
) const
{
if (!m_Extensions->EXT_bindable_uniform)
throw CExtensionException( this, "::GetBindableUniform()", "GL_EXT_bindable_uniform" );
map<string, Ptr<IBindableUniform> >::const_iterator i = m_BindableUniformCache.find( Name );
if (i != m_BindableUniformCache.end())
{
*Uniform = i->second;
return;
}
CGparameter Parameter = cgGetNamedParameter( m_Program, Name.c_str() );
if (!Parameter)
{
*Uniform = NULL;
throw Sys::CException( this, "::GetBindableUniform() : Failed to get a program parameter by name \"%s\".", Name.c_str() );
}
*Uniform = new CCgBindableUniform( Name, m_Program, Parameter );
m_BindableUniformCache[ Name ] = *Uniform;
}
void
Scene::loadShader()
{
std::string sourcePtr = read("vshader.cg");
auto optimal = cgD3D11GetOptimalOptions(mCgVertexShaderProfile);
mVertexShaderId = cgCreateProgram(mCgContext, CG_SOURCE, sourcePtr.c_str(), mCgVertexShaderProfile, "main", optimal);
if(mVertexShaderId != nullptr)
{
optimal = cgD3D11GetOptimalOptions(mCgFragmentShaderProfile);
HRESULT res = cgD3D11LoadProgram(mVertexShaderId, NULL);
CGerror error;
const char *errorString = cgGetLastErrorString(&error);
sourcePtr = read("fshader.cg");
mFragmentShaderId = cgCreateProgram(mCgContext, CG_SOURCE, sourcePtr.c_str(), mCgFragmentShaderProfile, "main", optimal);
errorString = cgGetLastErrorString(&error);
res = cgD3D11LoadProgram(mFragmentShaderId, NULL);
}
// here the uniform can be set
CGparameter location = cgGetNamedParameter(mVertexShaderId, "ambient");
checkForCgError("could not get uniform color location", mCgContext, false);
cgSetParameter4fv(location, glm::value_ptr(glm::vec4(1.0,1.0,1.0,1.0)));
checkForCgError("could not set uniform color", mCgContext, false);
bindShader(mVertexShaderId, mFragmentShaderId);
}
int main(int argc,char** argv) {
diff_seconds();
srand(time(NULL));
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_DEPTH | GLUT_DOUBLE |GLUT_RGB);
glutInitWindowSize (900,600);
glutInitWindowPosition (240, 40);
glutCreateWindow ("E16 - Partikelsystem");
glutKeyboardFunc(keyboard);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
init();
glutDisplayFunc(display);
glutIdleFunc(idle);
glEnable(GL_DEPTH_TEST);
/********************************************/
cg_context = cgCreateContext();
checkForCgError("creating context");
cg_vertex_profile = cgGLGetLatestProfile(CG_GL_VERTEX);
cgGLSetOptimalOptions(cg_vertex_profile);
checkForCgError("selecting vertex profile");
cg_vertex_program = cgCreateProgramFromFile(cg_context, CG_SOURCE, "vertex.cg",
cg_vertex_profile, "more_complex_vertex_shader", NULL);
checkForCgError("creating vertex program from file");
cgGLLoadProgram(cg_vertex_program);
checkForCgError("loading vertex program");
/**************************************************/
cg_parameter_vertex_velocity = cgGetNamedParameter(cg_vertex_program, "Texture0");
cg_parameter_vertex_time = cgGetNamedParameter(cg_vertex_program, "Texture1");
glutMainLoop();
return 0;
}
GPUProgram::Parameter GPUProgram::getNamedParameter(String name)
{
GPUProgram::Parameter par;
CGparameter cgparam = cgGetNamedParameter(program, name.c_str());
parent->checkError();
par.cgparameter = cgparam;
return par;
}
static void renderchain_set_shader_mvp(cg_renderchain_t *chain, void *shader_data, void *matrix_data)
{
CGprogram *vPrg = (CGprogram*)shader_data;
const D3DXMATRIX *matrix = (const D3DXMATRIX*)matrix_data;
CGparameter cgpModelViewProj = cgGetNamedParameter(*vPrg, "modelViewProj");
if (cgpModelViewProj)
cgD3D9SetUniformMatrix(cgpModelViewProj, matrix);
}
CGparameter Shader::getParameter(const char *name)
{
CGparameter parameter;
parameter=cgGetNamedParameter(program,name);
#ifdef _DEBUG
context->checkError("could not get parameter");
#endif
return parameter;
}
void ParticleShaderVoronoi::bindCGParametersFragmentZero()
{
// Bind the first fragment program parameters
diskRadius = cgGetNamedParameter(fProgramZero,"diskRadius");
if (!diskRadius)
exit(-1);
}
//------------------------------------------------------------
// Get the pointer for accessing constants in the shader code.
//------------------------------------------------------------
ShaderHandle ShaderGL::GetConstatnt(const char* Name)
{
ShaderHandle sh = (ShaderHandle)cgGetNamedParameter(m_Program, Name);
checkForCgError("GetConstant");
if (!sh)
io::Logger::Warning("%s shader parameter not found.", Name);
return sh;
} // GetConstatnt
static void gl_cg_set_program_base_attrib(void *data, unsigned i)
{
cg_shader_data_t *cg = (cg_shader_data_t*)data;
CGparameter param = cgGetFirstParameter(
cg->prg[i].vprg, CG_PROGRAM);
for (; param; param = cgGetNextParameter(param))
{
const char *semantic = NULL;
if ( (cgGetParameterDirection(param) != CG_IN)
|| (cgGetParameterVariability(param) != CG_VARYING))
continue;
semantic = cgGetParameterSemantic(param);
if (!semantic)
continue;
RARCH_LOG("[CG]: Found semantic \"%s\" in prog #%u.\n", semantic, i);
if (
string_is_equal(semantic, "TEXCOORD") ||
string_is_equal(semantic, "TEXCOORD0")
)
cg->prg[i].tex = param;
else if (
string_is_equal(semantic, "COLOR") ||
string_is_equal(semantic, "COLOR0")
)
cg->prg[i].color = param;
else if (string_is_equal(semantic, "POSITION"))
cg->prg[i].vertex = param;
else if (string_is_equal(semantic, "TEXCOORD1"))
cg->prg[i].lut_tex = param;
}
if (!cg->prg[i].tex)
cg->prg[i].tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.tex_coord");
if (!cg->prg[i].color)
cg->prg[i].color = cgGetNamedParameter(cg->prg[i].vprg, "IN.color");
if (!cg->prg[i].vertex)
cg->prg[i].vertex = cgGetNamedParameter(cg->prg[i].vprg, "IN.vertex_coord");
if (!cg->prg[i].lut_tex)
cg->prg[i].lut_tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.lut_tex_coord");
}
bool CgGLShader::setIntVectorVariable(const char* name, const int4& vec) {
if(mProgram) {
CGparameter param = cgGetNamedParameter(mProgram, name);
if(_check_error(mContext) && param) {
cgSetParameter4iv(param, (const int*)vec.value);
return _check_error(mContext);
}
}
return false;
}
bool CgDxShader::setTextureVariable(const char* name, const TexturePtr& tex) {
if(mProgram && tex) {
CGparameter param = cgGetNamedParameter(mProgram, name);
if(_check_error(mContext) && param) {
cgD3D11SetTextureParameter(param, (ID3D11Resource*)tex->getTextureId());
return _check_error(mContext);
}
}
return false;
}
bool CgDxShader::setIntVariable(const char* name, uint32 len, const int* vals) {
if(mProgram) {
CGparameter param = cgGetNamedParameter(mProgram, name);
if(_check_error(mContext) && param) {
cgSetParameterValueic(param, len, (const int*)vals);
return _check_error(mContext);
}
}
return false;
}
bool CgDxShader::getMatrixVariable(const char* name, Matrix4& mat) {
if(mProgram) {
CGparameter param = cgGetNamedParameter(mProgram, name);
if(_check_error(mContext) && param) {
cgGetMatrixParameterfc(param, (float*)mat.x);
return _check_error(mContext);
}
}
return false;
}
bool CgDxShader::getIntVectorVariable(const char* name, int4& vec) {
if(mProgram) {
CGparameter param = cgGetNamedParameter(mProgram, name);
if(_check_error(mContext) && param) {
cgGetParameterValueic(param, 4, (int*)vec.value);
return _check_error(mContext);
}
}
return false;
}
CGparameter IOGLBaseShader::GetParameter(const CString& strName) const{
auto szName = String::ToANSI(strName);
auto uParam = cgGetNamedParameter(this->m_uProgram, reinterpret_cast<const char*>(szName.GetPointer()));
if(uParam == 0 || !cgIsParameter(uParam)){
CR_THROW(L"Failed to find parameter: " + strName);
}
return uParam;
}
int32_t FceuGraphics::LoadFragmentShader(string shaderPath)
{
LOG_DBG("LoadFragmentShader(%s)\n", shaderPath.c_str());
// store the cur path
_curFragmentShaderPath = shaderPath;
_vertexProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_VP_RSX, shaderPath.c_str(), "main_vertex");
if (_vertexProgram <= 0)
{
LOG_DBG("Error loading vertex shader...");
return 1;
}
_fragmentProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_FP_RSX, shaderPath.c_str(), "main_fragment");
if (_fragmentProgram <= 0)
{
LOG_DBG("Error loading fragment shader...");
return 1;
}
// bind and enable the vertex and fragment programs
cgGLEnableProfile(CG_PROFILE_SCE_VP_RSX);
cgGLEnableProfile(CG_PROFILE_SCE_FP_RSX);
cgGLBindProgram(_vertexProgram);
cgGLBindProgram(_fragmentProgram);
// acquire mvp param from v shader
_cgpModelViewProj = cgGetNamedParameter(_vertexProgram, "modelViewProj");
if (CheckCgError (__LINE__) != CG_NO_ERROR)
{
// FIXME: WHY DOES THIS GIVE ERROR ON OTHER LOADS
//return 1;
}
_cgpVideoSize = cgGetNamedParameter(_fragmentProgram, "IN.video_size");
_cgpTextureSize = cgGetNamedParameter(_fragmentProgram, "IN.texture_size");
_cgpOutputSize = cgGetNamedParameter(_fragmentProgram, "IN.output_size");
LOG_DBG("SUCCESS - LoadFragmentShader(%s)\n", shaderPath.c_str());
return CELL_OK;
}
