bool
GLExtensions::init_gl_nv_fragment_program_option()
{
#ifdef GL_NV_fragment_program_option
if (is_extension_supported("GL_NV_fragment_program_option"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_fragment_program_option is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_fragment_program_option is NOT supported by hardware!");
return false;
}
#else // GL_NV_fragment_program_option
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_NV_fragment_program_option is not defined in glext.h!");
return false;
#endif // GL_NV_fragment_program_option
}
void
FFSTexture::get_ffs_data_file ()
{
str_ptr str;
// Get the style file
str = Config::JOT_ROOT() + location;
_data_file = str;
fstream fin;
fin.open(**(str),ios::in);
if (!fin){
err_mesg(ERR_LEV_ERROR, "FFSTexture - Could not find the file %s", **str);
//XXX - TO DO : Load some default values....
} else {
STDdstream s(&fin);
s >> str;
if (str != FFSTexture::static_name())
err_mesg(ERR_LEV_ERROR, "FFSTexture - No FFSTexture found in the file");
else {
decode(s);
}
}
}
bool
GLExtensions::init_gl_arb_fragment_shader()
{
#ifdef GL_ARB_fragment_shader
if (is_extension_supported("GL_ARB_fragment_shader") && init_gl_arb_shader_objects())
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_shader is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_shader is NOT supported by hardware!");
return false;
}
#else
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_fragment_shader is not defined in glext.h!");
return false;
#endif
}
bool
GLExtensions::init_gl_arb_fragment_program()
{
if (Config::get_var_bool("NO_GL_ARB_fragment_program",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_fragment_program - Just saying no!");
return false;
}
#ifdef GL_ARB_fragment_program
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_program is defined in glext.h!");
if (is_extension_supported("GL_ARB_fragment_program"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_program is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_fragment_program is NOT supported by hardware!");
return false;
}
#else
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_fragment_program is not defined in glext.h!");
return false;
#endif
}
bool
GLExtensions::init_gl_ati_fragment_shader()
{
if (Config::get_var_bool("NO_GL_ATI_fragment_shader",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ATI_fragment_shader - Just saying no!");
return false;
}
#ifdef GL_ATI_fragment_shader
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ATI_fragment_shader is defined in glext.h!");
if (is_extension_supported("GL_ATI_fragment_shader"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ATI_fragment_shader is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ATI_fragment_shader is NOT supported by hardware!");
return false;
}
#else //GL_ATI_fragment_shader
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ATI_fragment_shader is not defined in glext.h!");
return false;
#endif //GL_ATI_fragment_shader
}
bool
GLExtensions::init_gl_arb_multitexture()
{
if (Config::get_var_bool("NO_GL_ARB_multitexture",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_multitexture - Just saying no!");
return false;
}
#ifdef GL_ARB_multitexture
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_multitexture is defined in glext.h!");
if (is_extension_supported("GL_ARB_multitexture"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_multitexture is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_ARB_multitexture is NOT supported by hardware!");
return false;
}
#else //GL_ARB_multitexture
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_ARB_multitexture is not defined in glext.h!");
return false;
#endif //GL_ARB_multitexture
}
bool
GLExtensions::init_gl_nv_register_combiners()
{
if (Config::get_var_bool("NO_GL_NV_register_combiners",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_NV_register_combiners - Just saying no!");
return false;
}
#ifdef GL_NV_register_combiners
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_register_combiners is defined in glext.h!");
if (is_extension_supported("GL_NV_register_combiners"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_register_combiners is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_NV_register_combiners is NOT supported by hardware!");
return false;
}
#else //GL_NV_register_combiners
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_NV_register_combiners is not defined in glext.h!");
return false;
#endif //GL_NV_register_combiners
}
bool
GLExtensions::init_gl_ext_compiled_vertex_array()
{
if (Config::get_var_bool("NO_GL_EXT_compiled_vertex_array",false,true))
{
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_EXT_compiled_vertex_array - Just saying no!");
return false;
}
#ifdef GL_EXT_compiled_vertex_array
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_EXT_compiled_vertex_array is defined in glext.h!");
if (is_extension_supported("GL_EXT_compiled_vertex_array"))
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_EXT_compiled_vertex_array is supported by hardware!");
return true;
}
else
{
err_mesg(ERR_LEV_INFO, "GLExtensions: GL_EXT_compiled_vertex_array is NOT supported by hardware!");
return false;
}
#else //GL_EXT_compiled_vertex_array
err_mesg(ERR_LEV_WARN, "GLExtensions: GL_EXT_compiled_vertex_array is not defined in glext.h!");
return false;
#endif //GL_EXT_compiled_vertex_array
}
/////////////////////////////////////
// init()
/////////////////////////////////////
void
GLExtensions::internal_init()
{
assert(!_init);
err_mesg(ERR_LEV_INFO, "GLExtensions::init() - Initializing GL extensions...");
init_extensions();
_init = true;
err_mesg(ERR_LEV_INFO, "GLExtensions::init() - ...done.");
}
/////////////////////////////////////
// put_hatching_group_params()
/////////////////////////////////////
void
HatchingGroup::put_hatching_group_params(TAGformat &d) const
{
err_mesg(ERR_LEV_SPAM, "HatchingGroup::put_hatching_group_params()");
d.id();
_params.format(*d);
d.end_id();
}
/////////////////////////////////////
// get_base_stroke()
/////////////////////////////////////
void
HatchingGroupParams::get_base_stroke(TAGformat &d)
{
err_mesg(ERR_LEV_SPAM, "HatchingGroup::get_base_stroke()");
//Grab the class name... should be HatchingStroke
string str;
*d >> str;
if (str != BaseStroke::static_name()) {
// XXX - should throw away stuff from unknown obj
err_mesg(ERR_LEV_ERROR, "HatchingGroupParams::get_base_stroke() - Not 'BaseStroke': '%s'!", str.c_str());
return;
}
_stroke.decode(*d);
}
/////////////////////////////////////
// put_base_stroke()
/////////////////////////////////////
void
HatchingGroupParams::put_base_stroke(TAGformat &d) const
{
err_mesg(ERR_LEV_SPAM, "HatchingGroup::put_base_stroke()");
d.id();
_stroke.format(*d);
d.end_id();
}
/////////////////////////////////////
// get_hatching_group_params()
/////////////////////////////////////
void
HatchingGroup::get_hatching_group_params(TAGformat &d)
{
err_mesg(ERR_LEV_SPAM, "HatchingGroup::get_hatching_group_params()");
//Grab the class name... should be HatchingCollection
string str;
*d >> str;
if (str != HatchingGroupParams::static_name()) {
// XXX - should throw away stuff from unknown obj
err_mesg(ERR_LEV_ERROR, "HatchingGroupParams::get_hatching_group_params() - Not 'HatchingGroupParams': '%s'!", str.c_str());
return;
}
_params.decode(*d);
update_prototype();
}
int main(int argc,char* argv[]){
if(argc < 2)
err_mesg("argument too less");
int all_vowels_num = 0;
int a_number = 0;
int e_number = 0;
int i_number = 0;
int o_number = 0;
int u_number = 0;
FILE *pfile;
pfile = fopen(argv[1],"r");
if(pfile==NULL){
fprintf(stderr,"Open file %s failed\n",argv[1]);
exit(EXIT_FAILURE);
}
char string[BUFSIZE];
while(!feof(pfile)){
fgets(string,BUFSIZE,pfile);
for(int i = 0;string[i] != '\0';i++){
switch(string[i]){
case 'a': ++a_number; break;
case 'e': ++e_number; break;
case 'i': ++i_number; break;
case 'o': ++o_number; break;
case 'u': ++u_number; break;
}
}
}
all_vowels_num = a_number+e_number+i_number+o_number+u_number;
printf("a number: %d\n",a_number);
printf("e number: %d\n",e_number);
printf("i number: %d\n",i_number);
printf("o number: %d\n",o_number);
printf("u number: %d\n",u_number);
printf("All vowels is %d\n",all_vowels_num);
return EXIT_SUCCESS;
}
/////////////////////////////////////
// gl_arb_fragment_program_loaded()
/////////////////////////////////////
bool
GLExtensions::gl_arb_fragment_program_loaded(
const string &header,
bool &native,
const unsigned char *prog)
{
bool success;
if (!gl_arb_fragment_program_supported())
{
err_mesg(ERR_LEV_INFO, "%GL_ARB_fragment_program not supported.", header.c_str());
native = false;
success = false;
}
else
{
#ifdef GL_ARB_fragment_program
int i;
unsigned char *err_buf1, *err_buf2;
const GLubyte *err_str;
GLint err_pos;
GLint is_native;
GLenum err = glGetError();
err_mesg(ERR_LEV_INFO, "%sLoading program...", header.c_str());
err_str = glGetString( GL_PROGRAM_ERROR_STRING_ARB );
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &err_pos );
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &is_native);
native = (is_native != 0);
if (err_pos != -1)
{
int prog_len = strlen((const char *)prog); assert(err_pos <= prog_len);
int err_left = err_pos, err_right = err_pos;
while ((err_left > 0) &&
(prog[err_left-1] != '\n' &&
prog[err_left-1] != ';' &&
prog[err_left-1] != '\r')) err_left--;
while ((err_right < prog_len) &&
(prog[err_right+1] != '\n' &&
prog[err_right] != ';' &&
prog[err_right+1] != '\r' &&
prog[err_right+1] != 0 )) err_right++;
err_buf1 = new unsigned char [err_right - err_left + 2]; assert(err_buf1);
err_buf2 = new unsigned char [err_right - err_left + 2]; assert(err_buf2);
for (i=0; i<(err_right-err_left+1); i++)
{
err_buf1[i] = prog[err_left+i];
err_buf2[i] = ' ';
}
err_buf2[err_pos-err_left]='^';
err_buf1[i] = 0;
err_buf2[i] = 0;
}
if ( err == GL_INVALID_OPERATION )
{
success = false;
//assert(!native);
assert(err_str && (err_str[0] != 0));
err_mesg(ERR_LEV_ERROR, "%s*** Failed! ***", header.c_str());
if (err_pos != -1)
{
err_mesg(ERR_LEV_ERROR, "%sERROR LOCATION: %d", header.c_str(), err_pos);
err_mesg(ERR_LEV_ERROR, "%sERROR EXCERPT: [%s]", header.c_str(), err_buf1);
err_mesg(ERR_LEV_ERROR, "%s [%s]", header.c_str(), err_buf2);
}
err_mesg(ERR_LEV_ERROR, "%sERROR STRING: '%s'", header.c_str(), err_str);
}
else
{
success = true;
if (native)
err_mesg(ERR_LEV_INFO, "%sWill execute natively in hardware.", header.c_str());
else
err_mesg(ERR_LEV_WARN, "%sWill execute **BUT** not natively in hardware. Using emulation...", header.c_str());
if (err_pos != -1)
{
err_mesg(ERR_LEV_WARN, "%sWARNING LOCATION: %d", header.c_str(), err_pos);
err_mesg(ERR_LEV_WARN, "%sWARNING EXCERPT: [%s]", header.c_str(), err_buf1);
err_mesg(ERR_LEV_WARN, "%s [%s]", header.c_str(), err_buf2);
}
if (err_str && (err_str[0] != 0))
err_mesg(ERR_LEV_WARN, "%sWARNING STRING: '%s'", header.c_str(), err_str);
}
if (err_pos != -1)
{
delete[] err_buf1;
delete[] err_buf2;
}
GLint ins_num, ins_max, nins_num, nins_max;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_INSTRUCTIONS_ARB, &ins_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &ins_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &nins_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &nins_max);
GLint ains_num, ains_max, nains_num, nains_max;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_ALU_INSTRUCTIONS_ARB, &ains_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, &ains_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, &nains_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, &nains_max);
GLint tins_num, tins_max, ntins_num, ntins_max;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_TEX_INSTRUCTIONS_ARB, &tins_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, &tins_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, &ntins_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, &ntins_max);
GLint txns_num, txns_max, ntxns_num, ntxns_max;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_TEX_INDIRECTIONS_ARB, &txns_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, &txns_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, &ntxns_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, &ntxns_max);
GLint tmp_num, tmp_max, ntmp_num, ntmp_max;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_TEMPORARIES_ARB, &tmp_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &tmp_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_NATIVE_TEMPORARIES_ARB, &ntmp_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &ntmp_max);
GLint par_num, par_max, npar_num, npar_max;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_PARAMETERS_ARB, &par_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_PARAMETERS_ARB, &par_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_NATIVE_PARAMETERS_ARB, &npar_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &npar_max);
GLint att_num, att_max, natt_num, natt_max;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_ATTRIBS_ARB, &att_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ATTRIBS_ARB, &att_max);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_NATIVE_ATTRIBS_ARB, &natt_num);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, &natt_max);
err_mesg(ERR_LEV_SPAM, "%sResource Usage:", header.c_str());
err_mesg(ERR_LEV_SPAM, "%s Instructions - ALL (ARB): MAX=%d USED=%d", header.c_str(), ins_max, ins_num);
err_mesg(ERR_LEV_SPAM, "%s (NATIVE): MAX=%d USED=%d", header.c_str(), nins_max, nins_num);
err_mesg(ERR_LEV_SPAM, "%s Instructions - ALU (ARB): MAX=%d USED=%d", header.c_str(), ains_max, ains_num);
err_mesg(ERR_LEV_SPAM, "%s (NATIVE): MAX=%d USED=%d", header.c_str(), nains_max, nains_num);
err_mesg(ERR_LEV_SPAM, "%s Instructions - TEX (ARB): MAX=%d USED=%d", header.c_str(), tins_max, tins_num);
err_mesg(ERR_LEV_SPAM, "%s (NATIVE): MAX=%d USED=%d", header.c_str(), ntins_max, ntins_num);
err_mesg(ERR_LEV_SPAM, "%s Tex Indirections (ARB): MAX=%d USED=%d", header.c_str(), txns_max, txns_num);
err_mesg(ERR_LEV_SPAM, "%s (NATIVE): MAX=%d USED=%d", header.c_str(), ntxns_max, ntxns_num);
err_mesg(ERR_LEV_SPAM, "%s Temporaries (ARB): MAX=%d USED=%d", header.c_str(), tmp_max, tmp_num);
err_mesg(ERR_LEV_SPAM, "%s (NATIVE): MAX=%d USED=%d", header.c_str(), ntmp_max, tmp_num);
err_mesg(ERR_LEV_SPAM, "%s Parameters (ARB): MAX=%d USED=%d", header.c_str(), par_max, par_num);
err_mesg(ERR_LEV_SPAM, "%s (NATIVE): MAX=%d USED=%d", header.c_str(), npar_max, npar_num);
err_mesg(ERR_LEV_SPAM, "%s Attributes (ARB): MAX=%d USED=%d", header.c_str(), att_max, att_num);
err_mesg(ERR_LEV_SPAM, "%s (NATIVE): MAX=%d USED=%d", header.c_str(), natt_max, natt_num);
err_mesg(ERR_LEV_SPAM, "%s...done.", header.c_str());
#endif
}
return success;
}
