void EarthquakeApp::draw()
{
gl::clear( Color( 1, 0, 0 ) );
gl::ScopedDepth depth( true );
gl::ScopedColor color( 1, 1, 1 );
// Draw stars.
if( mShowStars ) {
gl::ScopedTextureBind tex0( mStars, 0 );
gl::ScopedFaceCulling cull( true, GL_FRONT );
mStarSphere->draw();
}
// Draw Earth.
if( mShowEarth ) {
mEarth.draw();
}
// Draw quakes.
if( mShowQuakes ) {
mEarth.drawQuakes();
}
// Draw labels.
if( mShowText ) {
mEarth.drawQuakeLabelsOnSphere( mPov.mEyeNormal, mPov.mDist );
}
if( mSaveFrames ) {
static int currentFrame = 0;
writeImage( getHomeDirectory() / "CinderScreengrabs" / ( "Highoutput_" + toString( currentFrame++ ) + ".png" ), copyWindowSurface() );
}
}
void EarthquakeApp::draw()
{
glClearColor( 1.0f, 0.0f, 0.0f, 1.0f );
gl::enableAlphaBlending();
gl::enableDepthRead( true );
gl::enableDepthWrite( true );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_TEXTURE_2D );
glDisable( GL_TEXTURE_RECTANGLE_ARB );
gl::GlslProg::unbind();
glColor4f( 1, 1, 1, 1 );
mStars.enableAndBind();
gl::drawSphere( Vec3f( 0, 0, 0 ), 15000.0f, 64 );
//gl::rotate( Quatf( Vec3f::zAxis(), -0.2f ) );
//gl::rotate( Quatf( Vec3f::yAxis(), mCounter*0.1f ) );
if( mShowEarth ){
mEarthShader.bind();
mEarthShader.uniform( "texDiffuse", 0 );
mEarthShader.uniform( "texNormal", 1 );
mEarthShader.uniform( "texMask", 2 );
mEarthShader.uniform( "counter", mCounter );
mEarthShader.uniform( "lightDir", mLightDir );
mEarth.draw();
mEarthShader.unbind();
}
glDisable( GL_TEXTURE_2D );
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
if( mShowQuakes ){
mQuakeShader.bind();
mQuakeShader.uniform( "lightDir", mLightDir );
mEarth.drawQuakeVectors();
mQuakeShader.unbind();
}
if( mShowText ){
gl::enableDepthWrite( false );
glEnable( GL_TEXTURE_2D );
//mEarth.drawQuakeLabelsOnBillboard( sBillboardRight, sBillboardUp );
mEarth.drawQuakeLabelsOnSphere( mPov.mEyeNormal, mPov.mDist );
glDisable( GL_TEXTURE_2D );
}
if( mSaveFrames ){
//writeImage( getHomeDirectory() / "CinderScreengrabs" / "Highoutput_" + toString( mCurrentFrame ) + ".png", copyWindowSurface() );
mCurrentFrame++;
}
}
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(resources);
QApplication app(argc, argv);
Earth earth;
earth.show();
return app.exec();
}
void EarthquakeApp::setup()
{
gl::Texture earthDiffuse = gl::Texture( loadImage( loadResource( RES_EARTHDIFFUSE ) ) );
gl::Texture earthNormal = gl::Texture( loadImage( loadResource( RES_EARTHNORMAL ) ) );
gl::Texture earthMask = gl::Texture( loadImage( loadResource( RES_EARTHMASK ) ) );
earthDiffuse.setWrap( GL_REPEAT, GL_REPEAT );
earthNormal.setWrap( GL_REPEAT, GL_REPEAT );
earthMask.setWrap( GL_REPEAT, GL_REPEAT );
mStars = gl::Texture( loadImage( loadResource( RES_STARS_PNG ) ) );
mEarthShader = gl::GlslProg( loadResource( RES_PASSTHRU_VERT ), loadResource( RES_EARTH_FRAG ) );
mQuakeShader = gl::GlslProg( loadResource( RES_QUAKE_VERT ), loadResource( RES_QUAKE_FRAG ) );
mCounter = 0.0f;
mCurrentFrame = 0;
mSaveFrames = false;
mShowEarth = true;
mShowText = true;
mShowQuakes = true;
mLightDir = Vec3f( 0.025f, 0.25f, 1.0f );
mLightDir.normalize();
mPov = POV( this, ci::Vec3f( 0.0f, 0.0f, 1000.0f ), ci::Vec3f( 0.0f, 0.0f, 0.0f ) );
mEarth = Earth( earthDiffuse, earthNormal, earthMask );
parseEarthquakes( "http://earthquake.usgs.gov/earthquakes/catalogs/7day-M2.5.xml" );
mEarth.setQuakeLocTip();
}
void EarthquakeApp::parseEarthquakes( const string &url )
{
XmlDocument doc( loadUrlStream( url ) );
vector<XmlElement> items( doc.rootNode().children() );
for( vector<XmlElement>::iterator itemIter = items.begin(); itemIter != items.end(); ++itemIter ) {
if( itemIter->name() == "entry" ) {
// Title is in the form "M 3.3, Puerto Rico region"
const XmlElement &titleEl = itemIter->findChild( "title" );
istringstream titleString( titleEl.value() );
string dummy, title;
float magnitude;
titleString.ignore( 2, ' ' );
titleString >> magnitude;
titleString.ignore( 2, ' ' );
char lineBuffer[512];
titleString.getline( lineBuffer, 511 );
title = string( lineBuffer );
const XmlElement &locationEl = itemIter->findChild( "georss:point" );
istringstream locationString( locationEl.value() );
Vec2f locationVector;
locationString >> locationVector.x >> locationVector.y;
mEarth.addQuake( locationVector.x, locationVector.y, magnitude, title );
}
}
}
void EarthquakeApp::keyDown( KeyEvent event )
{
if( event.getChar() == 'f' ) {
setFullScreen( ! isFullScreen() );
}
else if( event.getCode() == app::KeyEvent::KEY_ESCAPE ) {
setFullScreen( false );
}
else if( event.getChar() == 's' ) {
mSaveFrames = ! mSaveFrames;
}
else if( event.getChar() == 'e' ) {
mShowEarth = ! mShowEarth;
}
else if( event.getChar() == 't' ) {
mShowText = ! mShowText;
}
else if( event.getChar() == 'q' ) {
mShowQuakes = ! mShowQuakes;
}
else if( event.getChar() == 'm' ) {
mEarth.setMinMagToRender( -1.0f );
}
else if( event.getChar() == 'M' ) {
mEarth.setMinMagToRender( 1.0f );
}
else if( event.getCode() == app::KeyEvent::KEY_UP ) {
mPov.adjustDist( -10.0f );
}
else if( event.getCode() == app::KeyEvent::KEY_DOWN ) {
mPov.adjustDist( 10.0f );
}
else if( event.getChar() == ' ' ) {
// gl::TileRender tr( 5000, 5000 );
// CameraPersp cam;
// cam.lookAt( mPov.mEye, mPov.mCenter );
// cam.setPerspective( 60.0f, tr.getImageAspectRatio(), 1, 20000 );
// tr.setMatrices( cam );
// while( tr.nextTile() ) {
// draw();
// }
// writeImage( getHomeDirectory() / "output.png", tr.getSurface() );
}
}
void EarthquakeApp::update()
{
mPov.update();
mPov.mCam.getBillboardVectors( &sBillboardRight, &sBillboardUp );
//mLightDir = Vec3f( sin( mCounter ), 0.25f, cos( mCounter ) );
mEarth.update();
mCounter += 0.1f;
}
void EarthquakeApp::parseEarthquakes( const string &url )
{
try {
const JsonTree json( loadUrl( url ) );
for( auto &feature : json["features"].getChildren() ) {
auto &coords = feature["geometry"]["coordinates"];
float mag = feature["properties"]["mag"].getValue<float>();
const string &title = feature["properties"]["title"].getValue();
mEarth.addQuake( coords[0].getValue<float>(), coords[1].getValue<float>(), mag, title );
}
}
catch( ci::Exception &exc ) {
console() << "Failed to parse json, what: " << exc.what() << std::endl;
}
// Test to see if quakes show up in the right spot:
// mEarth.addQuake( 37.7833f, -122.4167f, 8.6f, "San Francisco" );
mEarth.setQuakeLocTips();
}
void EarthquakeApp::keyDown( KeyEvent event )
{
if( event.getChar() == 'f' ) {
// Toggle full screen.
setFullScreen( !isFullScreen() );
}
else if( event.getCode() == app::KeyEvent::KEY_ESCAPE ) {
if( isFullScreen() )
setFullScreen( false );
else
quit();
}
else if( event.getChar() == 's' ) {
mSaveFrames = !mSaveFrames;
}
else if( event.getChar() == 'e' ) {
mShowEarth = !mShowEarth;
}
else if( event.getChar() == 't' ) {
mShowText = !mShowText;
}
else if( event.getChar() == 'q' ) {
mShowQuakes = !mShowQuakes;
}
else if( event.getChar() == 'm' ) {
mEarth.setMinMagToRender( -1.0f );
}
else if( event.getChar() == 'M' ) {
mEarth.setMinMagToRender( 1.0f );
}
else if( event.getCode() == app::KeyEvent::KEY_UP ) {
mPov.adjustDist( -10.0f );
}
else if( event.getCode() == app::KeyEvent::KEY_DOWN ) {
mPov.adjustDist( 10.0f );
}
}
void EarthquakeApp::parseEarthquakes( const string &url )
{
const XmlTree xml( loadUrl( Url( url ) ) );
for( XmlTree::ConstIter itemIter = xml.begin( "feed/entry" ); itemIter != xml.end(); ++itemIter ) {
string titleLine( itemIter->getChild( "title" ).getValue() );
size_t firstComma = titleLine.find( ',' );
float magnitude = fromString<float>( titleLine.substr( titleLine.find( ' ' ) + 1, firstComma - 2 ) );
string title = titleLine.substr( firstComma + 2 );
istringstream locationString( itemIter->getChild( "georss:point" ).getValue() );
Vec2f locationVector;
locationString >> locationVector.x >> locationVector.y;
mEarth.addQuake( locationVector.x, locationVector.y, magnitude, title );
}
console() << xml << std::endl;
//mEarth.addQuake( 37.7f, -122.0f, 8.6f, "San Francisco" );
}
int main(){
squids::Const units;
// open HDF5 file
hid_t file_id = H5Fcreate("body_test.hdf5", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
hid_t body_group_id,track_group_id;
// ************************************
// testing vacuum serialization
// ************************************
Vacuum v;
Vacuum::Track vt(10.*units.km,50*units.km,100.0*units.km);
// open groups
hid_t vacuum_group_id = H5Gcreate(file_id, "vacuum", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
body_group_id = H5Gcreate(vacuum_group_id, "body", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
track_group_id = H5Gcreate(vacuum_group_id, "track", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
v.Serialize(body_group_id);
vt.Serialize(track_group_id);
auto vr = Vacuum::Deserialize(body_group_id);
auto vtr = Vacuum::Track::Deserialize(track_group_id);
if ( fabs(vr->density(*vtr) - v.density(vt)) >1.0e-5 )
std::cout << "densities are different after serializing for vacuum" << std::endl;
if ( fabs(vr->ye(*vtr) - v.ye(vt)) >1.0e-5 )
std::cout << "ye are different after serializing for vacuum" << std::endl;
// close hdf5 groups
H5Gclose(body_group_id);
H5Gclose(track_group_id);
H5Gclose(vacuum_group_id);
// ************************************
// testing constant density serialization
// ************************************
ConstantDensity c(3.0,0.5);
ConstantDensity::Track ct(10.*units.km,50*units.km,100.0*units.km);
// open groups
hid_t constant_density_group_id = H5Gcreate(file_id, "constant_density", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
body_group_id = H5Gcreate(constant_density_group_id, "body", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
track_group_id = H5Gcreate(constant_density_group_id, "track", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
c.Serialize(body_group_id);
ct.Serialize(track_group_id);
auto cr = ConstantDensity::Deserialize(body_group_id);
auto ctr = ConstantDensity::Track::Deserialize(track_group_id);
if ( fabs(cr->density(*ctr) - c.density(ct)) >1.0e-5 )
std::cout << "densities are different after serializing for constant_density" << std::endl;
if ( fabs(cr->ye(*ctr) - c.ye(ct)) >1.0e-5 )
std::cout << "ye are different after serializing for constant_density" << std::endl;
// close hdf5 groups
H5Gclose(body_group_id);
H5Gclose(track_group_id);
H5Gclose(constant_density_group_id);
// ************************************
// testing variable density serialization
// ************************************
std::vector<double> xx {1.,2.,3.,4.,5.};
std::vector<double> rho {0.,1.,0.,1.,0.};
std::vector<double> ye {0.5,0.5,0.5,0.5,0.5};
VariableDensity var(xx,rho,ye);
VariableDensity::Track vart(10.*units.km,50*units.km,100.0*units.km);
// open groups
hid_t variable_density_group_id = H5Gcreate(file_id, "variable_density", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
body_group_id = H5Gcreate(variable_density_group_id, "body", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
track_group_id = H5Gcreate(variable_density_group_id, "track", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
var.Serialize(body_group_id);
vart.Serialize(track_group_id);
auto varr = VariableDensity::Deserialize(body_group_id);
auto vartr = VariableDensity::Track::Deserialize(track_group_id);
if ( fabs(varr->density(*ctr) - var.density(vart)) >1.0e-5 )
std::cout << "densities are different after serializing for constant_density" << std::endl;
if ( fabs(varr->ye(*vartr) - var.ye(vart)) >1.0e-5 )
std::cout << "ye are different after serializing for constant_density" << std::endl;
// close hdf5 groups
H5Gclose(body_group_id);
H5Gclose(track_group_id);
H5Gclose(variable_density_group_id);
// ************************************
// testing earth
// ************************************
Earth earth;
Earth::Track eartht(10.*units.km,50*units.km,100.0*units.km);
// open groups
hid_t earth_group_id = H5Gcreate(file_id, "earth", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
body_group_id = H5Gcreate(earth_group_id, "body", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
track_group_id = H5Gcreate(earth_group_id, "track", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
earth.Serialize(body_group_id);
eartht.Serialize(track_group_id);
auto earthr = Earth::Deserialize(body_group_id);
auto earthtr = Earth::Track::Deserialize(track_group_id);
if ( fabs(earthr->density(*earthtr) - earth.density(eartht)) >1.0e-5 )
std::cout << "densities are different after serializing for constant_density" << std::endl;
if ( fabs(earthr->ye(*earthtr) - earth.ye(eartht)) >1.0e-5 )
std::cout << "ye are different after serializing for constant_density" << std::endl;
// close hdf5 groups
H5Gclose(body_group_id);
H5Gclose(track_group_id);
H5Gclose(earth_group_id);
// ************************************
// testing sun
// ************************************
Sun sun;
Sun::Track sunt(10.*units.km,50*units.km,100.0*units.km);
// open groups
hid_t sun_group_id = H5Gcreate(file_id, "sun", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
body_group_id = H5Gcreate(sun_group_id, "body", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
track_group_id = H5Gcreate(sun_group_id, "track", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
sun.Serialize(body_group_id);
sunt.Serialize(track_group_id);
auto sunr = Sun::Deserialize(body_group_id);
auto suntr = Sun::Track::Deserialize(track_group_id);
if ( fabs(sunr->density(*suntr) - sun.density(sunt)) >1.0e-5 )
std::cout << "densities are different after serializing for constant_density" << std::endl;
if ( fabs(sunr->ye(*suntr) - sun.ye(sunt)) >1.0e-5 )
std::cout << "ye are different after serializing for constant_density" << std::endl;
// close hdf5 groups
H5Gclose(body_group_id);
H5Gclose(track_group_id);
H5Gclose(sun_group_id);
// ************************************
// testing sunasnu
// ************************************
SunASnu sunasnu;
SunASnu::Track sunasnut(10.*units.km,50*units.km,100.0*units.km);
// open groups
hid_t sunasnu_group_id = H5Gcreate(file_id, "sunasnu", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
body_group_id = H5Gcreate(sun_group_id, "body", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
track_group_id = H5Gcreate(sun_group_id, "track", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
sunasnu.Serialize(body_group_id);
sunasnut.Serialize(track_group_id);
auto sunasnur = SunASnu::Deserialize(body_group_id);
auto sunasnutr = SunASnu::Track::Deserialize(track_group_id);
if ( fabs(sunasnur->density(*sunasnutr) - sunasnu.density(sunasnut)) >1.0e-5 )
std::cout << "densities are different after serializing for constant_density" << std::endl;
if ( fabs(sunasnur->ye(*sunasnutr) - sunasnu.ye(sunasnut)) >1.0e-5 )
std::cout << "ye are different after serializing for constant_density" << std::endl;
// close hdf5 groups
H5Gclose(body_group_id);
H5Gclose(track_group_id);
H5Gclose(sunasnu_group_id);
// ************************************
// testing earthatm
// ************************************
EarthAtm earthatm;
EarthAtm::Track earthatmt(10.*units.km,acos(3.1415));
// open groups
hid_t earthatm_group_id = H5Gcreate(file_id, "earthatm", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
body_group_id = H5Gcreate(sun_group_id, "body", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
track_group_id = H5Gcreate(sun_group_id, "track", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
earthatm.Serialize(body_group_id);
earthatmt.Serialize(track_group_id);
auto earthatmr = EarthAtm::Deserialize(body_group_id);
auto earthatmtr = EarthAtm::Track::Deserialize(track_group_id);
if ( fabs(earthatmr->density(*earthatmtr) - earthatm.density(earthatmt)) >1.0e-5 )
std::cout << "densities are different after serializing for constant_density" << std::endl;
if ( fabs(earthatmr->ye(*earthatmtr) - earthatm.ye(earthatmt)) >1.0e-5 )
std::cout << "ye are different after serializing for constant_density" << std::endl;
// close hdf5 groups
H5Gclose(body_group_id);
H5Gclose(track_group_id);
H5Gclose(earthatm_group_id);
// closing file
H5Fclose(file_id);
H5close();
return 0;
}
EarthViewer(const Vec2<int>& size, const float scale, const bool oblong, Touch& touch, Keyinp& keyinp, const std::string& path, const std::string& lang) :
touch_(touch),
keyinp_(keyinp),
size_(size.x / scale, size.y / scale),
params_(path + "devdata/params.json"),
scale_(scale),
aspect_((float)size.x / (float)size.y),
camera_(Camera::PERSPECTIVE),
cockpit_(Camera::ORTHOGONAL),
localize_(lang, path),
earth_(params_.value().get<picojson::object>()["earth"].get<picojson::object>(), path, camera_),
rotate_mix_(),
place_index_()
{
DOUT << "EarthViewer()" << std::endl;
picojson::object& params = params_.value().get<picojson::object>();
camera_.oblong(oblong);
SetupCamera(camera_, params["camera"].get<picojson::object>(), aspect_);
cockpit_.setSize(size.x / scale, size.y / scale);
{
picojson::array& array = params["lights"].get<picojson::array>();
for (picojson::array::iterator it = array.begin(); it != array.end(); ++it)
{
Light light;
SetupLight(light, it->get<picojson::object>());
lights_.push_back(light);
}
earth_.light(lights_);
}
env_.touch = &touch_;
env_.keyinp = &keyinp_;
env_.path = &path;
env_.savePath = &path;
env_.size = &size_;
env_.scale = scale_;
env_.params = ¶ms_;
env_.task = &task_;
env_.camera = &camera_;
env_.cockpit = &cockpit_;
env_.earth = &earth_;
env_.earthLight = &lights_[0];
env_.fonts = &fonts_;
env_.texMng = &texMng_;
env_.localize = &localize_;
env_.earth_texture = 0;
earth_.texture(env_.earth_texture);
earth_.setRotSpeed(0);
{
const std::string& file = params["game"].get<picojson::object>()["places"].get<std::string>();
Json places = Json(path + file);
places_ = places.value().get<picojson::object>();
for (picojson::object::iterator it = places_.begin(); it != places_.end(); ++it)
{
place_names_.push_back(&it->first);
}
}
task_.add<Control>(TASK_PRIO_SYS, env_);
task_.add<Game2DSetup>(TASK_PRIO_2D_TOPPRIO, env_);
task_.add<GameWorld>(TASK_PRIO_3D_TOPPRIO, env_);
env_.task->add<PlaceDisp>(TASK_PRIO_2D, env_);
// task_.add<Equator>(TASK_PRIO_3D, env_);
task_.add<TouchEft>(TASK_PRIO_3D, env_);
}
bool step(const float delta_time)
{
task_.step(delta_time);
u_char key_inp = env_.keyinp->get();
if (key_inp != '\0')
{
static const u_char tbl[] = {
'1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c',
'd', 'e'
};
int i;
for (i = 0; i < elemsof(tbl); ++i)
{
if (tbl[i] == key_inp) break;
}
if (i < elemsof(tbl))
{
env_.earth_texture = i;
earth_.texture(env_.earth_texture);
}
if (key_inp == 'r')
{
rotate_mix_ = !rotate_mix_;
env_.task->sendMsgAll(rotate_mix_ ? MSG_CONTROL_MIX : MSG_CONTROL_XY);
}
}
// 地球のテクスチャを変更する
// 問題と回答を表示するテスト
if (key_inp == 'q' || key_inp == 'w')
{
if (key_inp == 'w')
{
--place_index_;
if (place_index_ < 0) place_index_ = place_names_.size() - 1;
}
DOUT << *place_names_[place_index_] << ":" << place_index_ << "(" << place_names_.size() << ")" << std::endl;
picojson::object place = places_[*place_names_[place_index_]].get<picojson::object>();
env_.cur_place = place["name"].get<std::string>();
env_.answer = place["answer"].is<std::string>();
if (env_.answer) env_.ans_place = place["answer"].get<std::string>();
env_.onetime = place["onetime"].is<bool>() ? place["onetime"].get<bool>() : false;
if (key_inp == 'q')
{
place_index_ = (place_index_ + 1) % place_names_.size();
}
{
std::string& f = place["file"].get<std::string>();
std::string path = *(env_.path) + "devdata/place/" + f;
place_ = std::tr1::shared_ptr<Place>(new Place(path));
std::vector<Vec2<float> > center;
place_->center(center); // 各範囲の中心を求める
env_.place_center.clear();
for(std::vector<Vec2<float> >::iterator it = center.begin(); it != center.end(); ++it)
{
Vec3<float> pos = locToPos(*it);
env_.place_center.push_back(pos);
}
this->ansDisp();
}
// 問題の正解位置を表示
env_.task->sendMsgAll(MSG_GAME_PLACEDISP_START);
if (env_.answer) env_.task->sendMsgAll(MSG_GAME_PLACEDISP_ANS);
env_.task->sendMsgAll(MSG_GAME_TOUCH_DISP);
}
else
if (key_inp == 'E')
{
localize_.reload("en.lang");
DOUT << "Localize:en.lang" << std::endl;
// 強制的に英語モード
}
else
if (key_inp == 'J')
{
localize_.reload("jp.lang");
DOUT << "Localize:jp.lang" << std::endl;
// 強制的に日本語モード
}
else
if (key_inp == 'Z')
{
earth_.airDraw();
}
else
if (key_inp == 'X')
{
earth_.bodyDraw();
}
else
if (key_inp == 'C')
{
earth_.cloudshadowDraw();
}
else
if (key_inp == 'V')
{
earth_.cloudbodyDraw();
}
else
if (key_inp == 'B')
{
earth_.atmosbodyDraw();
}
return true;
}
void EarthquakeApp::update()
{
mPov.update();
mEarth.update();
}
