void csWrappedDocumentNode::ProcessInclude (const TempString<>& filename,
NodeProcessingState* state,
iDocumentNode* node)
{
iVFS* vfs = globalState->vfs;
csRef<iDataBuffer> pathExpanded = vfs->ExpandPath (filename);
csRef<iDocumentNode> includeNode;
includeNode = globalState->includesCache.Get (pathExpanded->GetData(),
(iDocumentNode*)0);
if (!includeNode.IsValid())
{
csRef<iFile> include = vfs->Open (filename, VFS_FILE_READ);
if (!include.IsValid ())
{
Report (syntaxErrorSeverity, node,
"could not open %s", CS::Quote::Single (filename.GetData ()));
}
else
{
csRef<iDocumentSystem> docsys (
csQueryRegistry<iDocumentSystem> (shared->objreg));
if (!docsys.IsValid())
docsys.AttachNew (new csTinyDocumentSystem ());
csRef<iDocument> includeDoc = docsys->CreateDocument ();
const char* err = includeDoc->Parse (include, false);
if (err != 0)
{
Report (syntaxErrorSeverity, node,
"error parsing %s: %s", CS::Quote::Single (filename.GetData ()), err);
return;
}
else
{
csRef<iDocumentNode> rootNode = includeDoc->GetRoot ();
includeNode = rootNode->GetNode ("include");
if (!includeNode)
{
Report (syntaxErrorSeverity, rootNode,
"%s: no <include> node", filename.GetData ());
return;
}
globalState->includesCache.Put (pathExpanded->GetData(),
includeNode);
}
}
}
csVfsDirectoryChanger dirChange (vfs);
dirChange.ChangeTo (filename);
csRef<iDocumentNodeIterator> it = includeNode->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
ProcessSingleWrappedNode (state, child);
}
}
iShader* csStencilShadowType::GetShadow ()
{
if (!shadowLoaded)
{
shadowLoaded = true;
csRef<iPluginManager> plugin_mgr (
csQueryRegistry<iPluginManager> (object_reg));
// Load the shadow vertex program
csRef<iShaderManager> shmgr = csQueryRegistryOrLoad<iShaderManager> (
object_reg, "crystalspace.graphics3d.shadermanager");
if (!shmgr) return 0;
csRef<iShaderCompiler> shcom (shmgr->GetCompiler ("XMLShader"));
csRef<iVFS> vfs = csQueryRegistry<iVFS> (object_reg);
csRef<iDataBuffer> buf = vfs->ReadFile ("/shader/shadow.xml");
//csRef<iDataBuffer> buf = vfs->ReadFile ("/shader/shadowdebug.xml");
csRef<iDocumentSystem> docsys (
csQueryRegistry<iDocumentSystem> (object_reg));
if (docsys == 0)
{
docsys.AttachNew (new csTinyDocumentSystem ());
}
csRef<iDocument> shaderDoc = docsys->CreateDocument ();
shaderDoc->Parse (buf, true);
// @@@ TODO: Try to get a right ldr_context here???
shadow = shcom->CompileShader (0,
shaderDoc->GetRoot ()->GetNode ("shader"));
if (!shadow)
{
Report (CS_REPORTER_SEVERITY_ERROR, "Unable to load shadow shader");
return 0;
}
}
return shadow;
}
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;
}
