bool Shagnetron::Initialize ()
{
csRef<iCommandLineParser> cmdline = csQueryRegistry<iCommandLineParser> (object_reg);
csRef<iVerbosityManager> verbose = csQueryRegistry<iVerbosityManager> (object_reg);
doVerbose = verbose->Enabled ("shagnetron");
// Implicitly enable verboseness for shaders.
verbose->Parse ("+renderer.shader.precache");
if (!csInitializer::RequestPlugins (object_reg,
CS_REQUEST_VFS,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_PLUGIN("crystalspace.graphics3d.shadermanager",
iShaderManager),
CS_REQUEST_PLUGIN("crystalspace.documentsystem.multiplexer",
iDocumentSystem),
CS_REQUEST_END))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.shagnetron",
"Can't initialize plugins!");
return false;
}
// Check for commandline help.
if (csCommandLineHelper::CheckHelp (object_reg))
{
PrintHelp ();
return false;
}
return true;
}
bool StartMe::OnInitialize(int /*argc*/, char* /*argv*/ [])
{
if (!csInitializer::SetupConfigManager (GetObjectRegistry (),
"/config/startme.cfg"))
return ReportError ("Error reading config file %s!",
CS::Quote::Single ("startme.cfg"));
// RequestPlugins() will load all plugins we specify. In addition
// it will also check if there are plugins that need to be loaded
// from the config system (both the application config and CS or
// global configs). In addition it also supports specifying plugins
// on the commandline.
if (!csInitializer::RequestPlugins(GetObjectRegistry(),
CS_REQUEST_VFS,
CS_REQUEST_OPENGL3D,
CS_REQUEST_ENGINE,
CS_REQUEST_FONTSERVER,
CS_REQUEST_IMAGELOADER,
CS_REQUEST_LEVELLOADER,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_PLUGIN ("crystalspace.cegui.wrapper", iCEGUI),
CS_REQUEST_END))
return ReportError ("Failed to initialize plugins!");
csBaseEventHandler::Initialize(GetObjectRegistry());
// Now we need to setup an event handler for our application.
// Crystal Space is fully event-driven. Everything (except for this
// initialization) happens in an event.
if (!RegisterQueue (GetObjectRegistry(), csevAllEvents(GetObjectRegistry())))
return ReportError ("Failed to set up event handler!");
return true;
}
int main(int argc, char** argv)
{
iObjectRegistry* object_reg = csInitializer::CreateEnvironment(argc, argv);
if(!object_reg)
{
csPrintf("Object Reg failed to Init!\n");
return -1;
}
if(!csInitializer::SetupConfigManager(object_reg, CONFIGFILE))
{
csPrintf("Failed to read config file!\n");
return -2;
}
csInitializer::RequestPlugins (object_reg, CS_REQUEST_VFS,
CS_REQUEST_PLUGIN("crystalspace.documentsystem.multiplexer", iDocumentSystem),
CS_REQUEST_END);
NavGen* navgen = new NavGen(object_reg);
if(!csInitializer::OpenApplication(object_reg))
{
csPrintf("csInitializer::OpenApplication failed!\n"
"Is your CRYSTAL environment var set?");
return -2;
}
navgen->Run();
delete navgen;
CS_STATIC_VARIABLE_CLEANUP
csInitializer::DestroyApplication(object_reg);
return 0;
}
bool SelfShadowDemo::OnInitialize (int argc, char* argv[])
{
// Default behavior from csDemoApplication
if (!DemoApplication::OnInitialize (argc, argv))
return false;
// Load furmesh for krystal scene
if (!csInitializer::RequestPlugins (GetObjectRegistry (),
CS_REQUEST_PLUGIN("crystalspace.mesh.object.furmesh",
CS::Mesh::iFurMeshType),
CS_REQUEST_END))
return ReportError ("Failed to initialize plugins!");
return true;
}
bool Simple::OnInitialize(int /*argc*/, char* /*argv*/ [])
{
// RequestPlugins() will load all plugins we specify. In addition
// it will also check if there are plugins that need to be loaded
// from the config system (both the application config and CS or
// global configs). In addition it also supports specifying plugins
// on the commandline.
if (!csInitializer::RequestPlugins(GetObjectRegistry(),
CS_REQUEST_VFS,
CS_REQUEST_OPENGL3D,
CS_REQUEST_ENGINE,
CS_REQUEST_FONTSERVER,
CS_REQUEST_IMAGELOADER,
CS_REQUEST_LEVELLOADER,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_PLUGIN( "crystalspace.script.python", iScript ),
CS_REQUEST_END))
return ReportError("Failed to initialize plugins!");
// "Warm up" the event handler so it can interact with the world
csBaseEventHandler::Initialize(GetObjectRegistry());
// Now we need to register the event handler for our application.
// Crystal Space is fully event-driven. Everything (except for this
// initialization) happens in an event.
// Rather than simply handling all events, we subscribe to the
// particular events we're interested in.
csEventID events[] = {
csevFrame (GetObjectRegistry()),
csevKeyboardEvent (GetObjectRegistry()),
CS_EVENTLIST_END
};
if (!RegisterQueue(GetObjectRegistry(), events))
return ReportError("Failed to set up event handler!");
// Report success
return true;
}
CS_IMPLEMENT_APPLICATION
int main (int argc, char *argv[])
{
iObjectRegistry* objreg = csInitializer::CreateEnvironment (argc, argv);
if (! objreg)
{
csFPrintf (stderr, "Failed to create environment!\n");
return 1;
}
bool ok = csInitializer::RequestPlugins (objreg,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_PLUGIN ("crystalspace.script.perl5", iScript),
CS_REQUEST_END);
if (! ok)
{
csFPrintf (stderr, "Failed to load plugins!\n");
return 2;
}
if (csCommandLineHelper::CheckHelp (objreg))
{
csCommandLineHelper::Help (objreg);
return 0;
}
{
csRef<iScript> script = csQueryRegistry<iScript> (objreg);
if (! script)
{
csFPrintf (stderr, "Failed to find perl5 plugin!\n");
return 3;
}
ok = script->LoadModule ("cspace");
//ok = script->LoadModule ("scripts/perl5", "cspace.pm");
if (! ok)
{
csFPrintf (stderr, "Failed to load perl5 cspace module!\n");
return 4;
}
csInitializer::OpenApplication (objreg);
//====================================================================//
csPrintf ("Testing RValue/Store/Retrieve:\n");
int test_int = 3;
float test_float = 3.0;
double test_double = 3.0;
bool test_bool = true;
const char *test_str = "hello";
csPrintf (" Int: ");
csRef<iScriptValue> int_value (script->RValue (test_int));
ok = script->Store("i", int_value);
int_value.AttachNew (script->Retrieve ("i"));
csPrintf ("%d == %d\n", test_int, int_value->GetInt ());
csPrintf (" Float: ");
csRef<iScriptValue> float_value (script->RValue (test_float));
ok = script->Store("f", float_value);
float_value.AttachNew (script->Retrieve ("f"));
csPrintf ("%f == %f\n", test_float, float_value->GetFloat ());
csPrintf (" Double: ");
csRef<iScriptValue> double_value (script->RValue (test_double));
ok = script->Store("d", double_value);
double_value.AttachNew (script->Retrieve ("d"));
csPrintf ("%lf == %lf\n", test_double, double_value->GetDouble ());
csPrintf (" String: ");
csRef<iScriptValue> str_value (script->RValue (test_str));
ok = script->Store("s", str_value);
str_value.AttachNew (script->Retrieve ("s"));
csPrintf ("%s == %s\n", test_str, str_value->GetString ()->GetData ());
csPrintf (" Bool: ");
csRef<iScriptValue> bool_value (script->RValue (test_bool));
ok = script->Store("b", bool_value);
bool_value.AttachNew (script->Retrieve ("b"));
csPrintf ("%s == %s\n\n", test_bool ? "true" : "false",
bool_value->GetBool () ? "true" : "false");
//====================================================================//
csPrintf ("Testing Remove:\n");
ok = script->Remove ("i") && script->Remove ("f") && script->Remove ("d")
&& script->Remove ("s") && script->Remove ("b");
csPrintf (" %s\n", ok ? "ok" : "failed");
int_value.AttachNew (script->Retrieve ("i"));
csPrintf (" %s\n", int_value.IsValid () ? "failed" : "ok");
//====================================================================//
csPrintf ("Testing New(csVector3):\n");
csRef<iScriptObject> obj (script->New ("csVector3"));
csPrintf (" %s\n", obj.IsValid () ? "ok" : "failed");
//====================================================================//
csPrintf ("Testing GetClass/IsA:\n");
csRef<iString> classname (obj->GetClass ());
csPrintf (" %s\n", classname->GetData ());
csPrintf (" %s\n", obj->IsA ("csVector3") ? "ok" : "failed");
//====================================================================//
csPrintf ("Testing Set/Get:\n");
csPrintf (" %f == ", float_value->GetFloat ());
ok = obj->Set ("x", float_value);
float_value.AttachNew (obj->Get ("x"));
csPrintf ("%f\n", float_value->GetFloat ());
//====================================================================//
csPrintf ("Testing Call(csVector3::Set):\n");
csRefArray<iScriptValue> args;
args.Push (float_value);
csRef<iScriptValue> ret (obj->Call ("Set", args));
csPrintf (" %f\n", float_value->GetFloat ());
//====================================================================//
csPrintf ("Testing Call(csVector3::Norm):\n");
ret.AttachNew (obj->Call ("Norm"));
csPrintf (" %f\n", ret->GetFloat ());
//====================================================================//
csPrintf ("Testing GetPointer:\n");
csVector3 &vector = * (csVector3 *) obj->GetPointer ();
vector.Normalize ();
csPrintf (" %f %f %f\n", vector[0], vector[1], vector[2]);
csPrintf (" ok\n");
csPrintf ("All Done!\n");
}
csInitializer::DestroyApplication (objreg);
return 0;
}
bool HeightMapGen::Initialize ()
{
if (!csInitializer::RequestPlugins (object_reg,
CS_REQUEST_VFS,
CS_REQUEST_PLUGIN("crystalspace.graphics3d.null", iGraphics3D),
CS_REQUEST_ENGINE,
CS_REQUEST_FONTSERVER,
CS_REQUEST_IMAGELOADER,
CS_REQUEST_LEVELLOADER,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_PLUGIN("crystalspace.collisiondetection.opcode",
iCollideSystem),
CS_REQUEST_END))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"Can't initialize plugins!");
return false;
}
// Check for commandline help.
if (csCommandLineHelper::CheckHelp (object_reg))
{
csCommandLineHelper::Help (object_reg);
return false;
}
// The virtual clock.
vc = csQueryRegistry<iVirtualClock> (object_reg);
if (!vc)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"Can't find the virtual clock!");
return false;
}
// Find the pointer to engine plugin
engine = csQueryRegistry<iEngine> (object_reg);
if (!engine)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"No iEngine plugin!");
return false;
}
loader = csQueryRegistry<iLoader> (object_reg);
if (!loader)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"No iLoader plugin!");
return false;
}
g3d = csQueryRegistry<iGraphics3D> (object_reg);
if (!g3d)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"No iGraphics3D plugin!");
return false;
}
kbd = csQueryRegistry<iKeyboardDriver> (object_reg);
if (!kbd)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"No iKeyboardDriver plugin!");
return false;
}
// Open the main system. This will open all the previously loaded plug-ins.
if (!csInitializer::OpenApplication (object_reg))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"Error opening system!");
return false;
}
csRef<iCommandLineParser> cmdline =
csQueryRegistry<iCommandLineParser> (object_reg);
const char* configfile = cmdline->GetName (0);
if (!configfile)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.heightmapgen",
"Expected name of a config file as a parameter!");
return false;
}
config.AddConfig (object_reg, configfile);
cfgmgr = (iConfigFile*)config;
if (!LoadMap ()) return false;
return true;
}
bool csWaterDemo::Initialize ()
{
if (!csInitializer::SetupConfigManager (object_reg,
"/config/waterdemo.cfg"))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"Failed to initialize config!");
return false;
}
if (!csInitializer::RequestPlugins (object_reg,
CS_REQUEST_VFS,
CS_REQUEST_PLUGIN ("crystalspace.graphics3d.opengl", iGraphics3D),
CS_REQUEST_ENGINE,
CS_REQUEST_IMAGELOADER,
CS_REQUEST_FONTSERVER,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_CONSOLEOUT,
CS_REQUEST_LEVELLOADER,
CS_REQUEST_END))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"Can't initialize plugins!");
return false;
}
FocusGained = csevFocusGained (object_reg);
FocusLost = csevFocusLost (object_reg);
Frame = csevFrame (object_reg);
KeyboardDown = csevKeyboardDown (object_reg);
if (!csInitializer::SetupEventHandler (object_reg, SimpleEventHandler))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"Can't initialize event handler!");
return false;
}
// Check for commandline help.
if (csCommandLineHelper::CheckHelp (object_reg))
{
csCommandLineHelper::Help (object_reg);
return false;
}
vc = csQueryRegistry<iVirtualClock> (object_reg);
if (vc == 0)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"No iVirtualClock plugin!");
return false;
}
vfs = csQueryRegistry<iVFS> (object_reg);
if (vfs == 0)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"No iVFS plugin!");
return false;
}
r3d = csQueryRegistry<iGraphics3D> (object_reg);
if (r3d == 0)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"No iGraphics3D plugin!");
return false;
}
font = r3d->GetDriver2D ()->GetFontServer()->LoadFont(CSFONT_LARGE);
engine = csQueryRegistry<iEngine> (object_reg);
if (engine == 0)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"No iEngine plugin!");
return false;
}
kbd = csQueryRegistry<iKeyboardDriver> (object_reg);
if (kbd == 0)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"No iKeyboardDriver plugin!");
return false;
}
mouse = csQueryRegistry<iMouseDriver> (object_reg);
if (mouse == 0)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"No iMouseDriver plugin!");
return false;
}
csRef<iLoader> loader = csQueryRegistry<iLoader> (object_reg);
if (loader == 0)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"No iLoader plugin!");
return false;
}
vfs->ChDir ("/tmp");
console = csQueryRegistry<iConsoleOutput> (object_reg);
// Open the main system. This will open all the previously loaded plug-ins.
if (!csInitializer::OpenApplication (object_reg))
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"Error opening system!");
return false;
}
csRef<iSector> room = engine->CreateSector ("room");
view = csPtr<iView> (new csView (engine, r3d));
view->GetCamera ()->SetSector (room);
view->GetCamera ()->GetTransform ().SetOrigin (csVector3 (0, 5, 0));
view->GetCamera ()->GetTransform ().LookAt (csVector3(5,-5,20), csVector3(0,1,0));
csRef<iGraphics2D> g2d = r3d->GetDriver2D ();
view->SetRectangle (0, 0, g2d->GetWidth (), g2d->GetHeight ());
bool hasAccel;
if (g2d->PerformExtension ("hardware_accelerated", &hasAccel))
{
csReport (object_reg, CS_REPORTER_SEVERITY_NOTIFY,
"crystalspace.application.waterdemo",
"Hardware acceleration %s.\n",
hasAccel ? "present" : "not present");
}
else
{
csReport (object_reg, CS_REPORTER_SEVERITY_NOTIFY,
"crystalspace.application.waterdemo",
"Hardware acceleration check not available.\n");
}
r3d->GetDriver2D ()->SetMouseCursor( csmcNone );
csRef<iPluginManager> plugin_mgr (
csQueryRegistry<iPluginManager> (object_reg));
csRef<iStringSet> strings =
csQueryRegistryTagInterface<iStringSet>
(object_reg, "crystalspace.shared.stringset");
csRef<iShaderVarStringSet> stringsSvName =
csQueryRegistryTagInterface<iShaderVarStringSet>
(object_reg, "crystalspace.shader.variablenameset");
//get a custom renderloop
csRef<iRenderLoop> rl = engine->GetRenderLoopManager ()->Create ();
csRef<iRenderStepType> genType = csLoadPlugin<iRenderStepType> (
plugin_mgr, "crystalspace.renderloop.step.generic.type");
csRef<iRenderStepFactory> genFact = genType->NewFactory ();
csRef<iRenderStep> step;
csRef<iGenericRenderStep> genStep;
step = genFact->Create ();
rl->AddStep (step);
genStep = scfQueryInterface<iGenericRenderStep> (step);
genStep->SetShaderType ("general");
genStep->SetZBufMode (CS_ZBUF_USE);
genStep->SetZOffset (false);
engine->GetRenderLoopManager ()->Register ("waterdemoRL", rl);
engine->SetCurrentDefaultRenderloop (rl);
// Load in lighting shaders
csRef<iVFS> vfs (csQueryRegistry<iVFS> (object_reg));
csRef<iFile> shaderFile = vfs->Open ("/shader/water.xml", VFS_FILE_READ);
csRef<iDocumentSystem> docsys (
csQueryRegistry<iDocumentSystem> (object_reg));
csRef<iDocument> shaderDoc = docsys->CreateDocument ();
shaderDoc->Parse (shaderFile, true);
csRef<iShader> shader;
csRef<iShaderManager> shmgr (csQueryRegistry<iShaderManager> (object_reg));
csRef<iShaderCompiler> shcom (shmgr->GetCompiler ("XMLShader"));
csRef<iLoaderContext> ldr_context = engine->CreateLoaderContext ();
shader = shcom->CompileShader (ldr_context,
shaderDoc->GetRoot ()->GetNode ("shader"));
// setup the mesh
csRef<iMeshObjectType> gType = csLoadPluginCheck<iMeshObjectType> (
plugin_mgr, "crystalspace.mesh.object.genmesh");
if (!gType)
{
csReport (object_reg, CS_REPORTER_SEVERITY_ERROR,
"crystalspace.application.waterdemo",
"Error loading genmesh baseobject!");
return false;
}
gFact = gType->NewFactory ();
csRef<iMeshFactoryWrapper> fw = engine->CreateMeshFactory (gFact, "waterFactory");
gFactState = scfQueryInterface<iGeneralFactoryState> (gFact);
gMesh = gFact->NewInstance ();
gMeshState = scfQueryInterface<iGeneralMeshState> (gMesh);
gMeshState->SetShadowCasting (false);
gMeshState->SetShadowReceiving (false);
//setup a wrapper too
gMeshW = engine->CreateMeshWrapper (gMesh, "water", room);
csMatrix3 m;
m.Identity ();
gMeshW->GetMovable ()->SetTransform (m);
gMeshW->GetMovable ()->SetPosition (csVector3(0,-5,0));
gMeshW->GetMovable ()->UpdateMove ();
//setup a material
csRef<iMaterial> mat = engine->CreateBaseMaterial (0);
mat->SetShader (strings->Request ("general"), shader);
csRef<iMaterialWrapper> matW = engine->GetMaterialList ()->NewMaterial (mat,
"waterMaterial");
csRef<csImageCubeMapMaker> cubeMaker;
cubeMaker.AttachNew (new csImageCubeMapMaker ());
csRef<iImage> img = loader->LoadImage ("/lib/cubemap/cubemap_rt.jpg");
cubeMaker->SetSubImage (0, img);
img = loader->LoadImage ("/lib/cubemap/cubemap_lf.jpg");
cubeMaker->SetSubImage (1, img);
img = loader->LoadImage ("/lib/cubemap/cubemap_up.jpg");
cubeMaker->SetSubImage (2, img);
img = loader->LoadImage ("/lib/cubemap/cubemap_dn.jpg");
cubeMaker->SetSubImage (3, img);
img = loader->LoadImage ("/lib/cubemap/cubemap_fr.jpg");
cubeMaker->SetSubImage (4, img);
img = loader->LoadImage ("/lib/cubemap/cubemap_bk.jpg");
cubeMaker->SetSubImage (5, img);
csRef<iTextureHandle> tex = r3d->GetTextureManager ()->RegisterTexture (
cubeMaker, CS_TEXTURE_3D | CS_TEXTURE_CLAMP | CS_TEXTURE_NOMIPMAPS);
csRef<csShaderVariable> attvar (csPtr<csShaderVariable> (
new csShaderVariable (stringsSvName->Request ("tex diffuse"))));
attvar->SetValue (tex);
mat->AddVariable (attvar);
gMesh->SetMaterialWrapper (matW);
Width = Height = 64;
water = new float[Width*Height];
water1 = new float[Width*Height];
water2 = new float[Width*Height];
memset(water,0,Width*Height*sizeof(float));
memset(water1,0,Width*Height*sizeof(float));
memset(water2,0,Width*Height*sizeof(float));
WaveSpeed = 0.3f;
WaveLife = 0.1f;
GridSize = 0.25f;
TimeDelta = 0.12f;
//setup the mesh
gFactState->SetVertexCount (Width*Height);
gFactState->SetTriangleCount (2*((Width-1)*(Height-1)));
//setup ibuf
int x, z, cnt=0,idx;
csTriangle *ibuf=gFactState->GetTriangles ();
for(x=0;x<(Height-1);x++)
{
for(z=0;z<(Width-1);z++)
{
idx = 2*(x*(Width-1)+z);
ibuf[idx].a = x*Width+z;
ibuf[idx].b = x*Width+z+1;
ibuf[idx].c = (x+1)*Width+z;
idx++;
ibuf[idx].a = x*Width+z+1;
ibuf[idx].b = (x+1)*Width+(z+1);
ibuf[idx].c = (x+1)*Width+z;
}
}
//setup our vbuf
csVector3 *vbuf = gFactState->GetVertices ();
cnt=0;
for(x=0;x<Height;x++)
{
for(z=0;z<Width;z++)
{
idx = x*Width+z;
vbuf[idx].x = x*GridSize;
vbuf[idx].y = water[idx];
vbuf[idx].z = z*GridSize;
}
}
//setup texture
csVector2 *tbuf = gFactState->GetTexels ();
for(x=0;x<Height;x++)
{
for(z=0;z<Width;z++)
{
idx = x*Width+z;
tbuf[idx].x = (float)x/(float)Height;
tbuf[idx].y = (float)z/(float)Width;
}
}
lastSimTime = nextSimTime = 0.0f;
gFactState->Invalidate ();
engine->Prepare ();
console->SetVisible (false);
hasfocus = true;
int w = r3d->GetDriver2D ()->GetWidth()/2;
int h = r3d->GetDriver2D ()->GetHeight()/2;
r3d->GetDriver2D ()->SetMousePosition (w, h);
printer.AttachNew (new FramePrinter (object_reg));
return true;
}
bool AvatarTest::OnInitialize (int /*argc*/, char* /*argv*/ [])
{
// Check for commandline help.
if (csCommandLineHelper::CheckHelp (GetObjectRegistry ()))
{
csPrintf ("Usage: avatartest\n");
csPrintf ("Tests on animesh animation\n\n");
csPrintf ("Options for avatartest:\n");
csPrintf (" -model=<name>: set the starting model (frankie, krystal)\n");
csPrintf (" -no_physics: disable physical animations\n");
csCommandLineHelper::Help (GetObjectRegistry ());
return false;
}
if (!csInitializer::RequestPlugins (GetObjectRegistry (),
CS_REQUEST_VFS,
CS_REQUEST_OPENGL3D,
CS_REQUEST_ENGINE,
CS_REQUEST_FONTSERVER,
CS_REQUEST_IMAGELOADER,
CS_REQUEST_LEVELLOADER,
CS_REQUEST_REPORTER,
CS_REQUEST_REPORTERLISTENER,
CS_REQUEST_PLUGIN ("crystalspace.mesh.animesh.controllers.lookat",
iSkeletonLookAtManager2),
CS_REQUEST_PLUGIN ("crystalspace.mesh.animesh.controllers.basic",
iSkeletonBasicNodesManager2),
CS_REQUEST_END))
return ReportError ("Failed to initialize plugins!");
csBaseEventHandler::Initialize (GetObjectRegistry ());
if (!RegisterQueue (GetObjectRegistry (), csevAllEvents (GetObjectRegistry ())))
return ReportError ("Failed to set up event handler!");
// Check if physics effects are enabled
csRef<iCommandLineParser> clp =
csQueryRegistry<iCommandLineParser> (GetObjectRegistry ());
physicsEnabled = !clp->GetBoolOption ("no_physics", false);
if (physicsEnabled)
{
// Load the Bullet plugin
csRef<iPluginManager> plugmgr =
csQueryRegistry<iPluginManager> (GetObjectRegistry ());
dynamics = csLoadPlugin<iDynamics> (plugmgr, "crystalspace.dynamics.bullet");
if (!dynamics)
{
ReportWarning
("Can't load Bullet plugin, continuing with reduced functionalities");
physicsEnabled = false;
}
}
// Read which model to display at first
csString modelName = clp->GetOption ("model");
if (modelName != "krystal")
avatarModel = MODEL_FRANKIE;
else
avatarModel = MODEL_KRYSTAL;
return true;
}