C++ cgGetNamedParameter函数代码示例

void board_update()
{
  cgGLEnableProfile(cg__fragmentProfile);
  cgGLBindProgram(cg__fragmentProgram);

  // transfer data to texture
    texture_load_array(board__computeTexture, GL_TEXTURE_RECTANGLE_ARB, board__width, board__width, board__data);

  // perform computation
    CGparameter textureCg = cgGetNamedParameter(cg__fragmentProgram, "aBoard");
    cgGLSetTextureParameter(textureCg, board__computeTexture);
    cgGLEnableTextureParameter(textureCg);

    CGparameter widthCg = cgGetNamedParameter(cg__fragmentProgram, "aWidth");
    cgSetParameter1f(widthCg, board__width);

    board_draw(); // GPGPU CONCEPT 4: Viewport-Sized Quad = Data Stream Generator.

    cgGLDisableTextureParameter(textureCg);
    cgGLDisableProfile(cg__fragmentProfile);

  // Read back the results
    glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
    // The glReadBuffer function selects a color buffer source for pixels.
    // void glReadBuffer(GLenum mode); mode is a color buffer

    // The glReadPixels function reads a block of pixels from the framebuffer.
    glReadPixels(
      0, 0,           // GLint x, y The window coordinates of the first pixel that is read from the framebuffer. This location is the lower-left corner of a rectangular block of pixels
      board__width,   // GLsizei width
      board__width,   // GLsizei height
      GL_RGBA,        // GLenum format
      GL_FLOAT,       // GLenum type
      board__data);   // GLvoid *pixels
}

void Shader::Apply()
{
  if (vertex_program)
    {
      cgGLSetStateMatrixParameter(cgGetNamedParameter(vertex_program, "ModelViewProj"), CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
      cgGLBindProgram(vertex_program);
      cgGLEnableProfile(vertex_profile);
    }
  else
    {
      cgGLDisableProfile(vertex_profile);
    }
  if (fragment_program)
    {
      GLint handle;
      CGparameter param;

      glGetIntegerv(GL_TEXTURE_BINDING_2D, &handle);
      param = cgGetNamedParameter(fragment_program, "Decal");
      cgGLSetTextureParameter(param, handle);
      cgGLEnableTextureParameter(param);

      cgGLBindProgram(fragment_program);
      cgGLEnableProfile(fragment_profile);
    }
  else
    {
      cgGLDisableProfile(fragment_profile);
    }
}

int32_t PS3Graphics::LoadFragmentShader(std::string shaderPath)
{
	// store the current path
	_curFragmentShaderPath = shaderPath;

	_vertexProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_VP_RSX, shaderPath.c_str(), "main_vertex");
	_fragmentProgram = LoadShaderFromSource(_cgContext, CG_PROFILE_SCE_FP_RSX, shaderPath.c_str(), "main_fragment");

	// bind and enable the vertex and fragment programs
	cgGLEnableProfile(CG_PROFILE_SCE_VP_RSX);
	cgGLEnableProfile(CG_PROFILE_SCE_FP_RSX);
	cgGLBindProgram(_vertexProgram);
	cgGLBindProgram(_fragmentProgram);

	// acquire mvp param from vertex shader
	_cgpModelViewProj = cgGetNamedParameter(_vertexProgram, "modelViewProj");

	_cgpVideoSize = cgGetNamedParameter(_fragmentProgram, "IN.video_size");
	_cgpTextureSize = cgGetNamedParameter(_fragmentProgram, "IN.texture_size");
	_cgpOutputSize = cgGetNamedParameter(_fragmentProgram, "IN.output_size");

	if (active_shader)
		lib_free(active_shader);

	active_shader = util_concat(shaderPath.c_str(), NULL);

	return CELL_OK;
}

Cluster::Cluster (const btVector3& origin, QScriptProgram& shellProgram,
                  QObject* parent) :
    QObject(parent),
    d(new Private(origin, shellProgram, this))
{
    setup();

    CGprogram prog = scene->shader("fyreworks")->program();
    d->shader.v0     = cgGetNamedParameter(prog, "v0");
    d->shader.t      = cgGetNamedParameter(prog, "t");
    d->shader.nt     = cgGetNamedParameter(prog, "nt");
    d->shader.origin = cgGetNamedParameter(prog, "origin");
    d->shader.eye    = cgGetNamedParameter(prog, "eye");

    // color
    d->colorTable.insert("red"           , btVector3(1.0f , 0.0f , 0.0f ));
    d->colorTable.insert("orange"        , btVector3(1.0f , 0.6f , 0.0f ));
    d->colorTable.insert("gold"          , btVector3(1.0f , 0.84f, 0.0f ));
    d->colorTable.insert("yellow"        , btVector3(1.0f , 1.0f , 0.0f ));
    d->colorTable.insert("green"         , btVector3(0.0f , 1.0f , 0.0f ));
    d->colorTable.insert("blue"          , btVector3(0.0f , 0.0f , 1.0f ));
    d->colorTable.insert("purple"        , btVector3(0.50f, 0.50f, 0.0f ));
    d->colorTable.insert("silver"        , btVector3(0.75f, 0.75f, 0.75f));

    QList<btVector3> colors (d->colorTable.values());
    d->color = colors[floor(randf(colors.size()))];

    // sound
    soundEngine->soundSystem()->playSound(
        FMOD_CHANNEL_REUSE, soundEngine->sound("explosion"), false, d->channel);
    d->channel->set3DAttributes(d->origin);
}

static void renderchain_bind_luts(cg_renderchain_t *chain,
      Pass *pass)
{
   unsigned i, index;

   for (i = 0; i < chain->luts.size(); i++)
   {
      CGparameter vparam;
      CGparameter fparam = cgGetNamedParameter(pass->fPrg, chain->luts[i].id);
      int bound_index    = -1;

      if (fparam)
      {
         index           = cgGetParameterResourceIndex(fparam);
         bound_index     = index;

         cg_d3d9_renderchain_add_lut(chain, index, i);
      }

      vparam             = cgGetNamedParameter(pass->vPrg, chain->luts[i].id);

      if (vparam)
      {
         index           = cgGetParameterResourceIndex(vparam);
         if (index != (unsigned)bound_index)
            cg_d3d9_renderchain_add_lut(chain, index, i);
      }
   }
}

void cgtk::raycasting_pass()
{
	disable_renderbuffers();

	//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_RECTANGLE_ARB,final_image,0);
	//glClearColor(0,0,0,0);
	//glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
	cgGLEnableProfile(vertexProfile);
	cgGLEnableProfile(fragmentProfile);
	cgGLBindProgram(vertex_main);
	cgGLBindProgram(fragment_main);
	cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"stepsize"),stepsize);
	cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"width"),WINDOW_SIZE_W);
	cgGLSetParameter1f(cgGetNamedParameter(fragment_main,"heigth"),WINDOW_SIZE_H);
	set_tex_param("tex",backface_buffer,fragment_main,param1);
	set_tex_param("volume_tex",volume_texture,fragment_main,param2);
	glEnable(GL_BLEND);
	glEnable(GL_CULL_FACE);
	glCullFace(GL_BACK);
	//drawQuads(1,1,1,b);
	drawBd();
	cgGLDisableProfile(vertexProfile);
	cgGLDisableProfile(fragmentProfile);
	glDisable(GL_CULL_FACE);
	glDisable(GL_BLEND);
}

static void set_program_base_attrib(unsigned i)
{
   CGparameter param = cgGetFirstParameter(prg[i].vprg, CG_PROGRAM);
   for (; param; param = cgGetNextParameter(param))
   {
      if (cgGetParameterDirection(param) != CG_IN || cgGetParameterVariability(param) != CG_VARYING)
         continue;

      const char *semantic = cgGetParameterSemantic(param);
      if (!semantic)
         continue;

      RARCH_LOG("CG: Found semantic \"%s\" in prog #%u.\n", semantic, i);

      if (strcmp(semantic, "TEXCOORD") == 0 || strcmp(semantic, "TEXCOORD0") == 0)
         prg[i].tex = param;
      else if (strcmp(semantic, "COLOR") == 0 || strcmp(semantic, "COLOR0") == 0)
         prg[i].color = param;
      else if (strcmp(semantic, "POSITION") == 0)
         prg[i].vertex = param;
      else if (strcmp(semantic, "TEXCOORD1") == 0)
         prg[i].lut_tex = param;
   }

   if (!prg[i].tex)
      prg[i].tex = cgGetNamedParameter(prg[i].vprg, "IN.tex_coord");
   if (!prg[i].color)
      prg[i].color = cgGetNamedParameter(prg[i].vprg, "IN.color");
   if (!prg[i].vertex)
      prg[i].vertex = cgGetNamedParameter(prg[i].vprg, "IN.vertex_coord");
   if (!prg[i].lut_tex)
      prg[i].lut_tex = cgGetNamedParameter(prg[i].vprg, "IN.lut_tex_coord");
}

void RenderChain::bind_orig(Pass &pass)
{
   D3DXVECTOR2 video_size, texture_size;
   video_size.x = passes[0].last_width;
   video_size.y = passes[0].last_height;
   texture_size.x = passes[0].info.tex_w;
   texture_size.y = passes[0].info.tex_h;

   set_cg_param(pass.vPrg, "ORIG.video_size", video_size);
   set_cg_param(pass.fPrg, "ORIG.video_size", video_size);
   set_cg_param(pass.vPrg, "ORIG.texture_size", texture_size);
   set_cg_param(pass.fPrg, "ORIG.texture_size", texture_size);

   CGparameter param = cgGetNamedParameter(pass.fPrg, "ORIG.texture");
   if (param)
   {
      unsigned index = cgGetParameterResourceIndex(param);
      dev->SetTexture(index, passes[0].tex);
      dev->SetSamplerState(index, D3DSAMP_MAGFILTER,
            translate_filter(passes[0].info.pass->filter));
      dev->SetSamplerState(index, D3DSAMP_MINFILTER,
            translate_filter(passes[0].info.pass->filter));
      dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
      dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
      bound_tex.push_back(index);
   }

   param = cgGetNamedParameter(pass.vPrg, "ORIG.tex_coord");
   if (param)
   {
      unsigned index = pass.attrib_map[cgGetParameterResourceIndex(param)];
      dev->SetStreamSource(index, passes[0].vertex_buf, 0, sizeof(Vertex));
      bound_vert.push_back(index);
   }
}

void RenderChain::bind_pass(Pass &pass, unsigned pass_index)
{
   // We only bother binding passes which are two indices behind.
   if (pass_index < 3)
      return;

   for (unsigned i = 1; i < pass_index - 1; i++)
   {
      char pass_base[64];
      snprintf(pass_base, sizeof(pass_base), "PASS%u.", i);

      std::string attr_texture = pass_base;
      attr_texture += "texture";
      std::string attr_video_size = pass_base;
      attr_video_size += "video_size";
      std::string attr_texture_size = pass_base;
      attr_texture_size += "texture_size";
      std::string attr_tex_coord = pass_base;
      attr_tex_coord += "tex_coord";

      D3DXVECTOR2 video_size, texture_size;
      video_size.x = passes[i].last_width;
      video_size.y = passes[i].last_height;
      texture_size.x = passes[i].info.tex_w;
      texture_size.y = passes[i].info.tex_h;

      set_cg_param(pass.vPrg, attr_video_size.c_str(), video_size);
      set_cg_param(pass.fPrg, attr_video_size.c_str(), video_size);
      set_cg_param(pass.vPrg, attr_texture_size.c_str(), texture_size);
      set_cg_param(pass.fPrg, attr_texture_size.c_str(), texture_size);

      CGparameter param = cgGetNamedParameter(pass.fPrg, attr_texture.c_str());
      if (param)
      {
         unsigned index = cgGetParameterResourceIndex(param);
         bound_tex.push_back(index);

         dev->SetTexture(index, passes[i].tex);
         dev->SetSamplerState(index, D3DSAMP_MAGFILTER,
               translate_filter(passes[i].info.pass->filter));
         dev->SetSamplerState(index, D3DSAMP_MINFILTER,
               translate_filter(passes[i].info.pass->filter));
         dev->SetSamplerState(index, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
         dev->SetSamplerState(index, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
      }

      param = cgGetNamedParameter(pass.vPrg, attr_tex_coord.c_str());
      if (param)
      {
         unsigned index = pass.attrib_map[cgGetParameterResourceIndex(param)];
         dev->SetStreamSource(index, passes[i].vertex_buf, 0, sizeof(Vertex));
         bound_vert.push_back(index);
      }
   }
}

void ParticleShaderDiskDevelop::bindCGParametersFragment()
{

	// Bind the first fragment program parameters
	lightPositionEC = cgGetNamedParameter(fProgram,"lightPositionEC");
	diffuseColor = cgGetNamedParameter(fProgram,"diffuseColor");
	diskRadius = cgGetNamedParameter(fProgram,"diskRadius");
	
	if (!lightPositionEC || !diffuseColor || !diskRadius)
		exit(-1);
}

bool ShaderTextureInterface::InitProgram() {
	if (!loadVertexProgram("CG/shaderTexture.cg", "VertexMain")) return false;

	if (!loadFragmentProgram("CG/shaderTexture.cg", "FragmentMain")) return false;

	// build some parameters by name such that we can set them later...
	vertexModelViewProj = cgGetNamedParameter(vertexProgram, "modelViewProj");
	fragmentTex = cgGetNamedParameter(fragmentProgram, "tex");

	return true;
}

static void gl_cg_set_program_base_attrib(void *data, unsigned i)
{
   cg_shader_data_t *cg = (cg_shader_data_t*)data;
   CGparameter         param = cgGetFirstParameter(
         cg->prg[i].vprg, CG_PROGRAM);

   for (; param; param = cgGetNextParameter(param))
   {
      uint32_t semantic_hash;
      const char *semantic = NULL;
      if (cgGetParameterDirection(param) != CG_IN 
            || cgGetParameterVariability(param) != CG_VARYING)
         continue;

      semantic = cgGetParameterSemantic(param);
      if (!semantic)
         continue;

      RARCH_LOG("CG: Found semantic \"%s\" in prog #%u.\n", semantic, i);

      semantic_hash = djb2_calculate(semantic);

      switch (semantic_hash)
      {
         case SEMANTIC_TEXCOORD:
         case SEMANTIC_TEXCOORD0:
            cg->prg[i].tex     = param;
            break;
         case SEMANTIC_COLOR:
         case SEMANTIC_COLOR0:
            cg->prg[i].color   = param;
            break;
         case SEMANTIC_POSITION:
            cg->prg[i].vertex  = param;
            break;
         case SEMANTIC_TEXCOORD1:
            cg->prg[i].lut_tex = param;
            break;
      }
   }

   if (!cg->prg[i].tex)
      cg->prg[i].tex     = cgGetNamedParameter(cg->prg[i].vprg, "IN.tex_coord");
   if (!cg->prg[i].color)
      cg->prg[i].color   = cgGetNamedParameter(cg->prg[i].vprg, "IN.color");
   if (!cg->prg[i].vertex)
      cg->prg[i].vertex  = cgGetNamedParameter(cg->prg[i].vprg, "IN.vertex_coord");
   if (!cg->prg[i].lut_tex)
      cg->prg[i].lut_tex = cgGetNamedParameter(cg->prg[i].vprg, "IN.lut_tex_coord");
}

void CgInit(){
	CgCtxt = cgCreateContext();
	CgProg = cgCreateProgramFromFile( CgCtxt, CG_SOURCE, "shader.cg",
											CgProf, NULL, NULL );
	if( CgProg != NULL ){
		
		cgGLLoadProgram( CgProg );
		
		ModelViewProjParam = cgGetNamedParameter( CgProg, "ModelViewProj" );
		
		LightAngle = cgGetNamedParameter( CgProg, "LA" );
		
		LightY = cgGetNamedParameter( CgProg, "LY" );
	}
}

    //
    // GetBindableUniform
    //
    void CCgShadingProgram::GetBindableUniform( 
                                               const string& Name, 
                                               Ptr<IBindableUniform> *Uniform 
                                               ) const
    {
        if (!m_Extensions->EXT_bindable_uniform)
            throw CExtensionException( this, "::GetBindableUniform()", "GL_EXT_bindable_uniform" );
            
        map<string, Ptr<IBindableUniform> >::const_iterator i = m_BindableUniformCache.find( Name );
        if (i != m_BindableUniformCache.end())
        {
            *Uniform = i->second;
            return;
        }

        CGparameter Parameter = cgGetNamedParameter( m_Program, Name.c_str() );
        if (!Parameter)
        {
            *Uniform = NULL;
            throw Sys::CException( this, "::GetBindableUniform() : Failed to get a program parameter by name \"%s\".", Name.c_str() );
        }

        *Uniform = new CCgBindableUniform( Name, m_Program, Parameter );
        m_BindableUniformCache[ Name ] = *Uniform;
    }

void
Scene::loadShader() 
{
	std::string sourcePtr = read("vshader.cg");

	auto optimal = cgD3D11GetOptimalOptions(mCgVertexShaderProfile);

	mVertexShaderId = cgCreateProgram(mCgContext, CG_SOURCE, sourcePtr.c_str(), mCgVertexShaderProfile, "main", optimal);

	if(mVertexShaderId != nullptr)
	{
		optimal = cgD3D11GetOptimalOptions(mCgFragmentShaderProfile);

		HRESULT res = cgD3D11LoadProgram(mVertexShaderId, NULL);

		CGerror error;
		const char *errorString = cgGetLastErrorString(&error);
		sourcePtr = read("fshader.cg");
		mFragmentShaderId = cgCreateProgram(mCgContext, CG_SOURCE, sourcePtr.c_str(), mCgFragmentShaderProfile, "main", optimal);
		errorString = cgGetLastErrorString(&error);
		res = cgD3D11LoadProgram(mFragmentShaderId, NULL);
	}

	// here the uniform can be set 
	CGparameter location = cgGetNamedParameter(mVertexShaderId, "ambient");
	checkForCgError("could not get uniform color location", mCgContext, false);
	cgSetParameter4fv(location, glm::value_ptr(glm::vec4(1.0,1.0,1.0,1.0)));
	checkForCgError("could not set uniform color", mCgContext, false);

	bindShader(mVertexShaderId, mFragmentShaderId);

}