Ejemplo n.º 1
0
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;
    }
}
Ejemplo n.º 2
0
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);
    }
}
Ejemplo n.º 3
0
    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());
    }
Ejemplo n.º 4
0
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
}
Ejemplo n.º 5
0
 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);
 }
Ejemplo n.º 6
0
/**********************
* 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
}
Ejemplo n.º 7
0
	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);
		}
	}
Ejemplo n.º 8
0
void Cg::SetTextureParameter(CGparameter decal,int texname){
	if (decal != NULL)
		cgGLSetTextureParameter(decal,texname);
	else
	{
		cout<<"CGparameter is null"<<endl;
		abort();
	}
	CheckCgError();
}
Ejemplo n.º 9
0
 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);
    }
}
Ejemplo n.º 11
0
 //
 // 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
 */
 }
Ejemplo n.º 12
0
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
}
Ejemplo n.º 13
0
	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);
		}
	}
Ejemplo n.º 14
0
	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);
	}
Ejemplo n.º 15
0
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);
}
Ejemplo n.º 17
0
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");
}
Ejemplo n.º 18
0
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();
}
Ejemplo n.º 19
0
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 );
}
Ejemplo n.º 20
0
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);
      }
   }
}
Ejemplo n.º 21
0
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]);
}
Ejemplo n.º 23
0
void Effect::setTexture( const char *_name, GLuint _texture ) {
  CGparameter texture = cgGetNamedEffectParameter( effect, _name );
  cgGLSetTextureParameter( texture, _texture );
}
Ejemplo n.º 24
0
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);
}
Ejemplo n.º 25
0
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);
      }
   }
}
Ejemplo n.º 26
0
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);	
}
Ejemplo n.º 27
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);
		
	}
Ejemplo n.º 28
0
// 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);
}
Ejemplo n.º 29
0
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);
      }
   }
}
Ejemplo n.º 30
0
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));
}