ps1.0_program.cpp

赫赫大名的 OGRE 游戏引擎

				if(instr[2+instr_base] != "r0.a" && instr[2+instr_base] != "r0.w")
				{} // bad
				if(mask == GL_RGBA || mask == GL_RGB)
				{
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_C_NV, b.reg, b.map, b.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_TRUE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}

				if(mask == GL_RGBA || mask == GL_ALPHA)
				{
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_C_NV, b.reg, b.map, b.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_TRUE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
			}
			else if(op == "dp3")
			{
				src a(instr[2+instr_base],combiner);
				src b(instr[3+instr_base],combiner);

				if(mask == GL_RGBA || mask == GL_RGB)
				{
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);
					glCombinerOutputNV_ptr(C, GL_RGB, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
						GL_TRUE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					// ooh.. what to do here?
				}

				if(mask == GL_RGBA || mask == GL_ALPHA)
				{
					// todo -- make next ref to dst.a actually ref dst.b since combiners can't write dp3 to the alpha channel
					// Done by Ashu: Put this register in the alphaBlueRegister set. 
					isAlphaBlue = true;
					ps10::alphaBlueRegisters.insert(dst.c_str());
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
			}
			else if(op == "lrp")
			{
				src a(instr[2+instr_base],combiner);
				src b(instr[3+instr_base],combiner);
				src c(instr[4+instr_base],combiner);

				if(mask == GL_RGBA || mask == GL_RGB)
				{
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, GL_UNSIGNED_IDENTITY_NV, a.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_C_NV, a.reg, GL_UNSIGNED_INVERT_NV, a.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_D_NV, c.reg, c.map, c.comp);
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}

				if(mask == GL_RGBA || mask == GL_ALPHA)
				{
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, GL_UNSIGNED_IDENTITY_NV, a.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_B_NV, b.reg, b.map, b.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_C_NV, a.reg, GL_UNSIGNED_INVERT_NV, a.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_D_NV, c.reg, c.map, c.alphaComp);
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
			}
			else if(op == "mad")
			{
				src a(instr[2+instr_base],combiner);
				src b(instr[3+instr_base],combiner);
				src c(instr[4+instr_base],combiner);

				if(mask == GL_RGBA || mask == GL_RGB)
				{
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);					
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_D_NV, c.reg, c.map, c.comp);
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}

				if(mask == GL_RGBA || mask == GL_ALPHA)
				{
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_B_NV, b.reg, b.map, b.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_D_NV, c.reg, c.map, c.alphaComp);
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
			}
			else if(op == "mov")
			{
				src a(instr[2+instr_base],combiner);

				if(mask == GL_RGBA || mask == GL_RGB)
				{
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
					glCombinerOutputNV_ptr(C, GL_RGB, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}

				if(mask == GL_RGBA || mask == GL_ALPHA)
				{
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
					glCombinerOutputNV_ptr(C, GL_ALPHA, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
			}
			else if(op == "mul")
			{
				src a(instr[2+instr_base],combiner);
				src b(instr[3+instr_base],combiner);

				if(mask == GL_RGBA || mask == GL_RGB)
				{
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
					glCombinerInputNV_ptr(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);
					glCombinerOutputNV_ptr(C, GL_RGB, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}

				if(mask == GL_RGBA || mask == GL_ALPHA)
				{
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
					glCombinerInputNV_ptr(C, GL_ALPHA, GL_VARIABLE_B_NV, b.reg, b.map, b.alphaComp);
					glCombinerOutputNV_ptr(C, GL_ALPHA, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
				else if (!paired_instr)
				{
					glCombinerOutputNV_ptr(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
									   GL_FALSE, GL_FALSE, GL_FALSE);
				}
			}
            // combiner++;
			if (!isAlphaBlue)
				RemoveFromAlphaBlue(dst);
		}

		int combiner;
	};


}

void ps10::SetFinalCombinerStage()
{
	glFinalCombinerInputNV_ptr(GL_VARIABLE_A_NV,GL_FOG,GL_UNSIGNED_IDENTITY_NV,GL_ALPHA);
	glFinalCombinerInputNV_ptr(GL_VARIABLE_B_NV,GL_SPARE0_NV,
			GL_UNSIGNED_IDENTITY_NV,GL_RGB);
	glFinalCombinerInputNV_ptr(GL_VARIABLE_C_NV,GL_FOG,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
	glFinalCombinerInputNV_ptr(GL_VARIABLE_D_NV,GL_ZERO,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
	glFinalCombinerInputNV_ptr(GL_VARIABLE_E_NV,GL_ZERO,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
	glFinalCombinerInputNV_ptr(GL_VARIABLE_F_NV,GL_ZERO,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
	std::set<const char*, ltstr>::iterator iter = ps10::alphaBlueRegisters.find("r0");
	GLenum alphaComp = GL_ALPHA;
	if (iter != ps10::alphaBlueRegisters.end())
		alphaComp = GL_BLUE;
	glFinalCombinerInputNV_ptr(GL_VARIABLE_G_NV,GL_SPARE0_NV,GL_UNSIGNED_IDENTITY_NV,alphaComp);
	// We can now clear alphaBlueRegisters for the next go around
	alphaBlueRegisters.clear();
}

void ps10::invoke(vector<constdef> * c,
	              list<vector<string> > * a,
				  list<vector<string> > * b)
{
	const_to_combiner_reg_mapping_count = 0; // Hansong


	glEnable(GL_PER_STAGE_CONSTANTS_NV); // should we require apps to do this?
	if(c)
		for_each(c->begin(), c->end(), set_constants());
	if(a)
		for_each(a->begin(), a->end(), set_texture_shaders(c));
	glActiveTextureARB_ptr( GL_TEXTURE0_ARB );
    int numCombiners = 0;
    list<vector<string> >::iterator it = b->begin();
    for(; it!=b->end(); ++it) {
      if ( (*it)[0] != "+" )
        numCombiners++;
    }
    glCombinerParameteriNV_ptr(GL_NUM_GENERAL_COMBINERS_NV, numCombiners);
	if(b)
		for_each(b->begin(), b->end(), set_register_combiners());
	SetFinalCombinerStage();
	// We can clear the stageToTarget map now.
	stageToTargetMap.clear();
}

// simple identification - just look for magic substring
//  -- easy to break...
bool is_ps10(const char * s)
{
	if(strstr(s, "ps.1.0"))
		return true;
	if(strstr(s, "Ps.1.0"))
		return true;
	if(strstr(s, "ps.1.1"))
		return true;
	if(strstr(s, "Ps.1.1"))
		return true;
	return false;
}

bool ps10::init_extensions()
{
	// register combiners	
	static bool rcinit = false;
	if(rcinit == false)
	{
      /*
		if(! glh_init_extensions("GL_NV_register_combiners"))
		{
			errors.set("unable to initialize GL_NV_register_combiners\n");
			return false;
		}
		else
		{
        */
			rcinit = true;
            /*
		}
        */
	}

	// register combiners 2
	static bool rc2init = false;
	if(rc2init == false)
	{
      /*
		if( ! glh_init_extensions("GL_NV_register_combiners2"))
		{
			errors.set("unable to initialize GL_NV_register_combiners2\n");
			return false;
		}
		else
		{
        */
			rc2init = true;
            /*
		}
        */
	}
	
	static bool tsinit = 0;	
	if (tsinit == false )
	{
      /*
		if(! glh_init_extensions( "GL_NV_texture_shader " "GL_ARB_multitexture " ))
		{
			errors.set("unable to initialize GL_NV_texture_shader\n");
			return false;
		}
		else
		{
        */
			tsinit = true;
            /*
		}
        */
	}
	constToStageAndConstMap.clear();
	constToStageArray.clear();
	stageToConstMap.clear();
	line_number = 1;
	return true;
}

const int* ps10_get_info(int* pcount)
{
	if (pcount)
		*pcount = constToStageArray.size();
	return &(constToStageArray[0]);
}