void ScriptSerializerManager::initializeConfig(const String& configFileName) {
ConfigFile configFile;
Archive* workingDirectory = ArchiveManager::getSingleton().load(".", "FileSystem");
if (workingDirectory->exists(configFileName)) {
DataStreamPtr configStream = workingDirectory->open(configFileName);
configFile.load(configStream);
configStream->close();
}
else {
stringstream message;
message << "WARNING: Cannot find Script Cache config file:" << configFileName << ". Using default values";
LogManager::getSingleton().logMessage(message.str());
}
binaryScriptExtension = configFile.getSetting("extension", "ScriptCache", ".sbin");
scriptCacheLocation = configFile.getSetting("location", "ScriptCache", ".scriptCache");
shaderCacheFilename = configFile.getSetting("filename", "ShaderCache", "ShaderCache");
String searchExtensions = configFile.getSetting("searchExtensions", "ScriptCache", "program material particle compositor os pu");
istringstream extensions(searchExtensions);
String extension;
while (extensions >> extension) {
stringstream pattern;
pattern << "*." << extension << binaryScriptExtension;
ScriptCompilerManager::getSingleton().addScriptPattern(pattern.str());
}
}
time_t ScriptSerializerManager::getBinaryTimeStamp(const String& filename) {
DataStreamPtr stream = mCacheArchive->open(filename);
ScriptBlock::ScriptHeader header;
stream->read(reinterpret_cast<char*>(&header), sizeof(ScriptBlock::ScriptHeader));
stream->close();
return header.lastModifiedTime;
}
void ScriptSerializerManager::saveShaderCache() {
#ifdef USE_MICROCODE_SHADERCACHE
// A previously cached shader file exists. load it
DataStreamPtr shaderCache = mCacheArchive->create(shaderCacheFilename);
mShaderSerializer->saveCache(shaderCache);
shaderCache->close();
#endif
}
AbstractNodeListPtr ScriptSerializerManager::loadAstFromDisk(const String& filename) {
DataStreamPtr stream = mCacheArchive->open(filename);
ScriptSerializer* serializer = OGRE_NEW ScriptSerializer();
AbstractNodeListPtr ast = serializer->deserialize(stream);
OGRE_DELETE serializer;
stream->close();
return ast;
}
void ScriptSerializerManager::saveAstToDisk(const String& filename, size_t scriptTimestamp, const AbstractNodeListPtr& ast) {
// A text script was just parsed. Save the compiled AST to disk
DataStreamPtr stream = mCacheArchive->create(filename);
ScriptSerializer* serializer = OGRE_NEW ScriptSerializer();
serializer->serialize(stream, ast, scriptTimestamp);
OGRE_DELETE serializer;
stream->close();
}
//-----------------------------------------------------------------------
void RenderSystemCapabilitiesManager::parseCapabilitiesFromArchive(const String& filename, const String& archiveType, bool recursive)
{
// get the list of .rendercaps files
Archive* arch = ArchiveManager::getSingleton().load(filename, archiveType);
StringVectorPtr files = arch->find(mScriptPattern, recursive);
// loop through .rendercaps files and load each one
for (StringVector::iterator it = files->begin(), end = files->end(); it != end; it++)
{
DataStreamPtr stream = arch->open(*it);
mSerializer->parseScript(stream);
stream->close();
}
}
void FileSystemArchiveTests::testCreateAndRemoveFile()
{
FileSystemArchive arch("./", "FileSystem");
arch.load();
CPPUNIT_ASSERT(!arch.isReadOnly());
String fileName = "a_test_file.txt";
DataStreamPtr stream = arch.create(fileName);
String testString = "Some text here";
size_t written = stream->write((void*)testString.c_str(), testString.size());
CPPUNIT_ASSERT_EQUAL(testString.size(), written);
stream->close();
arch.remove(fileName);
CPPUNIT_ASSERT(!arch.exists(fileName));
}
//---------------------------------------------------------------------
void PlayPen_testPoseAnimationWithoutNormals::setupContent()
{
mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
Vector3 dir(-1, -1, 0.5);
dir.normalise();
Light* l = mSceneMgr->createLight("light1");
l->setType(Light::LT_DIRECTIONAL);
l->setDirection(dir);
MeshPtr mesh = MeshManager::getSingleton().load("cube.mesh",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
String newName = "testposenonormals.mesh";
mesh = mesh->clone(newName);
SubMesh* sm = mesh->getSubMesh(0);
// Re-organise geometry since this mesh has no animation and all
// vertex elements are packed into one buffer
VertexDeclaration* newDecl =
sm->vertexData->vertexDeclaration->getAutoOrganisedDeclaration(false, true, false);
sm->vertexData->reorganiseBuffers(newDecl);
// create 2 poses
Pose* pose = mesh->createPose(1, "pose1");
// Pose1 moves vertices 0, 1, 2 and 3 upward
Vector3 offset1(0, 50, 0);
pose->addVertex(0, offset1);
pose->addVertex(1, offset1);
pose->addVertex(2, offset1);
pose->addVertex(3, offset1);
pose = mesh->createPose(1, "pose2");
// Pose2 moves vertices 3, 4, and 5 to the right
// Note 3 gets affected by both
Vector3 offset2(100, 0, 0);
pose->addVertex(3, offset2);
pose->addVertex(4, offset2);
pose->addVertex(5, offset2);
Animation* anim = mesh->createAnimation("poseanim", 20.0f);
VertexAnimationTrack* vt = anim->createVertexTrack(1, sm->vertexData, VAT_POSE);
// Frame 0 - no effect
VertexPoseKeyFrame* kf = vt->createVertexPoseKeyFrame(0);
// Frame 1 - bring in pose 1 (index 0)
kf = vt->createVertexPoseKeyFrame(3);
kf->addPoseReference(0, 1.0f);
// Frame 2 - remove all
kf = vt->createVertexPoseKeyFrame(6);
// Frame 3 - bring in pose 2 (index 1)
kf = vt->createVertexPoseKeyFrame(9);
kf->addPoseReference(1, 1.0f);
// Frame 4 - remove all
kf = vt->createVertexPoseKeyFrame(12);
// Frame 5 - bring in pose 1 at 50%, pose 2 at 100%
kf = vt->createVertexPoseKeyFrame(15);
kf->addPoseReference(0, 0.5f);
kf->addPoseReference(1, 1.0f);
// Frame 6 - bring in pose 1 at 100%, pose 2 at 50%
kf = vt->createVertexPoseKeyFrame(18);
kf->addPoseReference(0, 1.0f);
kf->addPoseReference(1, 0.5f);
// Frame 7 - reset
kf = vt->createVertexPoseKeyFrame(20);
// Export the mesh
DataStreamPtr stream = Root::getSingleton().createFileStream(newName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
MeshSerializer ser;
ser.exportMesh(mesh.get(), stream);
stream->close();
// Unload old mesh to force reload
MeshManager::getSingleton().remove(mesh->getHandle());
mesh->unload();
mesh.setNull();
Entity* e;
AnimationState* animState;
// software pose
e = mSceneMgr->createEntity("test2", newName);
mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(150,0,0))->attachObject(e);
animState = e->getAnimationState("poseanim");
animState->setEnabled(true);
animState->setWeight(1.0f);
mAnimStateList.push_back(animState);
// test hardware pose
e = mSceneMgr->createEntity("test", newName);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(e);
e->setMaterialName("Examples/HardwarePoseAnimation");
animState = e->getAnimationState("poseanim");
animState->setEnabled(true);
animState->setWeight(1.0f);
mAnimStateList.push_back(animState);
mCamera->setNearClipDistance(0.5);
Plane plane;
plane.normal = Vector3::UNIT_Y;
plane.d = 200;
MeshManager::getSingleton().createPlane("Myplane",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
1500,1500,10,10,true,1,5,5,Vector3::UNIT_Z);
Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
pPlaneEnt->setMaterialName("2 - Default");
pPlaneEnt->setCastShadows(false);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
mCamera->setPosition(0,-200,-300);
mCamera->lookAt(0,0,0);
}
//---------------------------------------------------------------------
void PlayPen_testMorphAnimationWithoutNormals::setupContent()
{
bool testStencil = false;
if (testStencil)
mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE);
mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
Vector3 dir(-1, -1, 0.5);
dir.normalise();
Light* l = mSceneMgr->createLight("light1");
l->setType(Light::LT_DIRECTIONAL);
l->setDirection(dir);
MeshPtr mesh = MeshManager::getSingleton().load("sphere.mesh",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
String morphName = "testmorphnonormals.mesh";
mesh = mesh->clone(morphName);
SubMesh* sm = mesh->getSubMesh(0);
// Re-organise geometry since this mesh has no animation and all
// vertex elements are packed into one buffer
VertexDeclaration* newDecl =
sm->vertexData->vertexDeclaration->getAutoOrganisedDeclaration(false, true, false);
sm->vertexData->reorganiseBuffers(newDecl);
if (testStencil)
sm->vertexData->prepareForShadowVolume(); // need to re-prep since reorganised
// get the position buffer (which should now be separate);
const VertexElement* posElem =
sm->vertexData->vertexDeclaration->findElementBySemantic(VES_POSITION);
HardwareVertexBufferSharedPtr origbuf =
sm->vertexData->vertexBufferBinding->getBuffer(
posElem->getSource());
// Create a new position & normal buffer with updated values
HardwareVertexBufferSharedPtr newbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
VertexElement::getTypeSize(VET_FLOAT3),
sm->vertexData->vertexCount,
HardwareBuffer::HBU_STATIC, true);
float* pSrc = static_cast<float*>(origbuf->lock(HardwareBuffer::HBL_READ_ONLY));
float* pDst = static_cast<float*>(newbuf->lock(HardwareBuffer::HBL_DISCARD));
// Make the sphere turn into a cube
// Do this just by clamping each of the directions (we shrink it)
float cubeDimension = 0.3f * mesh->getBoundingSphereRadius();
for (size_t v = 0; v < sm->vertexData->vertexCount; ++v)
{
// x/y/z position
Vector3 pos;
for (int d = 0; d < 3; ++d)
{
if (*pSrc >= 0)
{
pos.ptr()[d] = std::min(cubeDimension, *pSrc++);
}
else
{
pos.ptr()[d] = std::max(-cubeDimension, *pSrc++);
}
*pDst++ = pos.ptr()[d];
}
}
origbuf->unlock();
newbuf->unlock();
// create a morph animation
Animation* anim = mesh->createAnimation("testAnim", 10.0f);
VertexAnimationTrack* vt = anim->createVertexTrack(1, sm->vertexData, VAT_MORPH);
// re-use start positions for frame 0
VertexMorphKeyFrame* kf = vt->createVertexMorphKeyFrame(0);
kf->setVertexBuffer(origbuf);
// Use translated buffer for mid frame
kf = vt->createVertexMorphKeyFrame(4.0f);
kf->setVertexBuffer(newbuf);
// Pause there
kf = vt->createVertexMorphKeyFrame(6.0f);
kf->setVertexBuffer(newbuf);
// re-use start positions for final frame
kf = vt->createVertexMorphKeyFrame(10.0f);
kf->setVertexBuffer(origbuf);
// Export the mesh
DataStreamPtr stream = Root::getSingleton().createFileStream(morphName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
MeshSerializer ser;
ser.exportMesh(mesh.get(), stream);
stream->close();
// Unload old mesh to force reload
MeshManager::getSingleton().remove(mesh->getHandle());
mesh->unload();
mesh.setNull();
Entity* e = mSceneMgr->createEntity("test", morphName);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(e);
AnimationState* animState = e->getAnimationState("testAnim");
animState->setEnabled(true);
animState->setWeight(1.0f);
mAnimStateList.push_back(animState);
e = mSceneMgr->createEntity("test2", morphName);
mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(200,0,0))->attachObject(e);
// test hardware morph
e->setMaterialName("Examples/HardwareMorphAnimation");
animState = e->getAnimationState("testAnim");
animState->setEnabled(true);
animState->setWeight(1.0f);
mAnimStateList.push_back(animState);
mCamera->setNearClipDistance(0.5);
mCamera->setPosition(0,100,-400);
mCamera->lookAt(Vector3::ZERO);
//mSceneMgr->setShowDebugShadows(true);
Plane plane;
plane.normal = Vector3::UNIT_Y;
plane.d = 200;
MeshManager::getSingleton().createPlane("Myplane",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
1500,1500,10,10,true,1,5,5,Vector3::UNIT_Z);
Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
pPlaneEnt->setMaterialName("2 - Default");
pPlaneEnt->setCastShadows(false);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
}
void DotSceneLoader::parseDotScene(const String &SceneName, const String &groupName, SceneManager *yourSceneMgr, SceneNode *pAttachNode, const String &sPrependNode)
{
// set up shared object values
m_sGroupName = groupName;
mSceneMgr = yourSceneMgr;
m_sPrependNode = sPrependNode;
staticObjects.clear();
dynamicObjects.clear();
TiXmlDocument *XMLDoc = 0;
TiXmlElement *XMLRoot;
try
{
// Strip the path
Ogre::String basename, path;
Ogre::StringUtil::splitFilename(SceneName, basename, path);
DataStreamPtr pStream = ResourceGroupManager::getSingleton().
openResource( basename, groupName );
//DataStreamPtr pStream = ResourceGroupManager::getSingleton().
// openResource( SceneName, groupName );
String data = pStream->getAsString();
// Open the .scene File
XMLDoc = new TiXmlDocument();
XMLDoc->Parse( data.c_str() );
pStream->close();
pStream.setNull();
if( XMLDoc->Error() )
{
//We'll just log, and continue on gracefully
LogManager::getSingleton().logMessage("[DotSceneLoader] The TiXmlDocument reported an error");
delete XMLDoc;
return;
}
}
catch(...)
{
//We'll just log, and continue on gracefully
LogManager::getSingleton().logMessage("[DotSceneLoader] Error creating TiXmlDocument");
delete XMLDoc;
return;
}
// Validate the File
XMLRoot = XMLDoc->RootElement();
if( String( XMLRoot->Value()) != "scene" ) {
LogManager::getSingleton().logMessage( "[DotSceneLoader] Error: Invalid .scene File. Missing <scene>" );
delete XMLDoc;
return;
}
// figure out where to attach any nodes we create
mAttachNode = pAttachNode;
if(!mAttachNode)
mAttachNode = mSceneMgr->getRootSceneNode();
// Process the scene
processScene(XMLRoot);
// Close the XML File
delete XMLDoc;
}
void DotSceneLoader::parseDotScene(const String &SceneName, const String &groupName, SceneManager *yourSceneMgr, CPhysicsManager *pPhysicsManager, SceneNode *pAttachNode, const String &sPrependNode)
{
cleanup();
Ogre::LogManager::getSingleton().logMessage("Loading dot scene: " + SceneName);
// set up shared object values
m_sGroupName = groupName;
mSceneMgr = yourSceneMgr;
m_pPhysicsManager = pPhysicsManager;
m_sPrependNode = sPrependNode;
mStaticSceneNode = pAttachNode->createChildSceneNode(sPrependNode + "StaticSceneNode");
XMLDocument *XMLDoc = 0;
XMLElement *XMLRoot;
try
{
// Strip the path
Ogre::String basename, path;
Ogre::StringUtil::splitFilename(SceneName, basename, path);
// Do not look in other groups but the given one
DataStreamPtr pStream = ResourceGroupManager::getSingleton().
openResource( basename, groupName, false );
//DataStreamPtr pStream = ResourceGroupManager::getSingleton().
// openResource( SceneName, groupName );
String data = pStream->getAsString();
// Open the .scene File
XMLDoc = new XMLDocument();
XMLDoc->Parse( data.c_str() );
pStream->close();
pStream.setNull();
if( XMLDoc->Error() )
{
//We'll just log, and continue on gracefully
LogManager::getSingleton().logMessage("[DotSceneLoader] The TiXmlDocument reported an error");
delete XMLDoc;
return;
}
}
catch(...)
{
//We'll just log, and continue on gracefully
LogManager::getSingleton().logMessage("[DotSceneLoader] Error creating TiXmlDocument");
delete XMLDoc;
return;
}
// Validate the File
XMLRoot = XMLDoc->RootElement();
if( String( XMLRoot->Value()) != "scene" ) {
LogManager::getSingleton().logMessage( "[DotSceneLoader] Error: Invalid .scene File. Missing <scene>" );
delete XMLDoc;
return;
}
// figure out where to attach any nodes we create
mAttachNode = pAttachNode;
if(!mAttachNode)
mAttachNode = mSceneMgr->getRootSceneNode();
// Process the scene
processScene(XMLRoot);
/*for (auto &m : m_mStaticGeometryMap) {
m.second->build();
}*/
/*for (auto &s : mStaticObjects) {
for (auto &cb : m_lCallbacks){
cb->staticObjectAdded(s);
}
}
// remove static geometry entities
destroySceneNode(mStaticSceneNode);*/
// apply manually material data
// ===============================
// dont cull grass
auto mat = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName("CS_Grass"));
if (!mat.isNull() && mat->getBestTechnique()) {
mat->getBestTechnique()->setCullingMode(Ogre::CullingMode::CULL_NONE);
}
// make water transparent, add textures
mat = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName("Water"));
if (!mat.isNull() && mat->getBestTechnique()) {
mat->getBestTechnique()->setCullingMode(Ogre::CullingMode::CULL_NONE);
mat->getBestTechnique()->getPass(0)->setDepthCheckEnabled(true);
mat->getBestTechnique()->getPass(0)->setDepthWriteEnabled(false);
mat->getBestTechnique()->getPass(0)->setSceneBlending(Ogre::SBF_SOURCE_ALPHA, Ogre::SBF_ONE);
mat->getBestTechnique()->getPass(0)->getTextureUnitState(0)->setTransformAnimation(
Ogre::TextureUnitState::TT_TRANSLATE_U, Ogre::WFT_SINE, 0, 0.25, 0, 0.125);
mat->getBestTechnique()->getPass(0)->getTextureUnitState(0)->setColourOperation(Ogre::LBO_MODULATE);
mat->getBestTechnique()->getPass(0)->getTextureUnitState(1)->setTransformAnimation(
Ogre::TextureUnitState::TT_TRANSLATE_V, Ogre::WFT_SINE, 0.1, 0.25, 0.1, 0.125);
mat->getBestTechnique()->getPass(0)->getTextureUnitState(1)->setTextureRotate(Ogre::Degree(90));
mat->getBestTechnique()->getPass(0)->getTextureUnitState(1)->setColourOperation(Ogre::LBO_MODULATE);
mat->getBestTechnique()->getPass(0)->setDiffuse(1, 1, 1, 0.8);
}
/*for (auto &m : m_lEntityBufferMap) {
mSceneMgr->destroyEntity(m.second);
}*/
// Close the XML File
delete XMLDoc;
// remove callbacks
m_lCallbacks.clear();
cleanup();
}
