static void gl_cg_set_texture_info(cg_shader_data_t *cg, const struct cg_fbo_params *params, const struct gfx_tex_info *info) { CGparameter param = params->tex; if (param) { cgGLSetTextureParameter(param, info->tex); cgGLEnableTextureParameter(param); } set_param_2f(params->vid_size_v, info->input_size[0], info->input_size[1]); set_param_2f(params->vid_size_f, info->input_size[0], info->input_size[1]); set_param_2f(params->tex_size_v, info->tex_size[0], info->tex_size[1]); set_param_2f(params->tex_size_f, info->tex_size[0], info->tex_size[1]); if (params->coord) { cgGLSetParameterPointer(params->coord, 2, GL_FLOAT, 0, info->coord); cgGLEnableClientState(params->coord); cg->cg_attribs[cg->cg_attrib_idx++] = params->coord; } }
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); } }
void Effect::set(unsigned int level, const Texture* texture) { char semantic[] = {'T', 'E', 'X', static_cast<unsigned char> (level + 48), '\0'}; CGparameter parameter = cgGetEffectParameterBySemantic(effect.get(), semantic); cgGLSetTextureParameter(parameter, texture->getID()); }
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 ShaderParameterCg::Set(ITexture2D& texture) { Texture2D& tex = reinterpret_cast<Texture2D&>(texture); //assert(tex.GetBindID() >= 0 && "Faut bind la texture avant."); cgGLSetTextureParameter(this->_param, tex.GetID()); cgSetSamplerState(this->_param); }
/********************** * void BasicAS::setGPUParameters( CShader& l_Shader ) * * sets shader parameters for the BasicAS ***********************/ void BasicAS::setGPUParameters( CShader& l_Shader, GPUAccelerationStructureData& l_ASD ) { #ifndef STUB CGparameter& cell_info = l_Shader.GetNamedParameter("cellData0", true); cgGLSetTextureParameter(cell_info, l_ASD.m_CellTexture[0]); CGparameter& v0 = l_Shader.GetNamedParameter("v0t", true); cgGLSetTextureParameter(v0, l_ASD.m_VertexTexture[0]); CGparameter& v1 = l_Shader.GetNamedParameter("v1t", true); cgGLSetTextureParameter(v1, l_ASD.m_VertexTexture[1]); CGparameter& v2 = l_Shader.GetNamedParameter("v2t", true); cgGLSetTextureParameter(v2, l_ASD.m_VertexTexture[2]); #endif }
void IOGLBaseShader::RemoveSampler(CPtr<IOGLBaseTexture> pTexture){ uint32 uIndex = 0; while(Collection::TryFind(this->m_pSamplerTextures, pTexture, uIndex)){ cgGLSetTextureParameter(this->m_uSamplerParams[uIndex], 0); this->m_uSamplerParams.Remove(uIndex); this->m_pSamplerTextures.Remove(uIndex); } }
void Cg::SetTextureParameter(CGparameter decal,int texname){ if (decal != NULL) cgGLSetTextureParameter(decal,texname); else { cout<<"CGparameter is null"<<endl; abort(); } CheckCgError(); }
bool CgGLShader::setTextureVariable(const char* name, const TexturePtr& tex) { if(mProgram && tex) { CGparameter param = cgGetNamedParameter(mProgram, name); if(_check_error(mContext) && param) { cgGLSetTextureParameter(param, (GLuint)tex->getTextureId()); cgSetSamplerState(param); return _check_error(mContext); } } return false; }
void COpenGLCgUniformSampler2D::update(const void* data, const SMaterial& material) const { s32* Data = (s32*)data; s32 LayerID = *Data; if (material.TextureLayer[LayerID].Texture) { int TextureID = reinterpret_cast<COpenGLTexture*>(material.TextureLayer[LayerID].Texture)->getOpenGLTextureName(); cgGLSetTextureParameter(Parameter, TextureID); cgGLEnableTextureParameter(Parameter); } }
// // SetSampler // void CCgSamplerUniform::SetSampler( Ptr<const CTexture> Texture ) { cgGLSetTextureParameter( m_Parameter, Texture->m_Texture ); /* #ifdef _DEBUG CGerror Error = cgGetError(); if (Error != CG_NO_ERROR) throw CCgException( this, Error, "::SetSampler() : A Cg error has occured." ); #endif */ }
void Bvh::setGPUParameters( CShader& l_Shader, GPUAccelerationStructureData& l_ASD ) { #ifndef STUB CGparameter& v0 = l_Shader.GetNamedParameter("v0t", true); cgGLSetTextureParameter(v0, l_ASD.m_VertexTexture[0]); CGparameter& v1 = l_Shader.GetNamedParameter("v1t", true); cgGLSetTextureParameter(v1, l_ASD.m_VertexTexture[1]); CGparameter& v2 = l_Shader.GetNamedParameter("v2t", true); cgGLSetTextureParameter(v2, l_ASD.m_VertexTexture[2]); //l_ASD.SaveTextureData( "v0t.txt", l_ASD.m_VertexTexture[0] ); //l_ASD.SaveTextureData( "v1t.txt", l_ASD.m_VertexTexture[1] ); //l_ASD.SaveTextureData( "v2t.txt", l_ASD.m_VertexTexture[2] ); CGparameter& maxindex = l_Shader.GetNamedParameter("maxIndex"); cgGLSetParameter1f( maxindex, (float)m_NodeUsed ); CGparameter& maxloop = l_Shader.GetNamedParameter("looplimit"); cgGLSetParameter1f( maxloop, 2500.0f ); #endif }
void IOGLBaseShader::FreeSampler(const CString& strName){ auto uParam = this->GetParameter(strName); if(this->m_bBinded){ cgGLDisableTextureParameter(uParam); } uint32 uIndex = 0; if(Collection::TryFind(this->m_uSamplerParams, uParam, uIndex)){ cgGLSetTextureParameter(uParam, 0); this->m_uSamplerParams.Remove(uIndex); this->m_pSamplerTextures.Remove(uIndex); } }
void IOGLBaseShader::SetSampler(const CString& strName, CRefPtr<Graphic::IBaseTexture> pTexture){ CR_APICHECK(this, pTexture); auto pGLTexture = pTexture.Cast<IOGLBaseTexture>(); auto uParam = this->GetParameter(strName); this->FreeSampler(strName); cgGLSetTextureParameter(uParam, pGLTexture->GetTextureID()); if(this->m_bBinded){ cgGLEnableTextureParameter(uParam); } this->m_uSamplerParams.Add(uParam); this->m_pSamplerTextures.Add(pGLTexture); }
void ParticleShaderVoronoi::bindCGParametersFragmentOne() { // Bind the first fragment program parameters lightPositionEC = cgGetNamedParameter(fProgramOne,"lightPositionEC"); diffuseColor = cgGetNamedParameter(fProgramOne,"diffuseColor"); diskRadius = cgGetNamedParameter(fProgramOne,"diskRadius"); firstPassDepth = cgGetNamedParameter(fProgramOne,"firstPassDepth"); depthRange = cgGetNamedParameter(fProgramOne,"depthRange"); toleranceScaleFactor = cgGetNamedParameter(fProgramOne,"toleranceScaleFactor"); cgGLSetTextureParameter(firstPassDepth, depth_texture); if (!lightPositionEC || !diffuseColor || !diskRadius || !firstPassDepth || !depthRange || !toleranceScaleFactor) exit(-1); }
void ShaderProjectiveTextureInterface::PerFrameInit() { // bind the texture GLuint texture_id = mesh->projTexture->texture->Bind(); //set parameters cgGLSetStateMatrixParameter(vertexModelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); float zNear = 1.0f; float zFar = 1000.0f; M44 biasMatrix, lightViewMatrix, projectionMatrix; BuildBiasMatrix(biasMatrix); BuildLightViewMatrix(mesh->projTexture->ppc, lightViewMatrix); BuildProjectionMatrix(mesh->projTexture->ppc, zNear, zFar, projectionMatrix); lightViewMatrix = biasMatrix * projectionMatrix * lightViewMatrix; cgSetMatrixParameterfr(vertexTextureMatrix, (float*)lightViewMatrix.rows); cgGLSetTextureParameter(fragmentProjectiveMap, texture_id); }
void FreezeParticle::InitializeFreezeParticleShader() { TextureLoader textureLoader; glTexture FreezeParticleTexture; FreezeParticleProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); cgGLSetOptimalOptions(FreezeParticleProfile); CheckForCgError("FreezeParticle", "selecting fragment profile"); FreezeParticleProgram = cgCreateProgramFromFile(ShaderContext, CG_SOURCE, "assets/pixelshaders/ps_freezeparticle.cg", FreezeParticleProfile, "pixelMain", 0); CheckForCgError("FreezeParticle", "creating fragment program from file"); cgGLLoadProgram(FreezeParticleProgram); CheckForCgError("FreezeParticle", "loading fragment program"); FreezeParticleCoord0 = cgGetNamedParameter(FreezeParticleProgram, "texcoord0"); textureLoader.LoadTextureFromDisk("assets/textures/weapon/freezeparticle.tga", &FreezeParticleTexture); FreezeParticleText1 = cgGetNamedParameter(FreezeParticleProgram, "text1"); cgGLSetTextureParameter(FreezeParticleText1, FreezeParticleTexture.TextureID); CheckForCgError("FreezeParticle", "setting decal 2D texture"); }
void GLWindow::showImage( TexInfo texInfo ) { if( texInfo.handle == 0 ) return; mCurrentTexture = texInfo; mTextureValid = true; // Make it the current texture glEnable( mTextureMode ); glBindTexture(mTextureMode, texInfo.handle); #ifdef COMPILE_CG // Set the texture to be used by the shader program if( mUseCG ) cgGLSetTextureParameter(cgImageParam, texInfo.handle); #endif updateTextureCoords(); updateGL(); }
void DrawSea() { seatime=seatime+1.0f/2400.0f; if(seatime>1.0f) seatime=seatime-1.0f; cgSetParameter1f(cgGetNamedParameter( g_Sea_vertex, "time"), seatime); g_CGparam_AmbientReflectiveSea = cgGetNamedParameter(g_Sea_pixel, "AmbientReflectiveTexturSea"); cgGLSetTextureParameter( g_CGparam_AmbientReflectiveSea, AmbientReflectiveTexture ); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "globalAmbient" ), globalAmbient); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "paraLightColor" ), paraLightColor); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "paraLightDirection" ), LightSunPos); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "eyePosition"), eyePositionSea); cgSetParameter3fv(cgGetNamedParameter( g_Sea_pixel, "FogColor"), pixelfogColor); //cgSetParameter1f(cgGetNamedParameter( g_Sea_pixel, "time"), seatime); cgGLBindProgram( g_Sea_vertex ); cgGLEnableProfile( g_CGprofile_vertex ); cgGLBindProgram( g_Sea_pixel ); cgGLEnableProfile( g_CGprofile_pixel ); cgGLEnableTextureParameter( g_CGparam_AmbientReflectiveSea ); }
static void gl_cg_set_params(void *data, void *shader_data, unsigned width, unsigned height, unsigned tex_width, unsigned tex_height, unsigned out_width, unsigned out_height, unsigned frame_count, const void *_info, const void *_prev_info, const void *_feedback_info, const void *_fbo_info, unsigned fbo_info_cnt) { unsigned i; const struct gfx_tex_info *info = (const struct gfx_tex_info*)_info; const struct gfx_tex_info *prev_info = (const struct gfx_tex_info*)_prev_info; const struct gfx_tex_info *feedback_info = (const struct gfx_tex_info*)_feedback_info; const struct gfx_tex_info *fbo_info = (const struct gfx_tex_info*)_fbo_info; cg_shader_data_t *cg_data = (cg_shader_data_t*)shader_data; if (!cg_data || (cg_data->active_idx == 0) || (cg_data->active_idx == GL_SHADER_STOCK_BLEND)) return; /* Set frame. */ set_param_2f(cg_data->prg[cg_data->active_idx].vid_size_f, width, height); set_param_2f(cg_data->prg[cg_data->active_idx].tex_size_f, tex_width, tex_height); set_param_2f(cg_data->prg[cg_data->active_idx].out_size_f, out_width, out_height); cg_gl_set_param_1f(cg_data->prg[cg_data->active_idx].frame_dir_f, state_manager_frame_is_reversed() ? -1.0 : 1.0); set_param_2f(cg_data->prg[cg_data->active_idx].vid_size_v, width, height); set_param_2f(cg_data->prg[cg_data->active_idx].tex_size_v, tex_width, tex_height); set_param_2f(cg_data->prg[cg_data->active_idx].out_size_v, out_width, out_height); cg_gl_set_param_1f(cg_data->prg[cg_data->active_idx].frame_dir_v, state_manager_frame_is_reversed() ? -1.0 : 1.0); if (cg_data->prg[cg_data->active_idx].frame_cnt_f || cg_data->prg[cg_data->active_idx].frame_cnt_v) { unsigned modulo = cg_data->shader->pass[cg_data->active_idx - 1].frame_count_mod; if (modulo) frame_count %= modulo; cg_gl_set_param_1f(cg_data->prg[cg_data->active_idx].frame_cnt_f, (float)frame_count); cg_gl_set_param_1f(cg_data->prg[cg_data->active_idx].frame_cnt_v, (float)frame_count); } /* Set orig texture. */ gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].orig, info); /* Set feedback texture. */ gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].feedback, feedback_info); /* Set prev textures. */ for (i = 0; i < PREV_TEXTURES; i++) gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].prev[i], &prev_info[i]); /* Set lookup textures. */ for (i = 0; i < cg_data->shader->luts; i++) { CGparameter vparam; CGparameter fparam = cgGetNamedParameter( cg_data->prg[cg_data->active_idx].fprg, cg_data->shader->lut[i].id); if (fparam) { cgGLSetTextureParameter(fparam, cg_data->lut_textures[i]); cgGLEnableTextureParameter(fparam); } vparam = cgGetNamedParameter(cg_data->prg[cg_data->active_idx].vprg, cg_data->shader->lut[i].id); if (vparam) { cgGLSetTextureParameter(vparam, cg_data->lut_textures[i]); cgGLEnableTextureParameter(vparam); } } /* Set FBO textures. */ if (cg_data->active_idx) { for (i = 0; i < fbo_info_cnt; i++) gl_cg_set_texture_info(cg_data, &cg_data->prg[cg_data->active_idx].fbo[i], &fbo_info[i]); } /* #pragma parameters. */ for (i = 0; i < cg_data->shader->num_parameters; i++) { CGparameter param_v = cgGetNamedParameter( cg_data->prg[cg_data->active_idx].vprg, cg_data->shader->parameters[i].id); CGparameter param_f = cgGetNamedParameter( cg_data->prg[cg_data->active_idx].fprg, cg_data->shader->parameters[i].id); cg_gl_set_param_1f(param_v, cg_data->shader->parameters[i].current); cg_gl_set_param_1f(param_f, cg_data->shader->parameters[i].current); } /* Set state parameters. */ if (cg_data->state_tracker) { /* Only query uniforms in first pass. */ static struct state_tracker_uniform tracker_info[GFX_MAX_VARIABLES]; static unsigned cnt = 0; if (cg_data->active_idx == 1) cnt = state_tracker_get_uniform(cg_data->state_tracker, tracker_info, GFX_MAX_VARIABLES, frame_count); for (i = 0; i < cnt; i++) { CGparameter param_v = cgGetNamedParameter( cg_data->prg[cg_data->active_idx].vprg, tracker_info[i].id); CGparameter param_f = cgGetNamedParameter( cg_data->prg[cg_data->active_idx].fprg, tracker_info[i].id); cg_gl_set_param_1f(param_v, tracker_info[i].value); cg_gl_set_param_1f(param_f, tracker_info[i].value); } } }
void GPUProgram::Parameter::setTexture(Texture* t) { cgGLSetTextureParameter(cgparameter, t->getGLName()); cgGLEnableTextureParameter(cgparameter); }
void CG_initialize(void) { cgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX); cgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); cgGLSetOptimalOptions(cgVertexProfile); cgGLSetOptimalOptions(cgFragmentProfile); cgContext = cgCreateContext(); cgVertexProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "CG_ENVIRO_MAPPING/oglu_per_vertex_reflective_environment_mapping_vs.cg", cgVertexProfile, NULL, NULL); cgGLLoadProgram(cgVertexProgram); enviroCgVertexParam_lightPosition = cgGetNamedParameter(cgVertexProgram, "lightPosition"); enviroCgVertexParam_globalAmbient = cgGetNamedParameter(cgVertexProgram, "globalAmbient"); enviroCgVertexParam_lightColor = cgGetNamedParameter(cgVertexProgram, "lightColor"); //enviroCgVertexParam_Ke = cgGetNamedParameter(cgVertexProgram, "Ke"); enviroCgVertexParam_Ka = cgGetNamedParameter(cgVertexProgram, "Ka"); enviroCgVertexParam_Kd = cgGetNamedParameter(cgVertexProgram, "Kd"); enviroCgVertexParam_Ks = cgGetNamedParameter(cgVertexProgram, "Ks"); enviroCgVertexParam_shininess = cgGetNamedParameter(cgVertexProgram, "shininess"); enviroCgVertexParam_time = cgGetNamedParameter(cgVertexProgram, "time"); cgModelViewProj = cgGetNamedParameter(cgVertexProgram, "ModelViewProj"); cgModelView = cgGetNamedParameter(cgVertexProgram, "ModelView"); cgModelViewI = cgGetNamedParameter(cgVertexProgram, "ModelViewI"); cgModelViewIT = cgGetNamedParameter(cgVertexProgram, "ModelViewIT"); cgPosition = cgGetNamedParameter(cgVertexProgram, "position"); cgNormal = cgGetNamedParameter(cgVertexProgram, "N"); cgTexcoords = cgGetNamedParameter(cgVertexProgram, "texCoord"); cgEyePosition = cgGetNamedParameter(cgVertexProgram, "eyePosition"); cgGLSetParameter3f(cgEyePosition, 0, 0, 0); cgFragmentProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "CG_ENVIRO_MAPPING/oglu_per_vertex_reflective_environment_mapping_ps.cg", cgFragmentProfile, NULL, NULL ); cgGLLoadProgram(cgFragmentProgram); cgEnvironmentMap = cgGetNamedParameter(cgFragmentProgram, "environmentMap"); loadCubeMap(); cgGLSetTextureParameter(cgEnvironmentMap, cubemapTexture[0]); }
void Effect::setTexture( const char *_name, GLuint _texture ) { CGparameter texture = cgGetNamedEffectParameter( effect, _name ); cgGLSetTextureParameter( texture, _texture ); }
bool CgFXTechnique::validate(CgFXMaterial *pMat, DrawEnv *pEnv) { if(0x00 == (_uiValidationState & ValidationTried)) { #if 0 fprintf(stderr, "Validate %p\n", _pCGTechnique); #endif _uiValidationState = 0x03; #if 0 if(pWin != NULL) { pWin->activate(); } #endif if(_pCGTechnique == NULL || cgValidateTechnique(_pCGTechnique) == CG_FALSE ) { CgFXMaterial::checkForCgError("cgValidateTechnique", NULL); _uiValidationState = 0x02; } else { CgFXMaterial::checkForCgError("cgValidateTechnique", NULL); const CgFXMaterial::MFTexturesType *pTextures = pMat->getMFTextures(); CGpass pPass = cgGetFirstPass(_pCGTechnique); CgFXMaterial::checkForCgError("cgGetFirstPass", NULL); for(UInt32 i = 0; i < pTextures->size(); ++i) { const Char8 *szTexParamName = getName((*pTextures)[i]); Int32 iTexParamVal = -1; const ShaderVariable *pVar = pMat->getVariable(szTexParamName); OSG_ASSERT(pVar != NULL); const CgFXVariableTexObj *pTexVar = static_cast<const CgFXVariableTexObj *>(pVar); OSG_ASSERT(pTexVar != NULL); iTexParamVal = pTexVar->getValue(); if(iTexParamVal == -1) { CGparameter pParam = cgGetNamedEffectParameter(pMat->getEffect(), szTexParamName); CgFXMaterial::checkForCgError("cgGetNamedEffectParameter", NULL); (*pTextures)[i]->activate(pEnv, 0); Window::GLObjectId texObjId = pEnv->getWindow()->getGLObjectId( (*pTextures)[i]->getGLId()); cgGLSetTextureParameter(pParam, texObjId); CgFXMaterial::checkForCgError("cgGLSetTextureParameter", NULL); cgSetSamplerState (pParam ); CgFXMaterial::checkForCgError("cgSetSamplerState", NULL); CgFXVariableTexObj *pTexVarW = const_cast<CgFXVariableTexObj *>(pTexVar); pTexVarW->setValue(texObjId); (*pTextures)[i]->deactivate(pEnv); } } int count = 0; while(pPass) { StateUnrecPtr pState = State ::create(); CgFXPassChunkUnrecPtr pChunk = CgFXPassChunk::create(); pChunk->setPass (pPass); pChunk->setMaterial(pMat ); pState->addChunk(pChunk); this->addPassState(pState); pPass = cgGetNextPass(pPass); CgFXMaterial::checkForCgError("cgGetNextPass", NULL); count++; } pMat->updateUniformVariables(); } #if 0 if(_pCGTechnique != NULL) { fprintf(stderr, "Validated technique %s : %x\n", cgGetTechniqueName(_pCGTechnique), UInt32(_uiValidationState)); } #endif #if 0 if(pWin != NULL) { pWin->deactivate(); } #endif } return (_uiValidationState & TechniqueValid); }
static void gl_cg_set_params(unsigned width, unsigned height, unsigned tex_width, unsigned tex_height, unsigned out_width, unsigned out_height, unsigned frame_count, const struct gl_tex_info *info, const struct gl_tex_info *prev_info, const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt) { unsigned i; if (!cg_active || (active_index == 0) || (active_index == GL_SHADER_STOCK_BLEND)) return; // Set frame. set_param_2f(prg[active_index].vid_size_f, width, height); set_param_2f(prg[active_index].tex_size_f, tex_width, tex_height); set_param_2f(prg[active_index].out_size_f, out_width, out_height); set_param_1f(prg[active_index].frame_dir_f, g_extern.frame_is_reverse ? -1.0 : 1.0); set_param_2f(prg[active_index].vid_size_v, width, height); set_param_2f(prg[active_index].tex_size_v, tex_width, tex_height); set_param_2f(prg[active_index].out_size_v, out_width, out_height); set_param_1f(prg[active_index].frame_dir_v, g_extern.frame_is_reverse ? -1.0 : 1.0); if (prg[active_index].frame_cnt_f || prg[active_index].frame_cnt_v) { unsigned modulo = cg_shader->pass[active_index - 1].frame_count_mod; if (modulo) frame_count %= modulo; set_param_1f(prg[active_index].frame_cnt_f, (float)frame_count); set_param_1f(prg[active_index].frame_cnt_v, (float)frame_count); } // Set orig texture. CGparameter param = prg[active_index].orig.tex; if (param) { cgGLSetTextureParameter(param, info->tex); cgGLEnableTextureParameter(param); } set_param_2f(prg[active_index].orig.vid_size_v, info->input_size[0], info->input_size[1]); set_param_2f(prg[active_index].orig.vid_size_f, info->input_size[0], info->input_size[1]); set_param_2f(prg[active_index].orig.tex_size_v, info->tex_size[0], info->tex_size[1]); set_param_2f(prg[active_index].orig.tex_size_f, info->tex_size[0], info->tex_size[1]); if (prg[active_index].orig.coord) { cgGLSetParameterPointer(prg[active_index].orig.coord, 2, GL_FLOAT, 0, info->coord); cgGLEnableClientState(prg[active_index].orig.coord); cg_attribs[cg_attrib_index++] = prg[active_index].orig.coord; } // Set prev textures. for (i = 0; i < PREV_TEXTURES; i++) { param = prg[active_index].prev[i].tex; if (param) { cgGLSetTextureParameter(param, prev_info[i].tex); cgGLEnableTextureParameter(param); } set_param_2f(prg[active_index].prev[i].vid_size_v, prev_info[i].input_size[0], prev_info[i].input_size[1]); set_param_2f(prg[active_index].prev[i].vid_size_f, prev_info[i].input_size[0], prev_info[i].input_size[1]); set_param_2f(prg[active_index].prev[i].tex_size_v, prev_info[i].tex_size[0], prev_info[i].tex_size[1]); set_param_2f(prg[active_index].prev[i].tex_size_f, prev_info[i].tex_size[0], prev_info[i].tex_size[1]); if (prg[active_index].prev[i].coord) { cgGLSetParameterPointer(prg[active_index].prev[i].coord, 2, GL_FLOAT, 0, prev_info[i].coord); cgGLEnableClientState(prg[active_index].prev[i].coord); cg_attribs[cg_attrib_index++] = prg[active_index].prev[i].coord; } } // Set lookup textures. for (i = 0; i < cg_shader->luts; i++) { CGparameter fparam = cgGetNamedParameter(prg[active_index].fprg, cg_shader->lut[i].id); if (fparam) { cgGLSetTextureParameter(fparam, lut_textures[i]); cgGLEnableTextureParameter(fparam); } CGparameter vparam = cgGetNamedParameter(prg[active_index].vprg, cg_shader->lut[i].id); if (vparam) { cgGLSetTextureParameter(vparam, lut_textures[i]); cgGLEnableTextureParameter(vparam); } } // Set FBO textures. if (active_index > 2) { for (i = 0; i < fbo_info_cnt; i++) { if (prg[active_index].fbo[i].tex) { cgGLSetTextureParameter(prg[active_index].fbo[i].tex, fbo_info[i].tex); cgGLEnableTextureParameter(prg[active_index].fbo[i].tex); } set_param_2f(prg[active_index].fbo[i].vid_size_v, fbo_info[i].input_size[0], fbo_info[i].input_size[1]); set_param_2f(prg[active_index].fbo[i].vid_size_f, fbo_info[i].input_size[0], fbo_info[i].input_size[1]); set_param_2f(prg[active_index].fbo[i].tex_size_v, fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]); set_param_2f(prg[active_index].fbo[i].tex_size_f, fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]); if (prg[active_index].fbo[i].coord) { cgGLSetParameterPointer(prg[active_index].fbo[i].coord, 2, GL_FLOAT, 0, fbo_info[i].coord); cgGLEnableClientState(prg[active_index].fbo[i].coord); cg_attribs[cg_attrib_index++] = prg[active_index].fbo[i].coord; } } } // Set state parameters if (state_tracker) { // Only query uniforms in first pass. static struct state_tracker_uniform info[MAX_VARIABLES]; static unsigned cnt = 0; if (active_index == 1) cnt = state_get_uniform(state_tracker, info, MAX_VARIABLES, frame_count); for (i = 0; i < cnt; i++) { CGparameter param_v = cgGetNamedParameter(prg[active_index].vprg, info[i].id); CGparameter param_f = cgGetNamedParameter(prg[active_index].fprg, info[i].id); set_param_1f(param_v, info[i].value); set_param_1f(param_f, info[i].value); } } }
void Skydome::InitializeSkydomeShaders() { TextureLoader textureLoader; glTexture daySky, nightSky, redSky, sun, sunMask; textureLoader.LoadTextureFromDisk("assets/textures/sky/clouds2.tga", &daySky); textureLoader.LoadTextureFromDisk("assets/textures/sky/night.tga", &nightSky); textureLoader.LoadTextureFromDisk("assets/textures/sky/red.tga", &redSky); /* //Vertext Shader profile vsSkydomeProfile = cgGLGetLatestProfile(CG_GL_VERTEX); //Set profile cgGLSetOptimalOptions(vsFireballProfile); CheckForCgError("skydome", "selecting vertex profile"); //Load vertex shader vsFireballProgram = cgCreateProgramFromFile(ShaderContext, CG_SOURCE, "assets/vertexshaders/vs_fireball.cg", vsFireballProfile, "vertMain", 0); CheckForCgError("skydome", "creating vertex program from file"); cgGLLoadProgram(vsFireballProgram); CheckForCgError("skydome", "loading vertex program"); texVert = cgGetNamedParameter(vsFireballProgram, "texCoordIN"); position = cgGetNamedParameter(vsFireballProgram, "posIN"); move = cgGetNamedParameter(vsFireballProgram, "move"); mvMatrix = cgGetNamedParameter(vsFireballProgram, "ModelViewProj"); */ ///////////////////////////// //Pixel Shader psSkydomeProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); cgGLSetOptimalOptions(psSkydomeProfile); CheckForCgError("skydome", "selecting Skydome fragment profile"); psSkydomeProgram = cgCreateProgramFromFile(ShaderContext, CG_SOURCE, "assets/pixelshaders/ps_skydome.cg", psSkydomeProfile, "pixelMain", 0); CheckForCgError("skydome", "creating fragment program from file"); cgGLLoadProgram(psSkydomeProgram); CheckForCgError("skydome", "loading fragment program"); texcoord0 = cgGetNamedParameter(psSkydomeProgram, "texcoord0"); dayTime = cgGetNamedParameter(psSkydomeProgram, "lightdist"); transition = cgGetNamedParameter(psSkydomeProgram, "transition"); text1 = cgGetNamedParameter(psSkydomeProgram, "text1"); cgGLSetTextureParameter(text1, daySky.TextureID); text2 = cgGetNamedParameter(psSkydomeProgram, "text2"); cgGLSetTextureParameter(text2, nightSky.TextureID); text3 = cgGetNamedParameter(psSkydomeProgram, "text3"); cgGLSetTextureParameter(text3, redSky.TextureID); CheckForCgError("skydome", "setting decal 2D texture"); textureLoader.LoadTextureFromDisk("assets/textures/sky/sun.tga", &sun); textureLoader.LoadTextureFromDisk("assets/textures/sky/sunmask.tga", &sunMask); psSkydomeSunProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT); cgGLSetOptimalOptions(psSkydomeSunProfile); CheckForCgError("skydome", "selecting Skydome sun fragment profile"); psSkydomeSunProgram = cgCreateProgramFromFile(ShaderContext, CG_SOURCE, "assets/pixelshaders/ps_skydomeSun.cg", psSkydomeSunProfile, "pixelMain", 0); CheckForCgError("skydome", "creating fragment program from file"); cgGLLoadProgram(psSkydomeSunProgram); CheckForCgError("skydome", "loading fragment program"); texcoord0 = cgGetNamedParameter(psSkydomeSunProgram, "texcoord0"); suntext1 = cgGetNamedParameter(psSkydomeSunProgram, "text1"); cgGLSetTextureParameter(suntext1, sun.TextureID); suntext2 = cgGetNamedParameter(psSkydomeSunProgram, "text2"); cgGLSetTextureParameter(suntext2, sunMask.TextureID); CheckForCgError("skydome", "setting decal 2D texture"); //Temporarily Unbind Texture //glDisable(GL_TEXTURE_2D); //glDisable(GL_BLEND); // Disable Blending //glBindTexture(GL_TEXTURE_2D,0); }
//-- CgShaderCel::CgShaderCel(CGcontext cgContext) : CgShader(cgContext, CgShader::VertexFragment) { // [rad] This is vertex and fragment shader // [rad] Setup vertex shader: // [rad] Setup vertex shader entry point SetEntry(CgShader::Vertex, "main"); static const std::string sProgramVertex = " \ \ void main( float4 inPosition : POSITION, \ float4 inNormal : NORMAL, \ \ out float4 outOPosition : POSITION, \ out float4 outVPosition : TEXCOORD0, \ out float4 outNormal : TEXCOORD1, \ \ uniform float4x4 uniModelViewProjMat, \ uniform float4x4 uniModelViewITMat, \ uniform float4x4 uniModelViewMat) \ { \ outOPosition = mul(uniModelViewProjMat, inPosition); \ outVPosition = mul(uniModelViewMat, inPosition); \ \ outNormal = mul(uniModelViewITMat, inNormal); \ outNormal.xyz = normalize(outNormal.xyz); \ } "; // [rad] Setup vertex shader program SetProgram(CgShader::Vertex, sProgramVertex); // [rad] Setup fragment shader: // [rad] Setup fragment shader entry point SetEntry(CgShader::Fragment, "main"); static const std::string sProgramFragment = " \ \ void main( \ float4 inPosition : TEXCOORD0, \ float4 inNormal : TEXCOORD1, \ \ out float4 outColor : COLOR, \ \ uniform sampler1D uniTexDiffuse, \ uniform sampler1D uniTexSpecular, \ uniform sampler1D uniTexOutline, \ \ uniform float3 uniMatDiffuse, \ uniform float3 uniMatSpecular, \ uniform float3 uniLightColor, \ uniform float3 uniLightPosition, \ uniform float3 uniEyePosition, \ uniform float uniShininess, \ \ uniform int uniComputeOutline) \ { \ \ float3 p = inPosition.xyz; \ float3 n = normalize(inNormal.xyz); \ \ float3 l = normalize(uniLightPosition - p); \ float diffuseL = max(dot(n, l), 0); \ diffuseL = tex1D(uniTexDiffuse, diffuseL).x; \ float3 diffuse = uniLightColor * diffuseL * uniMatDiffuse; \ \ float3 v = normalize(uniEyePosition - p); \ float3 h = normalize(l + v); \ float specularL = pow(max(dot(n, h), 0), uniShininess); \ if(diffuseL <= 0) specularL = 0; \ specularL = tex1D(uniTexSpecular, specularL).x; \ float3 specular = uniLightColor * specularL * uniMatSpecular; \ \ float edgeL = 1; \ \ if(uniComputeOutline) \ { \ edgeL = max(dot(n, v), 0); \ edgeL = tex1D(uniTexOutline, edgeL).x; \ } \ \ outColor.x = edgeL * (diffuse + specular); \ outColor.y = edgeL * (diffuse + specular); \ outColor.z = edgeL * (diffuse + specular); \ outColor.w = 1; \ } "; // float3 diffuse = diffuseL * uniMatDiffuse; // float3 specular = specularL * uniMatSpecular; // [rad] Setup fragment shader program SetProgram(CgShader::Fragment, sProgramFragment); // [rad] Create shaders (both fragment and vertex) Create(); // [rad] Set params - vertex shader m_cgParamModelViewProjMatrix = cgGetNamedParameter(m_cgShaderVertex, "uniModelViewProjMat"); m_cgParamModelViewMatrix = cgGetNamedParameter(m_cgShaderVertex, "uniModelViewMat"); m_cgParamModelViewITMatrix = cgGetNamedParameter(m_cgShaderVertex, "uniModelViewITMat"); // [rad] Set params - fragment shader m_cgParamLightColorVector = cgGetNamedParameter(m_cgShaderFragment, "uniLightColor"); m_cgParamLightPositionVector = cgGetNamedParameter(m_cgShaderFragment, "uniLightPosition"); m_cgParamEyePositionVector = cgGetNamedParameter(m_cgShaderFragment, "uniEyePosition"); m_cgParamShininess = cgGetNamedParameter(m_cgShaderFragment, "uniShininess"); m_cgParamMatDiffuseVector = cgGetNamedParameter(m_cgShaderFragment, "uniMatDiffuse"); m_cgParamMatSpecularVector = cgGetNamedParameter(m_cgShaderFragment, "uniMatSpecular"); m_cgParamSamplerDiffuse = cgGetNamedParameter(m_cgShaderFragment, "uniTexDiffuse"); m_cgParamSamplerSpecular = cgGetNamedParameter(m_cgShaderFragment, "uniTexSpecular"); m_cgParamSamplerOutline = cgGetNamedParameter(m_cgShaderFragment, "uniTexOutline"); m_cgParamComputeOutline = cgGetNamedParameter(m_cgShaderFragment, "uniComputeOutline"); // [rad] Manually assign other (material) related params cgSetParameter1f(m_cgParamShininess, 128.0f); static const float af3ColorDiffuse[3] = {0.8f, 0.8f, 0.8f}; cgSetParameter3fv(m_cgParamMatDiffuseVector, af3ColorDiffuse); static const float af3ColorSpecular[3] = {1.0f, 1.0f, 1.0f}; cgSetParameter3fv(m_cgParamMatSpecularVector, af3ColorSpecular); static const float af3Color[3] = {1.0f, 1.0f, 1.0f}; cgSetParameter3fv(m_cgParamLightColorVector, af3Color); // [rad] Set texture params GenerateTextures(); cgGLSetTextureParameter(m_cgParamSamplerDiffuse, m_glIDTextureDiffuse); cgGLSetTextureParameter(m_cgParamSamplerSpecular, m_glIDTextureSpecular); cgGLSetTextureParameter(m_cgParamSamplerOutline, m_glIDTextureOutline); }
// The same function for texture, also to cgGLEnable void ZZshGLSetTextureParameter(ZZshProgram prog, ZZshParameter param, GLuint texobj, const char* name) { ShaderHandleName = name; cgGLSetTextureParameter(param, texobj); cgGLEnableTextureParameter(param); }
static void gl_cg_set_params(void *data, unsigned width, unsigned height, unsigned tex_width, unsigned tex_height, unsigned out_width, unsigned out_height, unsigned frame_count, const void *_info, const void *_prev_info, const void *_fbo_info, unsigned fbo_info_cnt) { unsigned i; const struct gl_tex_info *info = (const struct gl_tex_info*)_info; const struct gl_tex_info *prev_info = (const struct gl_tex_info*)_prev_info; const struct gl_tex_info *fbo_info = (const struct gl_tex_info*)_fbo_info; cg_shader_data_t *cg = (cg_shader_data_t*)driver.video_shader_data; (void)data; if (!cg || (cg->active_idx == 0) || (cg->active_idx == GL_SHADER_STOCK_BLEND)) return; /* Set frame. */ set_param_2f(cg->prg[cg->active_idx].vid_size_f, width, height); set_param_2f(cg->prg[cg->active_idx].tex_size_f, tex_width, tex_height); set_param_2f(cg->prg[cg->active_idx].out_size_f, out_width, out_height); set_param_1f(cg->prg[cg->active_idx].frame_dir_f, g_extern.frame_is_reverse ? -1.0 : 1.0); set_param_2f(cg->prg[cg->active_idx].vid_size_v, width, height); set_param_2f(cg->prg[cg->active_idx].tex_size_v, tex_width, tex_height); set_param_2f(cg->prg[cg->active_idx].out_size_v, out_width, out_height); set_param_1f(cg->prg[cg->active_idx].frame_dir_v, g_extern.frame_is_reverse ? -1.0 : 1.0); if (cg->prg[cg->active_idx].frame_cnt_f || cg->prg[cg->active_idx].frame_cnt_v) { unsigned modulo = cg->cg_shader->pass[cg->active_idx - 1].frame_count_mod; if (modulo) frame_count %= modulo; set_param_1f(cg->prg[cg->active_idx].frame_cnt_f, (float)frame_count); set_param_1f(cg->prg[cg->active_idx].frame_cnt_v, (float)frame_count); } /* Set orig texture. */ CGparameter param = cg->prg[cg->active_idx].orig.tex; if (param) { cgGLSetTextureParameter(param, info->tex); cgGLEnableTextureParameter(param); } set_param_2f(cg->prg[cg->active_idx].orig.vid_size_v, info->input_size[0], info->input_size[1]); set_param_2f(cg->prg[cg->active_idx].orig.vid_size_f, info->input_size[0], info->input_size[1]); set_param_2f(cg->prg[cg->active_idx].orig.tex_size_v, info->tex_size[0], info->tex_size[1]); set_param_2f(cg->prg[cg->active_idx].orig.tex_size_f, info->tex_size[0], info->tex_size[1]); if (cg->prg[cg->active_idx].orig.coord) { cgGLSetParameterPointer(cg->prg[cg->active_idx].orig.coord, 2, GL_FLOAT, 0, info->coord); cgGLEnableClientState(cg->prg[cg->active_idx].orig.coord); cg->cg_attribs[cg->cg_attrib_idx++] = cg->prg[cg->active_idx].orig.coord; } /* Set prev textures. */ for (i = 0; i < PREV_TEXTURES; i++) { param = cg->prg[cg->active_idx].prev[i].tex; if (param) { cgGLSetTextureParameter(param, prev_info[i].tex); cgGLEnableTextureParameter(param); } set_param_2f(cg->prg[cg->active_idx].prev[i].vid_size_v, prev_info[i].input_size[0], prev_info[i].input_size[1]); set_param_2f(cg->prg[cg->active_idx].prev[i].vid_size_f, prev_info[i].input_size[0], prev_info[i].input_size[1]); set_param_2f(cg->prg[cg->active_idx].prev[i].tex_size_v, prev_info[i].tex_size[0], prev_info[i].tex_size[1]); set_param_2f(cg->prg[cg->active_idx].prev[i].tex_size_f, prev_info[i].tex_size[0], prev_info[i].tex_size[1]); if (cg->prg[cg->active_idx].prev[i].coord) { cgGLSetParameterPointer(cg->prg[cg->active_idx].prev[i].coord, 2, GL_FLOAT, 0, prev_info[i].coord); cgGLEnableClientState(cg->prg[cg->active_idx].prev[i].coord); cg->cg_attribs[cg->cg_attrib_idx++] = cg->prg[cg->active_idx].prev[i].coord; } } /* Set lookup textures. */ for (i = 0; i < cg->cg_shader->luts; i++) { CGparameter fparam = cgGetNamedParameter( cg->prg[cg->active_idx].fprg, cg->cg_shader->lut[i].id); if (fparam) { cgGLSetTextureParameter(fparam, cg->lut_textures[i]); cgGLEnableTextureParameter(fparam); } CGparameter vparam = cgGetNamedParameter( cg->prg[cg->active_idx].vprg, cg->cg_shader->lut[i].id); if (vparam) { cgGLSetTextureParameter(vparam, cg->lut_textures[i]); cgGLEnableTextureParameter(vparam); } } /* Set FBO textures. */ if (cg->active_idx) { for (i = 0; i < fbo_info_cnt; i++) { if (cg->prg[cg->active_idx].fbo[i].tex) { cgGLSetTextureParameter( cg->prg[cg->active_idx].fbo[i].tex, fbo_info[i].tex); cgGLEnableTextureParameter(cg->prg[cg->active_idx].fbo[i].tex); } set_param_2f(cg->prg[cg->active_idx].fbo[i].vid_size_v, fbo_info[i].input_size[0], fbo_info[i].input_size[1]); set_param_2f(cg->prg[cg->active_idx].fbo[i].vid_size_f, fbo_info[i].input_size[0], fbo_info[i].input_size[1]); set_param_2f(cg->prg[cg->active_idx].fbo[i].tex_size_v, fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]); set_param_2f(cg->prg[cg->active_idx].fbo[i].tex_size_f, fbo_info[i].tex_size[0], fbo_info[i].tex_size[1]); if (cg->prg[cg->active_idx].fbo[i].coord) { cgGLSetParameterPointer(cg->prg[cg->active_idx].fbo[i].coord, 2, GL_FLOAT, 0, fbo_info[i].coord); cgGLEnableClientState(cg->prg[cg->active_idx].fbo[i].coord); cg->cg_attribs[cg->cg_attrib_idx++] = cg->prg[cg->active_idx].fbo[i].coord; } } } /* #pragma parameters. */ for (i = 0; i < cg->cg_shader->num_parameters; i++) { CGparameter param_v = cgGetNamedParameter( cg->prg[cg->active_idx].vprg, cg->cg_shader->parameters[i].id); CGparameter param_f = cgGetNamedParameter( cg->prg[cg->active_idx].fprg, cg->cg_shader->parameters[i].id); set_param_1f(param_v, cg->cg_shader->parameters[i].current); set_param_1f(param_f, cg->cg_shader->parameters[i].current); } /* Set state parameters. */ if (cg->state_tracker) { /* Only query uniforms in first pass. */ static struct state_tracker_uniform tracker_info[MAX_VARIABLES]; static unsigned cnt = 0; if (cg->active_idx == 1) cnt = state_get_uniform(cg->state_tracker, tracker_info, MAX_VARIABLES, frame_count); for (i = 0; i < cnt; i++) { CGparameter param_v = cgGetNamedParameter( cg->prg[cg->active_idx].vprg, tracker_info[i].id); CGparameter param_f = cgGetNamedParameter( cg->prg[cg->active_idx].fprg, tracker_info[i].id); set_param_1f(param_v, tracker_info[i].value); set_param_1f(param_f, tracker_info[i].value); } } }
void SetupFragmentProgramParameters(FRAGMENTSHADER* pf, int context, int type) { // uniform parameters ZZshParameter p; p = cgGetNamedParameter(pf->prog, "g_fFogColor"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { cgConnectParameter(g_fparamFogColor, p); } SET_UNIFORMPARAM(sOneColor, "g_fOneColor"); SET_UNIFORMPARAM(sBitBltZ, "g_fBitBltZ"); SET_UNIFORMPARAM(sInvTexDims, "g_fInvTexDims"); SET_UNIFORMPARAM(fTexAlpha2, "fTexAlpha2"); SET_UNIFORMPARAM(fTexOffset, "g_fTexOffset"); SET_UNIFORMPARAM(fTexDims, "g_fTexDims"); SET_UNIFORMPARAM(fTexBlock, "g_fTexBlock"); SET_UNIFORMPARAM(fClampExts, "g_fClampExts"); SET_UNIFORMPARAM(fTexWrapMode, "TexWrapMode"); SET_UNIFORMPARAM(fRealTexDims, "g_fRealTexDims"); SET_UNIFORMPARAM(fTestBlack, "g_fTestBlack"); SET_UNIFORMPARAM(fPageOffset, "g_fPageOffset"); SET_UNIFORMPARAM(fTexAlpha, "fTexAlpha"); // textures p = cgGetNamedParameter(pf->prog, "g_sBlocks"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { cgGLSetTextureParameter(p, ptexBlocks); cgGLEnableTextureParameter(p); } // cg parameter usage is wrong, so do it manually if( type == 3 ) { p = cgGetNamedParameter(pf->prog, "g_sConv16to32"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { cgGLSetTextureParameter(p, ptexConv16to32); cgGLEnableTextureParameter(p); } } else if( type == 4 ) { p = cgGetNamedParameter(pf->prog, "g_sConv32to16"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { cgGLSetTextureParameter(p, ptexConv32to16); cgGLEnableTextureParameter(p); } } else { p = cgGetNamedParameter(pf->prog, "g_sBilinearBlocks"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { cgGLSetTextureParameter(p, ptexBilinearBlocks); cgGLEnableTextureParameter(p); } } p = cgGetNamedParameter(pf->prog, "g_sMemory"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { //cgGLEnableTextureParameter(p); pf->sMemory = p; } p = cgGetNamedParameter(pf->prog, "g_sSrcFinal"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { //cgGLEnableTextureParameter(p); pf->sFinal = p; } p = cgGetNamedParameter(pf->prog, "g_sBitwiseANDX"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { //cgGLEnableTextureParameter(p); pf->sBitwiseANDX = p; } p = cgGetNamedParameter(pf->prog, "g_sBitwiseANDY"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { //cgGLEnableTextureParameter(p); pf->sBitwiseANDY = p; } p = cgGetNamedParameter(pf->prog, "g_sCLUT"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { //cgGLEnableTextureParameter(p); pf->sCLUT = p; } p = cgGetNamedParameter(pf->prog, "g_sInterlace"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { //cgGLEnableTextureParameter(p); pf->sInterlace = p; } // set global shader constants p = cgGetNamedParameter(pf->prog, "g_fExactColor"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) { cgGLSetParameter4fv(p, float4(0.5f, (conf.settings().exact_color)?0.9f/256.0f:0.5f/256.0f, 0,1/255.0f)); } p = cgGetNamedParameter(pf->prog, "g_fBilinear"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) cgGLSetParameter4fv(p, float4(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f )); p = cgGetNamedParameter(pf->prog, "g_fZBias"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) cgGLSetParameter4fv(p, float4(1.0f/256.0f, 1.0004f, 1, 0.5f)); p = cgGetNamedParameter(pf->prog, "g_fc0"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) cgGLSetParameter4fv(p, float4(0,1, 0.001f, 0.5f)); p = cgGetNamedParameter(pf->prog, "g_fMult"); if( p != NULL && cgIsParameterUsed(p, pf->prog) == CG_TRUE ) cgGLSetParameter4fv(p, float4(1/1024.0f, 0.2f/1024.0f, 1/128.0f, 1/512.0f)); }