void create(const string str_tmpl_file = "")
{
// if we are trying to create a single reference file, overwrite the global
// test list
if ( str_tmpl_file.length() )
{
tests_c.clear();
tests_c.push_back( test_s(str_tmpl_file) );
}
cout << "\nCreating " << tests_c.size() << " reference tests...\n" << endl;
for (unsigned int n=0; n < tests_c.size(); n++)
{
test_s & r_test = tests_c[n];
templ.Set_Template_File( r_test.str_file );
const string str_out_file = get_reference_file( r_test.str_file );
ofstream out_stream;
out_stream.open(str_out_file.c_str(), std::ios::out);
const string str_reference_output = templ.Process();
out_stream.write(str_reference_output.c_str(),
str_reference_output.length());
out_stream.close();
cout << r_test.str_file << endl;
}
}
void tick() {
world()->check();
frame_count++;
if(true) {
glColor3f(1,0,0);
glBegin(GL_LINES);
glVertex3f(ray.o.x,ray.o.y,ray.o.z);
glVertex3f((ray.o.x+ray.d.x),(ray.o.y+ray.d.y),(ray.o.z+ray.d.z));
glEnd();
}
const world_t::hits_t& visible = world()->visible();
visible_objects = visible.size();
//#define EXPLAIN // useful for seeing if it does draw front-to-back
#ifdef EXPLAIN
for(size_t MAX_OBJS=1; MAX_OBJS<visible_objects; MAX_OBJS++) {
#else
const size_t MAX_OBJS = visible_objects;
#endif
if(visible_objects) {
bool in_terrain = (terrain() && visible[0].type == TERRAIN);
if(in_terrain) terrain()->draw_init();
size_t i = 0;
for(world_t::hits_t::const_iterator v=visible.begin(); v!=visible.end() && i<MAX_OBJS; v++, i++) {
if(in_terrain && (v->type != TERRAIN)) {
terrain()->draw_done();
in_terrain = false;
} else if((v->type == TERRAIN) && !in_terrain)
panic("was not expecting "<<*v);
v->obj->draw(v->d);
}
if(in_terrain)
terrain()->draw_done();
} else {
for(tests_t::iterator i=objs.begin(); i!=objs.end(); i++)
(*i)->draw(0);
}
//spatial_test();
ui();
SDL_GL_SwapBuffers();
SDL_Flip(screen);
glClearColor(.2,.1,.2,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
#ifdef EXPLAIN
}
#endif
}
void spatial_test() {
enum { MIN_OBJS = 150, MAX_OBJS = 170, };
glDisable(GL_TEXTURE_2D);
for(int i=objs.size()-1; i>=0; i--) {
test_t* obj = objs[i];
glColor3ub(0xff,0,0);
if(obj->is_visible()) {
if(!world()->is_visible(*obj))
std::cerr << *obj << " thinks it is visible but it isn't" << std::endl;
else if(!obj->drawn)
std::cerr << *obj << " thinks it is visible but wasn't drawn" << std::endl;
else
glColor3ub(0,0xff,0);
} else {
if(world()->is_visible(*obj))
std::cerr << *obj << " thinks it is invisible but it is" << std::endl;
else if(obj->drawn)
std::cerr << *obj << " is invisible but was drawn" << std::endl;
else
glColor3ub(0,0,0xff);
}
obj->drawn = false;
caret(obj->get_pos(),obj->SZ,obj->rx,obj->ry,obj->rz);
if(!obj->tick()) {
objs.erase(objs.begin()+i);
delete obj;
}
}
glEnable(GL_TEXTURE_2D);
if(!objs.size() < MIN_OBJS) {
const size_t n = MIN_OBJS+(rand()%(MAX_OBJS-MIN_OBJS));
while(objs.size()<n) {
objs.push_back(new test_t());
}
}
}
int main(int argc,char** args) {
srand(time(NULL));
try {
if (SDL_Init(SDL_INIT_VIDEO)) {
fprintf(stderr,"Unable to initialize SDL: %s\n",SDL_GetError());
return EXIT_FAILURE;
}
atexit(SDL_Quit);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
#if 0
screen = SDL_SetVideoMode(1440,900,32,SDL_OPENGL|SDL_FULLSCREEN);
#else
screen = SDL_SetVideoMode(1024,768,32,SDL_OPENGL/*|SDL_FULLSCREEN*/);
#endif
if(!screen) {
fprintf(stderr,"Unable to create SDL screen: %s\n",SDL_GetError());
return EXIT_FAILURE;
}
SDL_WM_SetCaption("GlestNG","GlestNG");
GLenum err = glewInit();
if(GLEW_OK != err) {
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
return EXIT_FAILURE;
}
fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
// we have a GL context so we can go ahead and init all the singletons
std::auto_ptr<fs_t> fs_settings(fs_t::create("data/"));
fs_t::settings = fs_settings.get(); // set it globally
std::auto_ptr<xml_parser_t> xml_settings(new xml_parser_t("UI Settings",fs_settings->get_body("ui_settings.xml")));
xml_settings->set_as_settings();
std::auto_ptr<graphics_t::mgr_t> graphics_mgr(graphics_t::create());
std::auto_ptr<fonts_t> fonts(fonts_t::create());
std::auto_ptr<fs_t> fs;
try {
fs.reset(fs_t::create("data/Glest"));
if(false) {
fs_file_t::ptr_t logo_file(fs_settings->get("logo.g3d"));
istream_t::ptr_t logostream(logo_file->reader());
logo = std::auto_ptr<model_g3d_t>(new model_g3d_t(*logostream));
}
load(*fs);
} catch(glest_exception_t* e) {
std::cerr << "cannot load glest data: " << e << std::endl;
delete e;
}
std::auto_ptr<ui_mgr_t> ui_(ui_mgr());
std::auto_ptr<mod_ui_t> mod_ui(mod_ui_t::create());
std::auto_ptr<terrain_t> terrain(terrain_t::gen_planet(5,500,3));
//world()->dump(std::cout);
v4_t light_amb(0,0,0,1), light_dif(1.,1.,1.,1.), light_spec(1.,1.,1.,1.), light_pos(1.,1.,-1.,0.),
mat_amb(.7,.7,.7,1.), mat_dif(.8,.8,.8,1.), mat_spec(1.,1.,1.,1.);
glLightfv(GL_LIGHT0,GL_AMBIENT,light_amb.v);
glLightfv(GL_LIGHT0,GL_DIFFUSE,light_dif.v);
glLightfv(GL_LIGHT0,GL_SPECULAR,light_spec.v);
glLightfv(GL_LIGHT0,GL_POSITION,light_pos.v);
glLightfv(GL_LIGHT1,GL_AMBIENT,light_amb.v);
glLightfv(GL_LIGHT1,GL_DIFFUSE,light_dif.v);
glLightfv(GL_LIGHT1,GL_SPECULAR,light_spec.v);
glMaterialfv(GL_FRONT,GL_AMBIENT,mat_amb.v);
glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_dif.v);
glMaterialfv(GL_FRONT,GL_SPECULAR,mat_spec.v);
glMaterialf(GL_FRONT,GL_SHININESS,100.0);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glAlphaFunc(GL_GREATER,0.4);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_RESCALE_NORMAL);
glEnable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_NORMALIZE);
glFrontFace(GL_CW);
camera();
bool quit = false;
SDL_Event event;
SDL_EnableKeyRepeat(200,20);
SDL_EnableUNICODE(true);
const unsigned start = SDL_GetTicks();
framerate.reset();
while(!quit) {
set_now(SDL_GetTicks()-start);
while(!quit && SDL_PollEvent(&event)) {
if(ui_mgr()->offer(event))
continue;
switch (event.type) {
case SDL_MOUSEMOTION:
if(selection)
std::cout << "drag" << std::endl;
/*printf("Mouse moved by %d,%d to (%d,%d)\n",
event.motion.xrel, event.motion.yrel,
event.motion.x, event.motion.y);*/
break;
case SDL_MOUSEBUTTONDOWN:
click(event.button.x,event.button.y);
if(selection)
std::cout << "selection: "<<selected_point<<std::endl;
break;
case SDL_MOUSEBUTTONUP:
if(selection)
std::cout << "selection stopped" << std::endl;
selection = false;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_PLUS:
zoom += 1;
camera();
break;
case SDLK_MINUS:
zoom -= 1;
camera();
break;
case SDLK_ESCAPE:
quit = true;
break;
case SDLK_m: // MODDING MODE
if(!fs.get()) {
std::cerr << "(modding menu triggered but mod not loaded)" << std::endl;
break;
}
if(mod_ui->is_shown())
mod_ui->hide();
else
mod_ui->show(ref_t(*techtree,TECHTREE,techtree->name));
break;
default:
std::cout << "Ignoring key " <<
(int)event.key.keysym.scancode << "," <<
event.key.keysym.sym << "," <<
event.key.keysym.mod << "," <<
event.key.keysym.unicode << std::endl;
}
break;
case SDL_QUIT:
quit = true;
break;
}
}
framerate.tick(now());
tick();
}
for(tests_t::iterator i=objs.begin(); i!=objs.end(); i++)
delete *i;
return EXIT_SUCCESS;
} catch(data_error_t* de) {
std::cerr << "Oh! " << de << std::endl;
} catch(graphics_error_t* ge) {
std::cerr << "Oh! " << ge << std::endl;
} catch(panic_t* panic) {
std::cerr << "Oh! " << panic << std::endl;
}
return EXIT_FAILURE;
}
void test(const tests_t & tests_c, const string str_test_name)
{
cout << str_test_name << " ";
for (unsigned int n=0; n < tests_c.size(); n++)
{
const test_s & t = tests_c[n];
string str_template_output = "";
try
{
templ.Set_Template_File( t.str_file );
str_template_output = templ.Process();
}
catch (tmpl::syntax_ex & ex)
{
if ( t.str_error_to_catch == ex.what() )
{
cout << ".";
continue;
}
else // NOT the type of error we expect, rethrow
{
throw ex;
}
}
// if there is an error to catch - we didn't catch it
if ( t.str_error_to_catch.length() )
{
throw( string("Uncaught error: '") + t.str_error_to_catch + "'" );
}
const string str_ref_file_path = get_reference_file( t.str_file );
std::ifstream in_stream;
in_stream.open(str_ref_file_path.c_str());
if( !in_stream.is_open() )
{
throw(string("Could not open reference test file '")
+ str_ref_file_path
+ "'. All tests aborted");
}
std::stringstream oss;
oss << in_stream.rdbuf();
string str_reference_output = oss.str();
in_stream.close();
const bool b_match = (str_template_output == str_reference_output);
if (b_match == true)
{
cout << ".";
}
else
{
cout << " FAIL: '" << t.str_file << "'" << endl;
cout << "Output left in 'fail.txt'" << endl;
ofstream out_stream;
out_stream.open("fail.txt", std::ios::out);
out_stream.write(str_template_output.c_str(),
str_template_output.length());
out_stream.close();
#ifdef WIN
cout << "\nPress any key to QUIT";
_getch();
#endif
exit(1);
}
}
cout <<" Pass" << endl;
}
