void WorkspaceWidget::showDialog()
{
NewMaterialDialog *newMaterial = new NewMaterialDialog(this);
newMaterial->show();
MaterialManager *matMgr = MaterialManager::getSingletonPtr();
Ogre::LogManager::getSingleton().logMessage("Working dir: " + matMgr->getWorkDir().toStdString());
}
void SceneLabel::updateFromLabel() {
MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager();
if(texture)
materialManager->deleteTexture(texture);
texture = materialManager->createTextureFromImage(label, materialManager->clampDefault, materialManager->mipmapsDefault);
if(material) {
localShaderOptions->clearTexture("diffuse");
localShaderOptions->addTexture("diffuse", texture);
}
delete mesh;
mesh = new Mesh(Mesh::QUAD_MESH);
mesh->createVPlane(label->getWidth()*scale,label->getHeight()*scale);
bBox.x = label->getWidth()*scale;
bBox.y = label->getHeight()*scale;
bBox.z = 0;
if(useVertexBuffer)
CoreServices::getInstance()->getRenderer()->createVertexBufferForMesh(mesh);
// TODO: resize it here
bBoxRadius = label->getWidth()*scale;
}
//----------------------------------------------------------------------------
GraphicsRoot::~GraphicsRoot ()
{
MaterialManager *mi = MaterialManager::GetSingletonPtr();
if (mi)
{
mi->Terminate();
delete0(mi);
MaterialManager::Set(0);
}
}
void MeshWithoutIndexDataTests::setUp()
{
LogManager::getSingleton().createLog("MeshWithoutIndexDataTests.log", true);
OGRE_NEW ResourceGroupManager();
OGRE_NEW LodStrategyManager();
mBufMgr = OGRE_NEW DefaultHardwareBufferManager();
mMeshMgr = OGRE_NEW MeshManager();
archiveMgr = OGRE_NEW ArchiveManager();
archiveMgr->addArchiveFactory(OGRE_NEW FileSystemArchiveFactory());
MaterialManager* matMgr = OGRE_NEW MaterialManager();
matMgr->initialise();
}
Geometry* SceneLoader::LoadGeometry(QDomElement element)
{
Geometry* geom = GeometryPool::Get()->GetGeometry(_geometryName, _geometryIdx);
if (geom)
{
return geom;
}
if (element.nodeName() != QString ("geometry"))
{
printf ("ceXMLDataLoader::LoadGeometry: Illegal data format: '%s' != 'geometry'\n", element.nodeName().toStdString().c_str()); fflush (stdout);
return 0;
}
geom = new Geometry ();
QDomElement staticElement = element.firstChildElement("staticmesh");
if (!staticElement.isNull())
{
ceMesh* mesh = LoadMesh (staticElement);
if (!mesh)
{
geom->Release();
return 0;
}
iStaticMesh* staticMesh = _engine->GetDevice()->CreateStaticMesh();
staticMesh->SetMesh(mesh);
geom->SetMesh(staticMesh);
geom->SetMetaMesh(MT_Static,
staticElement.firstChildElement("mesh").attribute("filename"));
}
MaterialManager* matMgr = Session::Get()->GetMaterialManager();
QDomElement materialElement = element.firstChildElement("material");
Material* mat = 0;
if (!materialElement.isNull())
{
mat = matMgr->GetMaterial(materialElement.text());
}
if (!mat)
{
mat = matMgr->GetDefaultMaterial();
}
geom->SetMetaMaterial(mat);
GeometryPool::Get()->Set(_geometryName, _geometryIdx, geom);
return geom;
}
Texture* MdlFileImport::loadTexture( mstudiotexture_t& texDesc , uint8* data )
{
int texArea = texDesc.height * texDesc.width;
uint8* pal = data + texArea;
std::vector< uint8 > texData( texArea * 4 );
uint32* pColor = (uint32*) &texData[0];
for( int i = 0 ; i < texArea ; ++i )
{
uint8* palC = pal + 3 * data[i];
pColor[i] = Color::toARGB( palC[0] , palC[1], palC[2] , 255 );
}
MaterialManager* manager = mScene->getWorld()->_getMaterialManager();
Texture* texture = manager->createTexture2D( texDesc.name , CF_TEX_FMT_ARGB32 , &texData[0] , texDesc.width , texDesc.height );
return texture;
}
void SetTexturePack (ceTexturePack* pack)
{
for (unsigned rp=0; rp<RP_Count; rp++)
{
for (unsigned ts=0; ts<TS_Count; ts++)
{
iTexture* txt = pack->GetTexture((ceRenderPass)rp, (ceTextureStage)ts);
_textures[rp][ts] = _manager->FindTexture(txt);
}
}
}
void ImpostorTexture::renderTextures(bool force)
{
#ifdef IMPOSTOR_FILE_SAVE
TexturePtr renderTexture;
#else
TexturePtr renderTexture(texture);
//if we're not using a file image we need to set up a resource loader, so that the texture is regenerated if it's ever unloaded (such as switching between fullscreen and the desktop in win32)
loader = std::auto_ptr<ImpostorTextureResourceLoader>(new ImpostorTextureResourceLoader(*this));
#endif
RenderTexture *renderTarget;
Camera *renderCamera;
Viewport *renderViewport;
SceneNode *camNode;
//Set up RTT texture
uint32 textureSize = ImpostorPage::impostorResolution;
if (renderTexture.isNull()) {
renderTexture = TextureManager::getSingleton().createManual(getUniqueID("ImpostorTexture"), "Impostors",
TEX_TYPE_2D, textureSize * IMPOSTOR_YAW_ANGLES, textureSize * IMPOSTOR_PITCH_ANGLES, 0, PF_A8R8G8B8, TU_RENDERTARGET, loader.get());
}
renderTexture->setNumMipmaps(MIP_UNLIMITED);
//Set up render target
renderTarget = renderTexture->getBuffer()->getRenderTarget();
renderTarget->setAutoUpdated(false);
//Set up camera
camNode = sceneMgr->getSceneNode("ImpostorPage::cameraNode");
renderCamera = sceneMgr->createCamera(getUniqueID("ImpostorCam"));
camNode->attachObject(renderCamera);
renderCamera->setLodBias(1000.0f);
renderViewport = renderTarget->addViewport(renderCamera);
renderViewport->setOverlaysEnabled(false);
renderViewport->setClearEveryFrame(true);
renderViewport->setShadowsEnabled(false);
renderViewport->setBackgroundColour(ImpostorPage::impostorBackgroundColor);
//Set up scene node
SceneNode* node = sceneMgr->getSceneNode("ImpostorPage::renderNode");
Ogre::SceneNode* oldSceneNode = entity->getParentSceneNode();
if (oldSceneNode) {
oldSceneNode->detachObject(entity);
}
node->attachObject(entity);
node->setPosition(-entityCenter);
//Set up camera FOV
const Real objDist = entityRadius * 100;
const Real nearDist = objDist - (entityRadius + 1);
const Real farDist = objDist + (entityRadius + 1);
renderCamera->setAspectRatio(1.0f);
renderCamera->setFOVy(Math::ATan(entityDiameter / objDist));
renderCamera->setNearClipDistance(nearDist);
renderCamera->setFarClipDistance(farDist);
//Disable mipmapping (without this, masked textures look bad)
MaterialManager *mm = MaterialManager::getSingletonPtr();
FilterOptions oldMinFilter = mm->getDefaultTextureFiltering(FT_MIN);
FilterOptions oldMagFilter = mm->getDefaultTextureFiltering(FT_MAG);
FilterOptions oldMipFilter = mm->getDefaultTextureFiltering(FT_MIP);
mm->setDefaultTextureFiltering(FO_POINT, FO_LINEAR, FO_NONE);
//Disable fog
FogMode oldFogMode = sceneMgr->getFogMode();
ColourValue oldFogColor = sceneMgr->getFogColour();
Real oldFogDensity = sceneMgr->getFogDensity();
Real oldFogStart = sceneMgr->getFogStart();
Real oldFogEnd = sceneMgr->getFogEnd();
sceneMgr->setFog(Ogre::FOG_EXP2, Ogre::ColourValue(0,0,0,0), 0.0f, 0.0f, 0.0f); //Ember change
//We need to disable all lightning and render it full bright
Ogre::ColourValue oldAmbientColour = sceneMgr->getAmbientLight();
sceneMgr->setAmbientLight(ColourValue::White);
std::vector<Ogre::MovableObject*> lightStore;
Ogre::SceneManager::MovableObjectIterator lightIterator = sceneMgr->getMovableObjectIterator(Ogre::LightFactory::FACTORY_TYPE_NAME);
while (lightIterator.hasMoreElements()) {
Ogre::MovableObject* light = lightIterator.getNext();
if (light) {
if (light->getVisible()) {
lightStore.push_back(light);
light->setVisible(false);
}
}
}
// Get current status of the queue mode
Ogre::SceneManager::SpecialCaseRenderQueueMode OldSpecialCaseRenderQueueMode = sceneMgr->getSpecialCaseRenderQueueMode();
//Only render the entity
sceneMgr->setSpecialCaseRenderQueueMode(Ogre::SceneManager::SCRQM_INCLUDE);
sceneMgr->addSpecialCaseRenderQueue(group->geom->getRenderQueue() + 1);
uint8 oldRenderQueueGroup = entity->getRenderQueueGroup();
entity->setRenderQueueGroup(group->geom->getRenderQueue() + 1);
bool oldVisible = entity->getVisible();
entity->setVisible(true);
float oldMaxDistance = entity->getRenderingDistance();
entity->setRenderingDistance(0);
bool needsRegen = true;
#ifdef IMPOSTOR_FILE_SAVE
//Calculate the filename hash used to uniquely identity this render
String strKey = entityKey;
char key[32] = {0};
uint32 i = 0;
for (String::const_iterator it = entityKey.begin(); it != entityKey.end(); ++it)
{
key[i] ^= *it;
i = (i+1) % sizeof(key);
}
for (i = 0; i < sizeof(key); ++i)
key[i] = (key[i] % 26) + 'A';
String tempdir = this->group->geom->getTempdir();
ResourceGroupManager::getSingleton().addResourceLocation(tempdir, "FileSystem", "BinFolder");
String fileNamePNG = "Impostor." + String(key, sizeof(key)) + '.' + StringConverter::toString(textureSize) + ".png";
String fileNameDDS = "Impostor." + String(key, sizeof(key)) + '.' + StringConverter::toString(textureSize) + ".dds";
//Attempt to load the pre-render file if allowed
needsRegen = force;
if (!needsRegen){
try{
texture = TextureManager::getSingleton().load(fileNameDDS, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED);
}
catch (...){
try{
texture = TextureManager::getSingleton().load(fileNamePNG, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED);
}
catch (...){
needsRegen = true;
}
}
}
#endif
if (needsRegen){
//If this has not been pre-rendered, do so now
const float xDivFactor = 1.0f / IMPOSTOR_YAW_ANGLES;
const float yDivFactor = 1.0f / IMPOSTOR_PITCH_ANGLES;
for (int o = 0; o < IMPOSTOR_PITCH_ANGLES; ++o){ //4 pitch angle renders
#ifdef IMPOSTOR_RENDER_ABOVE_ONLY
Radian pitch = Degree((90.0f * o) * yDivFactor); //0, 22.5, 45, 67.5
#else
Radian pitch = Degree((180.0f * o) * yDivFactor - 90.0f);
#endif
for (int i = 0; i < IMPOSTOR_YAW_ANGLES; ++i){ //8 yaw angle renders
Radian yaw = Degree((360.0f * i) * xDivFactor); //0, 45, 90, 135, 180, 225, 270, 315
//Position camera
camNode->setPosition(0, 0, 0);
camNode->setOrientation(Quaternion(yaw, Vector3::UNIT_Y) * Quaternion(-pitch, Vector3::UNIT_X));
camNode->translate(Vector3(0, 0, objDist), Node::TS_LOCAL);
//Render the impostor
renderViewport->setDimensions((float)(i) * xDivFactor, (float)(o) * yDivFactor, xDivFactor, yDivFactor);
renderTarget->update();
}
}
#ifdef IMPOSTOR_FILE_SAVE
//Save RTT to file with respecting the temp dir
renderTarget->writeContentsToFile(tempdir + fileNamePNG);
//Load the render into the appropriate texture view
texture = TextureManager::getSingleton().load(fileNamePNG, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED);
#else
texture = renderTexture;
#endif
}
entity->setVisible(oldVisible);
entity->setRenderQueueGroup(oldRenderQueueGroup);
entity->setRenderingDistance(oldMaxDistance);
sceneMgr->removeSpecialCaseRenderQueue(group->geom->getRenderQueue() + 1);
// Restore original state
sceneMgr->setSpecialCaseRenderQueueMode(OldSpecialCaseRenderQueueMode);
//Re-enable mipmapping
mm->setDefaultTextureFiltering(oldMinFilter, oldMagFilter, oldMipFilter);
//Re-enable fog
sceneMgr->setFog(oldFogMode, oldFogColor, oldFogDensity, oldFogStart, oldFogEnd);
//Re-enable both scene lightning and disabled individual lights
sceneMgr->setAmbientLight(oldAmbientColour);
for (std::vector<Ogre::MovableObject*>::const_iterator I = lightStore.begin(); I != lightStore.end(); ++I) {
(*I)->setVisible(true);
}
//Delete camera
renderTarget->removeViewport(0);
renderCamera->getSceneManager()->destroyCamera(renderCamera);
//Delete scene node
node->detachAllObjects();
if (oldSceneNode) {
oldSceneNode->attachObject(entity);
}
#ifdef IMPOSTOR_FILE_SAVE
//Delete RTT texture
assert(!renderTexture.isNull());
String texName2(renderTexture->getName());
renderTexture.setNull();
if (TextureManager::getSingletonPtr())
TextureManager::getSingleton().remove(texName2);
#endif
}
void LevelManager::loadLevel(Level* lvl) {
printf("STARTING TO LOAD LEVEL \n" );
std::cout << "Entities::start " << cg::Registry::instance()->size() << "\n";
_currentLevel = lvl;
_currentClues = 0;
static_cast<Scene*>(cg::Registry::instance()->get("Scene"))->reset();
MaterialManager* materialManager = dynamic_cast<MaterialManager*>(cg::Registry::instance()->get("MaterialManager"));
TextureManager* textureManager = dynamic_cast<TextureManager*>(cg::Registry::instance()->get("TextureManager"));
materialManager->clear();
std::list<Material*>::iterator matit;
for(matit = lvl->getMaterials()->begin(); matit != lvl->getMaterials()->end(); matit++) {
materialManager->add(*matit);
}
textureManager->clear();
std::list<Texture*>::iterator texit;
textureManager->addMap(lvl->getMapTex());
for(texit = lvl->getTextures()->begin(); texit != lvl->getTextures()->end(); texit++) {
textureManager->add(*texit);
}
printf("LEVEL MANAGER: REMOVING PREVIOUS ENTITIES\n");
//clearing old ones (if there are any)
cg::View* v1 = static_cast<cg::View*>(cg::Registry::instance()->get("view1"));
std::list<std::string>::iterator entitiesit;
for(entitiesit = _currentEntities->begin(); entitiesit != _currentEntities->end(); entitiesit++) {
v1->unlinkEntity(*entitiesit);
cg::Registry::instance()->remove(*entitiesit);
}
std::cout << "Entities::after_unlink " << cg::Registry::instance()->size() << "\n";
DebugManager* dm = static_cast<DebugManager*>(cg::Registry::instance()->get("DebugManager"));
std::cout << "Debugmanager::Before " << dm->getListsSize() << "\n";
printf("LEVEL MANAGER: REMOVING DEBUG LISTENERS\n");
//removing everything registered for Debug (Ninja is always there)
//DebugManager* dm = static_cast<DebugManager*>(cg::Registry::instance()->get("DebugManager"));
dm->dispose();
dm->disableDebug();
std::cout << "Debugmanager::After " << dm->getListsSize() << "\n";
CollisionManager* cm = static_cast<CollisionManager*>(cg::Registry::instance()->get("CollisionManager"));
std::cout << "Collision::Before " << cm->getListsSize() << "\n";
printf("LEVEL MANAGER: REMOVING COLLISION LISTENERS\n");
//removing everything except Ninja from Collisions
//CollisionManager* cm = static_cast<CollisionManager*>(cg::Registry::instance()->get("CollisionManager"));
cm->dispose();
std::cout << "Collision::After " << cm->getListsSize() << "\n";
std::cout << "Entities::after_managers " << cg::Registry::instance()->size() << "\n";
_currentEntities->clear();
std::cout << "Entities::after_clean_entities " << cg::Registry::instance()->size() << "\n";
printf("LEVEL MANAGER: STARTING TO LOAD HEIGHT MAP\n");
ImageLoaderHeightMap* ilhm = static_cast<ImageLoaderHeightMap*>(cg::Registry::instance()->get("mappedterrain"));
if(ilhm != NULL)
ilhm->setHeightMap(LEVEL_PATH + _currentLevel->getHeightMap());
else {
ilhm = new ImageLoaderHeightMap("mappedterrain", LEVEL_PATH + _currentLevel->getHeightMap());
cg::Registry::instance()->add(ilhm);
}
std::cout << "Entities::after_heightmap " << cg::Registry::instance()->size() << "\n";
printf("LEVEL MANAGER: STARTING TO LOAD ITEM MAP\n");
ImageLoaderItemMap* ilim = static_cast<ImageLoaderItemMap*>(cg::Registry::instance()->get("mappeditems"));
if(ilim != NULL)
ilim->setItemMap(LEVEL_PATH + _currentLevel->getHeightMap(), LEVEL_PATH + _currentLevel->getItemMap());
else {
ilim = new ImageLoaderItemMap("mappeditems", LEVEL_PATH + _currentLevel->getHeightMap(), LEVEL_PATH + _currentLevel->getItemMap());
cg::Registry::instance()->add(ilim);
}
for(entitiesit = _currentEntities->begin(); entitiesit != _currentEntities->end(); entitiesit++) {
cg::Registry::instance()->get(*entitiesit)->init();
}
//reset ninja position
printf("LEVEL MANAGER: RESETING NINJA POSITION\n");
Ninja* ninja = dynamic_cast<Ninja*>(cg::Registry::instance()->get("Ninja"));
ninja->reset();
static_cast<Camera*>(cg::Registry::instance()->get("Camera"))->mainCamera();
std::cout << "Entities::after_itemmap " << cg::Registry::instance()->size() << "\n";
std::cout << "Debugmanager::After " << dm->getListsSize() << "\n";
std::cout << "Collision::After " << cm->getListsSize() << "\n";
printf("LEVEL LOADED\n");
}
void RenderState::enter()
{
OgreFramework* framework = OgreFramework::getSingletonPtr();
framework->_viewport->setVisibilityMask(RF_MAIN);
//framework->_log->logMessage("Entering RenderState...");
_sceneMgr = framework->_root->createSceneManager(ST_GENERIC, "RenderSceneMgr");
_sceneMgr->setAmbientLight(Ogre::ColourValue(0.7f, 0.7f, 0.7f));
_sceneMgr->addRenderQueueListener(framework->_overlaySystem);
/////////////////// Setup Ray queries (unused)
_rsq = _sceneMgr->createRayQuery(Ray());
_rsq->setQueryMask(OGRE_HEAD_MASK);
////////////////// Setup Camera
_camera = _sceneMgr->createCamera("GameCamera");
_camera->setPosition(Vector3(5, 60, 60));
_camera->lookAt(Vector3(5, 20, 0));
_camera->setNearClipDistance(5);
Real vpWidth = Real(framework->_viewport->getActualWidth());
Real vpHeight = Real(framework->_viewport->getActualHeight());
_camera->setAspectRatio(vpWidth / vpHeight);
framework->_viewport->setCamera(_camera);
_currentObject = 0;
////////////////// Setup GUI
buildGUI();
////////////////// Setup Scene
createScene();
////////////////// Create render textures
// PixelFormat format = PF_A8B8G8R8;
PixelFormat format = PF_FLOAT16_RGBA;
float rtWidth = vpWidth;
float rtHeight = vpHeight;
if (rayPositions.create("rayPos", rtWidth, rtHeight, format, _camera, _sceneMgr)) {
std::cout << "Error creating ray positions texture\n";
}
if (rayDirections.create("rayDir", rtWidth, rtHeight, format, _camera, _sceneMgr)) {
std::cout << "Error creating ray directions texture\n";
}
rayPositions.setupThumbnail(0.74, 0.99, -0.74, -0.99);
rayPositions.showThumbnail();
rayDirections.setupThumbnail(0.45, 0.7, -0.74, -0.99);
rayDirections.showThumbnail();
////////////////// Setup parameters for ray materials
MaterialManager* matMgr = MaterialManager::getSingletonPtr();
MaterialPtr rayDirMat = matMgr->getByName("BoundingCubesDirections");
GpuProgramParametersSharedPtr fragParameters;
fragParameters =
rayDirMat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
float rt_width_inv = 1.0 / rtWidth;
float rt_height_inv = 1.0 / rtHeight;
try {
fragParameters->setNamedConstant("width_inv", rt_width_inv);
fragParameters->setNamedConstant("height_inv", rt_height_inv);
}
catch (Exception e) {}
float width_inv = 1.0 / vpWidth;
float height_inv = 1.0 / vpHeight;
fragParameters =
breadMat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
try {
fragParameters->setNamedConstant("width_inv", width_inv);
fragParameters->setNamedConstant("height_inv", height_inv);
}
catch (Exception e) {}
////////////////// Setup shadow params
_sceneMgr->setShadowFarDistance(100);
_sceneMgr->setShadowTextureCount(2);
_sceneMgr->setShadowTextureSelfShadow(true);
_sceneMgr->setShadowCasterRenderBackFaces(false);
_sceneMgr->setShadowTextureCasterMaterial("DepthShadowmap/Caster/Bread");
_sceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED);
_sceneMgr->setShadowTextureConfig( 0, 2048, 2048, PF_FLOAT32_R );
tableEntity->getSubEntity(0)->getMaterial()->setReceiveShadows(true);
tableEntity->getSubEntity(0)->setMaterialName("DepthShadowmap/Receiver/Float",
"General");
breadEntity->getSubEntity(0)->getMaterial()->setReceiveShadows(true);
breadEntity->setCastShadows(true);
}
void WFLoader::parseMaterialFile( const char *line )
{
/* Variables
*/
char tempStr[20] = "\0";
MaterialManager *matMngrPtr = NULL;
MaterialData matData;
float r, g, b;
/* Code
*/
matMngrPtr = MaterialManager::getInstance();
if( strlen( line ) > 0 )
{
if( line[ 0 ] == 'n' )
{
sscanf( line, "%s", tempStr );
/* Material name */
if( strcmp( tempStr, "newmtl" ) == 0 )
{
sscanf( line, "%*s %s", m_CurrentMatName );
matMngrPtr->addMaterial( m_CurrentMatName, matData );
}
}
else if( line[ 0 ] == 'N' )
{
switch( line[ 1 ] )
{
case 's':
/* Specular exponent ( shininess ) */
sscanf( line, "%*s %f", &r );
/* Even though Color4f is used, only the value of r gets
saved into the Material values */
matMngrPtr->setValue( m_CurrentMatName,
MaterialManager::MAT_SHININESS,
Color4f( r, 0.0, 0.0, 1.0 ) );
break;
}
}
/* Reflectivity information */
else if( line[ 0 ] == 'K' )
{
switch( line[ 1 ] ) //if( line[ 1 ] == 'a' )
{
case 'a':
/* Ambient */
sscanf( line, "%*s %f %f %f", &r, &g, &b );
matMngrPtr->setValue( m_CurrentMatName,
MaterialManager::MAT_AMBIENT,
Color4f( r, g, b, 1.0 ) );
break;
case 'd':
/* Diffuse */
sscanf( line, "%*s %f %f %f", &r, &g, &b );
matMngrPtr->setValue( m_CurrentMatName,
MaterialManager::MAT_DIFFUSE,
Color4f( r, g, b, 1.0 ) );
break;
case 's':
/* Specular */
sscanf( line, "%*s %f %f %f", &r, &g, &b );
matMngrPtr->setValue( m_CurrentMatName,
MaterialManager::MAT_SPECULAR,
Color4f( r, g, b, 1.0 ) );
break;
}
}
}
}
void UIRect::loadTexture(String fileName) {
MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager();
texture = materialManager->createTextureFromFile(fileName, materialManager->clampDefault, false);
}
int main(int argc, char** argv ){
if( argc != 8 ) {
std::cout << " usage: print_materials compact.xml x0 y0 z0 x1 y1 z1 " << std::endl
<< " -> prints the materials on a straight line between the two given points ( unit is cm) "
<< std::endl ;
exit(1) ;
}
std::string inFile = argv[1] ;
std::stringstream sstr ;
sstr << argv[2] << " " << argv[3] << " " << argv[4] << " " << argv[5] << " " << argv[6] << " " << argv[7] ;
double x0,y0,z0,x1,y1,z1 ;
sstr >> x0 ;
sstr >> y0 ;
sstr >> z0 ;
sstr >> x1 ;
sstr >> y1 ;
sstr >> z1 ;
LCDD& lcdd = LCDD::getInstance();
lcdd.fromCompact( inFile );
Vector3D p0( x0, y0, z0 ) ;
Vector3D p1( x1, y1, z1 ) ;
MaterialManager matMgr ;
const MaterialVec& materials = matMgr.materialsBetween( p0 , p1 ) ;
std::cout << std::endl << " ####### materials between the two points : " << p0 << "*cm and " << p1 << "*cm : " << std::endl ;
double sum_x0 = 0 ;
double sum_lambda = 0 ;
double path_length = 0 ;
for( unsigned i=0,n=materials.size();i<n;++i){
Material mat = materials[i].first ;
double length = materials[i].second ;
double nx0 = length / mat.radLength() ;
sum_x0 += nx0 ;
double nLambda = length / mat.intLength() ;
sum_lambda += nLambda ;
path_length += length ;
std::cout << " " << mat << " thickness: " << length << " path_length:" << path_length << " integrated_X0: " << sum_x0 << " integrated_lambda: " << sum_lambda << std::endl ;
}
std::cout << "############################################################################### " << std::endl << std::endl ;
const MaterialData& avMat = matMgr.createAveragedMaterial( materials ) ;
std::cout << " averaged Material : " << " Z: " << avMat.Z() << " A: " << avMat.A() << " densitiy: " << avMat.density()
<< " radiationLength: " << avMat.radiationLength()
<< " interactionLength: " << avMat.interactionLength() << std::endl << std::endl ;
std::cout << " Total length : " << path_length / dd4hep::mm << " mm " << std::endl ;
std::cout << " Integrated radiation lengths : " << path_length / avMat.radiationLength() << " X0 " << std::endl ;
std::cout << " Integrated interaction lengths : " << path_length / avMat.interactionLength() << " lambda " << std::endl ;
std::cout << "############################################################################### " << std::endl << std::endl ;
return 0;
}
bool ObjModel::loadMTLFile(const char* fileName) {
cout << "Loading material file: " << fileName << endl;
FILE* fp;
string* modelPath = getCvarAddress_S("r_modelPath");
string canonicalPath = *modelPath + "obj/" + fileName;
cout << "From file path: " << canonicalPath << endl;
if( !(fp=fopen(canonicalPath.c_str(), "r")) ) {
error = "OBJ Materials file not found";
Con_print("Obj: File not found - %s", canonicalPath.c_str());
return false;
}
MaterialManager* tm = getMaterialManager();
material_t* mat;
while( !feof(fp) ) {
char in[MAX_OBJ_LINE_LEN];
fgets(in, MAX_OBJ_LINE_LEN, fp);
char incpy[MAX_OBJ_LINE_LEN];
#ifdef OBJMATDEBUG
cout << "MAT Line: " << in << endl;
#endif
strcpy(incpy, in);
// if its a comment or whitespace skip it
if( in[0] == '#' || in[0] == ' ' || in[0] == '\n' ||
in[0] == '\r' || in[0] == '\t')
continue;
else { // otherwise we need to process some data
char* token = strtok(in, WHITESPACE);
if( token == NULL )
break;
if( !strcmp(token, "newmtl") ) {
material_t* newmat = new material_t;
initializeMaterial(newmat);
token = strtok(NULL, WHITESPACE);
if( !tm->hasMaterial(token) ) {
tm->addMaterial(token, newmat);
mat = newmat;
#ifdef OBJMATDEBUG
cout << "New material created: " << token << endl;
#endif
}
else {
#ifdef OBJMATDEBUG
cout << "MTL Error: Material redefinition: " << token << endl;
#endif
}
}
else if( !strcmp(token, "Ns") ) {
sscanf(incpy, "Ns %f", &mat->Ns);
}
else if( !strcmp(token, "Ka") ) {
sscanf(incpy, "Ka %f %f %f", &mat->Ka[0], &mat->Ka[1], &mat->Ka[2]);
}
else if( !strcmp(token, "Kd") ) {
sscanf(incpy, "Kd %f %f %f", &mat->Kd[0], &mat->Kd[1], &mat->Kd[2]);
}
else if( !strcmp(token, "Ks") ) {
sscanf(incpy, "Ks %f %f %f", &mat->Ks[0], &mat->Ks[1],& mat->Ks[2]);
}
else if( !strcmp(token, "Ni") ) {
sscanf(incpy, "Ni %f", &mat->Ni);
}
else if( !strcmp(token, "d") ) {
sscanf(incpy, "d %f", &mat->d);
}
else if( !strcmp(token, "illum") ) {
sscanf(incpy, "illum %d", &mat->illum);
}
else if( !strcmp(token, "map_Kd") ) {
token = strtok(NULL, WHITESPACE);
strcpy(mat->map_Kd, token);
#ifdef OBJMATDEBUG
cout << "Loading texture: " << mat->map_Kd << endl;
#endif
getMaterialManager()->loadBitmap(mat->map_Kd);
}
}
}
fclose(fp);
return true;
}
void SceneMesh::loadTextureFromImage(Image *image) {
MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager();
texture = materialManager->createTextureFromImage(image, materialManager->clampDefault, materialManager->mipmapsDefault);
}
void GodRaysManager::_createMaterials(const HydraxComponent& HC)
{
Ogre::String VertexProgramData, FragmentProgramData;
Ogre::GpuProgramParametersSharedPtr VP_Parameters, FP_Parameters;
Ogre::String EntryPoints[2] = {"main_vp", "main_fp"};
Ogre::String GpuProgramsData[2]; Ogre::String GpuProgramNames[2];
MaterialManager *mMaterialManager = mHydrax->getMaterialManager();
int NumberOfDepthChannels = 0;
Ogre::String GB[2] = {"0, 1, 0", "0, 0, 1"};
if (_isComponent(HC, HYDRAX_COMPONENT_CAUSTICS))
{
NumberOfDepthChannels++;
}
// God Rays material
VertexProgramData = "";
FragmentProgramData = "";
// Vertex program
switch (mHydrax->getShaderMode())
{
case MaterialManager::SM_HLSL: case MaterialManager::SM_CG:
{
VertexProgramData +=
Ogre::String(
"void main_vp(\n") +
// IN
"float4 iPosition : POSITION,\n" +
// OUT
"out float4 oPosition : POSITION,\n";
if (mObjectsIntersections)
{
VertexProgramData += Ogre::String(
"out float3 oPosition_ : TEXCOORD0,\n") +
"out float4 oProjUV : TEXCOORD1,\n" +
// UNIFORM
"uniform float4x4 uWorld,\n" +
"uniform float4x4 uTexViewProj,\n";
}
VertexProgramData += Ogre::String(
"uniform float4x4 uWorldViewProj)\n") +
"{\n" +
"oPosition = mul(uWorldViewProj, iPosition);\n";
if (mObjectsIntersections)
{
VertexProgramData += Ogre::String(
"float4 wPos = mul(uWorld, iPosition);\n")+
"oPosition_ = wPos.xyz;\n"+
"oProjUV = mul(uTexViewProj, wPos);\n";
}
VertexProgramData +=
"}\n";
}
break;
case MaterialManager::SM_GLSL:
{}
break;
}
// Fragment program
switch (mHydrax->getShaderMode())
{
case MaterialManager::SM_HLSL: case MaterialManager::SM_CG:
{
if (mObjectsIntersections)
FragmentProgramData +=
Ogre::String(
"void main_fp(\n") +
// IN
"float3 iPosition : TEXCOORD0,\n" +
"float4 iProjUV : TEXCOORD1,\n" +
// OUT
"out float4 oColor : COLOR,\n" +
// UNIFORM
"uniform float3 uLightPosition,\n"+
"uniform float uLightFarClipDistance,\n" +
"uniform sampler2D uDepthMap : register(s0))\n" +
"{\n" +
"iProjUV = iProjUV / iProjUV.w;\n"+
"float Depth = tex2D(uDepthMap, iProjUV.xy).r;\n"+
"if (Depth < saturate( length(iPosition-uLightPosition) / uLightFarClipDistance ))\n"+
"{\n"+
"oColor = float4(0,0,0,1);\n"+
"}\n"+
"else\n"+
"{\n"+
"oColor = float4(float3(" + GB[NumberOfDepthChannels] + ") * 0.1, 1);\n"+
"}\n"+
"}\n";
else
FragmentProgramData +=
Ogre::String(
"void main_fp(\n") +
// OUT
"out float4 oColor : COLOR)\n" +
"{\n" +
"oColor = float4(float3(" + GB[NumberOfDepthChannels] + ") * 0.1, 1);\n"+
"}\n";
}
break;
case MaterialManager::SM_GLSL:
{}
break;
}
// Build our material
mMaterials[0] = Ogre::MaterialManager::getSingleton().
create(_def_GodRays_Material_Name,
HYDRAX_RESOURCE_GROUP);
Ogre::Pass *GR_Technique0_Pass0 = mMaterials[0]->getTechnique(0)->getPass(0);
GR_Technique0_Pass0->setLightingEnabled(false);
GR_Technique0_Pass0->setCullingMode(Ogre::CULL_NONE);
GR_Technique0_Pass0->setDepthWriteEnabled(false);
GR_Technique0_Pass0->setDepthCheckEnabled(mObjectsIntersections);
GR_Technique0_Pass0->setSceneBlending(Ogre::SBT_ADD);
GpuProgramsData[0] = VertexProgramData; GpuProgramsData[1] = FragmentProgramData;
GpuProgramNames[0] = _def_GodRays_Shader_VP_Name; GpuProgramNames[1] = _def_GodRays_Shader_FP_Name;
mMaterialManager->fillGpuProgramsToPass(GR_Technique0_Pass0, GpuProgramNames, mHydrax->getShaderMode(), EntryPoints, GpuProgramsData);
VP_Parameters = GR_Technique0_Pass0->getVertexProgramParameters();
FP_Parameters = GR_Technique0_Pass0->getFragmentProgramParameters();
VP_Parameters->setNamedAutoConstant("uWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
if (!mObjectsIntersections)
{
return;
}
Ogre::Matrix4 TexViewProj =
PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE *
mProjectorCamera->getProjectionMatrixWithRSDepth() *
mProjectorCamera->getViewMatrix();
VP_Parameters->setNamedAutoConstant("uWorld", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX);
VP_Parameters->setNamedConstant("uTexViewProj", TexViewProj);
FP_Parameters->setNamedConstant("uLightPosition", mProjectorSN->getPosition());
FP_Parameters->setNamedConstant("uLightFarClipDistance", mProjectorCamera->getFarClipDistance());
GR_Technique0_Pass0->createTextureUnitState(_def_GodRays_Depth_Map)->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
GR_Technique0_Pass0->getTextureUnitState(0)->setTextureName(_def_GodRays_Depth_Map);
// Depth material
VertexProgramData = "";
FragmentProgramData = "";
// Vertex program
switch (mHydrax->getShaderMode())
{
case MaterialManager::SM_HLSL: case MaterialManager::SM_CG:
{
VertexProgramData +=
Ogre::String(
"void main_vp(\n") +
// IN
"float4 iPosition : POSITION,\n" +
"float2 iUV : TEXCOORD0,\n" +
// OUT
"out float4 oPosition : POSITION,\n" +
"out float3 oPosition_ : TEXCOORD0,\n" +
// UNIFORM
"uniform float4x4 uWorld,\n" +
"uniform float4x4 uWorldViewProj)\n" +
"{\n" +
"oPosition = mul(uWorldViewProj, iPosition);\n"+
"float4 wPos = mul(uWorld, iPosition);\n"+
"oPosition_ = wPos.xyz;\n"+
"}\n";
}
break;
case MaterialManager::SM_GLSL:
{}
break;
}
// Fragment program
switch (mHydrax->getShaderMode())
{
case MaterialManager::SM_HLSL: case MaterialManager::SM_CG:
{
FragmentProgramData +=
Ogre::String(
"void main_fp(\n") +
// IN
"float3 iPosition : TEXCOORD0,\n" +
// OUT
"out float4 oColor : COLOR,\n" +
// UNIFORM
"uniform float3 uLightPosition,\n" +
"uniform float uLightFarClipDistance)\n" +
"{\n" +
"float depth = saturate( length(iPosition-uLightPosition) / uLightFarClipDistance );\n"+
"oColor = float4(depth, 0, 0, 0);\n"+
"}\n";
}
break;
case MaterialManager::SM_GLSL:
{}
break;
}
// Build our material
mMaterials[1] = Ogre::MaterialManager::getSingleton().
create(_def_GodRaysDepth_Material_Name,
HYDRAX_RESOURCE_GROUP);
Ogre::Pass *GRD_Technique0_Pass0 = mMaterials[1]->getTechnique(0)->getPass(0);
mMaterials[1]->getTechnique(0)->setSchemeName("HydraxGodRaysDepth");
GRD_Technique0_Pass0->setLightingEnabled(false);
GRD_Technique0_Pass0->setCullingMode(Ogre::CULL_NONE);
GpuProgramsData[0] = VertexProgramData; GpuProgramsData[1] = FragmentProgramData;
GpuProgramNames[0] = _def_GodRaysDepth_Shader_VP_Name; GpuProgramNames[1] = _def_GodRaysDepth_Shader_FP_Name;
mMaterialManager->fillGpuProgramsToPass(GRD_Technique0_Pass0, GpuProgramNames, mHydrax->getShaderMode(), EntryPoints, GpuProgramsData);
VP_Parameters = GRD_Technique0_Pass0->getVertexProgramParameters();
FP_Parameters = GRD_Technique0_Pass0->getFragmentProgramParameters();
VP_Parameters->setNamedAutoConstant("uWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
VP_Parameters->setNamedAutoConstant("uWorld", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX);
FP_Parameters->setNamedConstant("uLightPosition", mProjectorSN->getPosition());
FP_Parameters->setNamedConstant("uLightFarClipDistance", mProjectorCamera->getFarClipDistance());
}
//Loads the MD2 model
MD2Model* MD2Model::load(const char* filename) {
Vec3f xyzMin;
Vec3f xyzMax;
ifstream input;
input.open(filename, istream::binary);
Con_print("****MD2LOAD:START****");
char buffer[64];
input.read(buffer, 4); //Should be "IPD2", if this is an MD2 file
if (buffer[0] != 'I' || buffer[1] != 'D' ||
buffer[2] != 'P' || buffer[3] != '2') {
Con_print("MD2 Error: Wrong MD2 Version Found!");
return NULL;
}
if (readInt(input) != 8) { //The version number
Con_print("MD2 Error: Wrong MD2 Version Number Found!");
return NULL;
}
int textureWidth = readInt(input); //The width of the textures
int textureHeight = readInt(input); //The height of the textures
readInt(input); //The number of bytes per frame
int numTextures = readInt(input); //The number of textures
if (numTextures != 1) {
Con_print("MD2 Error: No Textures Found!");
return NULL;
}
int numVertices = readInt(input); //The number of vertices
int numTexCoords = readInt(input); //The number of texture coordinates
int numTriangles = readInt(input); //The number of triangles
readInt(input); //The number of OpenGL commands
int numFrames = readInt(input); //The number of frames
//Offsets (number of bytes after the beginning of the file to the beginning
//of where certain data appear)
int textureOffset = readInt(input); //The offset to the textures
int texCoordOffset = readInt(input); //The offset to the texture coordinates
int triangleOffset = readInt(input); //The offset to the triangles
int frameOffset = readInt(input); //The offset to the frames
readInt(input); //The offset to the OpenGL commands
readInt(input); //The offset to the end of the file
MD2Model* model = new MD2Model();
MaterialManager* matsMgr = getMaterialManager();
//Load the texture
input.seekg(textureOffset, ios_base::beg);
input.read(buffer, 64);
// FIXME
// Hack to get the md2 models with pcx textures to load bmp version instead
string s = buffer;
s = s.substr(0, s.find_last_of("."));
s = s + ".bmp";
strcpy(buffer, s.c_str());
// END FIXME
////////////////////////
if (strlen(buffer) < 5 || strcmp(buffer + strlen(buffer) - 4, ".bmp") != 0 ) {
Con_print("MD2 Error: Couldn't parse texture name: %s", buffer);
// Set texture not found because we can't load the texture that was set
model->textureId = matsMgr->getGLTexID("not-found.bmp");
}
else {
if( !matsMgr->hasMaterial(buffer) )
matsMgr->loadBitmap(buffer);
model->textureId = matsMgr->getGLTexID(buffer);
}
//Load the texture coordinates
input.seekg(texCoordOffset, ios_base::beg);
model->texCoords = new MD2TexCoord[numTexCoords];
for(int i = 0; i < numTexCoords; i++) {
MD2TexCoord* texCoord = model->texCoords + i;
texCoord->texCoordX = (float)readShort(input) / textureWidth;
texCoord->texCoordY = 1 - (float)readShort(input) / textureHeight;
}
//Load the triangles
input.seekg(triangleOffset, ios_base::beg);
model->triangles = new MD2Triangle[numTriangles];
model->numTriangles = numTriangles;
for(int i = 0; i < numTriangles; i++) {
MD2Triangle* triangle = model->triangles + i;
for(int j = 0; j < 3; j++) {
triangle->vertices[j] = readUShort(input);
}
for(int j = 0; j < 3; j++) {
triangle->texCoords[j] = readUShort(input);
}
}
//Load the frames
input.seekg(frameOffset, ios_base::beg);
model->frames = new MD2Frame[numFrames];
model->numFrames = numFrames;
for(int i = 0; i < numFrames; i++) {
MD2Frame* frame = model->frames + i;
frame->vertices = new MD2Vertex[numVertices];
Vec3f scale = readVec3f(input);
Vec3f translation = readVec3f(input);
input.read(frame->name, 16);
for(int j = 0; j < numVertices; j++) {
MD2Vertex* vertex = frame->vertices + j;
input.read(buffer, 3);
Vec3f v((unsigned char)buffer[0],
(unsigned char)buffer[1],
(unsigned char)buffer[2]);
vertex->pos = translation + Vec3f(scale[0] * v[0],
scale[1] * v[1],
scale[2] * v[2]);
// added to get dimensions of model at load time
model->doDimensionCheck(vertex->pos);
// end dimension add
input.read(buffer, 1);
int normalIndex = (int)((unsigned char)buffer[0]);
vertex->normal = Vec3f(NORMALS[3 * normalIndex],
NORMALS[3 * normalIndex + 1],
NORMALS[3 * normalIndex + 2]);
}
}
model->startFrame = 0;
model->endFrame = numFrames - 1;
Con_print("numFrames: %d", numFrames );
Con_print("****MD2LOAD:FINISH****");
Con_print("MD2 Dimensions: %.3f x %.3f x %.3f", model->xRadius*2, model->yRadius*2, model->zRadius*2);
return model;
}
void SceneMesh::loadTexture(const String& fileName) {
MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager();
texture = materialManager->createTextureFromFile(fileName, materialManager->clampDefault, materialManager->mipmapsDefault);
ownsTexture = false; // Texture is owned by material manager, not mesh.
}
void display()
{
Core::init(512,512);
Core::getInstance()->initImageRendering();
Camera * cam = new Camera();
cam->setPosition(Vector4I(0,-8,-8,1));
cam->setDirection(Vector4I(0,-1,-1,0),Vector4I(0,1,0,0));
cam->setFovDeg(30,30);
cam->flush();
MaterialManager * materials = new MaterialManager("/home/rulk/src/raytracer-wsp/StingRay/src/material/"
,"/home/rulk/src/raytracer-wsp/StingRay/src/material/");
materials->loadFile("basic.material");
materials->compile();
Material * mat = materials->getMaterial("simpleColor");
Material * mat1 = materials->getMaterial("complexColor");
std::cout<<mat<<std::endl;
RenderableManager * renderables = new RenderableManager();
Sphere * sphere = new Sphere(mat,Fvec4(2,0,-8,1),1);
Sphere * sphere1 = new Sphere(mat1,Fvec4(-2,0,-8,1),1);
Sphere * sphere2 = new Sphere(mat1,Fvec4(0,2,-8,1),1);
ManualMesh manual;
TriMesh *themesh = TriMesh::read("/home/rulk/src/raytracer-wsp/StingRay/cube.obj");
if (!themesh)
THROW(0,"No such mesh...");
themesh->need_normals();
themesh->need_tstrips();
themesh->need_bsphere();
int offset = 0,len = 0,pIndex;
manual.begin(mat);
bool needdub = false;
for(int i=0;i<themesh->tstrips.size();i++)
{
if( i >= offset+len)
{
offset = i+1;
len = themesh->tstrips[i];
//manual.beginStrip();
if(i != 0)
{
manual.duplicateLast();
needdub = true;
}
continue;
}
pIndex = themesh->tstrips[i];
manual.position(themesh->vertices[pIndex][0],themesh->vertices[pIndex][1],themesh->vertices[pIndex][2]);
if(needdub)
{
manual.duplicateLast();
needdub = false;
}
}
manual.normal(Fvec4(0,1,0,0));
std::cout<<"Size:"<<themesh->tstrips.size()<<std::endl;
TriangelMesh * mesh = manual.getTriangelMesh();
/*SphereStream * spheres = new SphereStream(1,STREAM_READ);
spheres->put(Vector4I(2,0,-8,1),1,Vector3I(0,0,1));
spheres->flush();
*/
// renderables->registerRendarable(sphere);
// renderables->registerRendarable(sphere1);
// renderables->registerRendarable(sphere2);
renderables->registerRendarable(mesh);
MaterialKernel * kernel = new MaterialKernel("/home/rulk/src/raytracer-wsp/StingRay/cl/sphere_tracer.cl");
kernel->setMaterialManager(materials);
kernel->setRenderableManager(renderables);
kernel->compileKernel();
kernel->setCamera(cam);
size_t global_item_size = 512*512; // Process the entire lists
size_t local_item_size = 512;
kernel->run(Core::getInstance()->getQue(),&global_item_size,&local_item_size);
//streamC.sync();
Core::getInstance()->dumpImage("out.png");
Core::getInstance()->flushQue();
Core::getInstance()->finishQue();
delete kernel;
Core::destroy();
cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
return ;
}
void SceneMesh::loadTexture(const String& fileName) {
MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager();
texture = materialManager->createTextureFromFile(fileName, materialManager->clampDefault, materialManager->mipmapsDefault);
}
Resource *TextureResourceLoader::loadResource(const String &path, ResourcePool *targetPool) {
MaterialManager *materialManager = Services()->getMaterialManager();
Texture *texture = materialManager->createTextureFromFile(path, materialManager->clampDefault, materialManager->mipmapsDefault);
return texture;
}
void MeshSerializerTests::setUp()
{
errorFactor = 0.05;
OGRE_DELETE LogManager::getSingletonPtr();
mLogManager = OGRE_NEW LogManager();
mLogManager->createLog("MeshWithoutIndexDataTests.log", false);
mLogManager->setLogDetail(LL_LOW);
mFSLayer = OGRE_NEW_T(Ogre::FileSystemLayer, Ogre::MEMCATEGORY_GENERAL)(OGRE_VERSION_NAME);
OGRE_NEW ResourceGroupManager();
OGRE_NEW LodStrategyManager();
OGRE_NEW DefaultHardwareBufferManager();
OGRE_NEW MeshManager();
OGRE_NEW SkeletonManager();
ArchiveManager* archiveMgr = OGRE_NEW ArchiveManager();
archiveMgr->addArchiveFactory(OGRE_NEW FileSystemArchiveFactory());
MaterialManager* matMgr = OGRE_NEW MaterialManager();
matMgr->initialise();
// Load resource paths from config file
ConfigFile cf;
String resourcesPath;
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_WIN32
resourcesPath = mFSLayer->getConfigFilePath("resources.cfg");
#else
resourcesPath = mFSLayer->getConfigFilePath("bin/resources.cfg");
#endif
// Go through all sections & settings in the file
cf.load(resourcesPath);
ConfigFile::SectionIterator seci = cf.getSectionIterator();
String secName, typeName, archName;
while (seci.hasMoreElements()) {
secName = seci.peekNextKey();
ConfigFile::SettingsMultiMap* settings = seci.getNext();
ConfigFile::SettingsMultiMap::iterator i;
for (i = settings->begin(); i != settings->end(); ++i) {
typeName = i->first;
archName = i->second;
if (typeName == "FileSystem") {
ResourceGroupManager::getSingleton().addResourceLocation(
archName, typeName, secName);
}
}
}
mMesh = MeshManager::getSingleton().load("knot.mesh", ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
getResourceFullPath(mMesh, mMeshFullPath);
if (!copyFile(mMeshFullPath + ".bak", mMeshFullPath)) {
// If there is no backup, create one.
copyFile(mMeshFullPath, mMeshFullPath + ".bak");
}
mSkeletonFullPath = "";
mSkeleton = SkeletonManager::getSingleton().load("jaiqua.skeleton", "Popular").staticCast<Skeleton>();
getResourceFullPath(mSkeleton, mSkeletonFullPath);
if (!copyFile(mSkeletonFullPath + ".bak", mSkeletonFullPath)) {
// If there is no backup, create one.
copyFile(mSkeletonFullPath, mSkeletonFullPath + ".bak");
}
mMesh->reload();
#ifdef OGRE_BUILD_COMPONENT_MESHLODGENERATOR
{
MeshLodGenerator().generateAutoconfiguredLodLevels(mMesh);
}
#endif /* ifdef OGRE_BUILD_COMPONENT_MESHLODGENERATOR */
mOrigMesh = mMesh->clone(mMesh->getName() + ".orig.mesh", mMesh->getGroup());
}
void FbxRender::CreateMaterials(MaterialManager& materialMgr)
{
std::vector<StandardMaterial> materialsVector;
int defaultIdx = 0;
// Try to use a default texture,
// when we are unable to load a texture.
for (unsigned int i = 0; i < materialMgr.GetTextureResource().size(); i++)
{
if (materialMgr.GetTextureResource()[i].name == "Default")
{
defaultIdx = i;
break;
}
}
for (unsigned int matIdx = 0; matIdx < m_fbxLoader.m_MaterialList.size(); matIdx++)
{
StandardMaterial material;
// Use reinterpret_cast to load data for a material type.
StandardMaterial* pConveter = reinterpret_cast<StandardMaterial*>(m_fbxLoader.m_MaterialList[matIdx].rawData);
unsigned int texIdx = pConveter->albedoMapIdx;
if (texIdx < m_fbxLoader.m_TextureList.size())
{
ComPtr<ID3D12Resource> Texture;
std::string path = m_fbxLoader.m_TextureList[texIdx].name;
if (path.size() > 10)
{
bool repeatTexture = false;
// Search the textures in the material manager.
for (unsigned int i = 0; i < materialMgr.GetTextureResource().size(); i++)
{
if (materialMgr.GetTextureResource()[i].name == path)
{
repeatTexture = true;
texIdx = i;
break;
}
}
// Create a new texture resource, if we don't find the same one in the material manager.
if (!repeatTexture)
{
HRESULT hr = CreateWICTextureFromFileEx(g_d3dObjects->GetD3DDevice(), std::wstring(path.begin(), path.end()).c_str(), 0, 0, 0, 0, 0, &Texture);
materialMgr.AddResource(Texture, path);
texIdx = materialMgr.GetTextureResource().size() - 1;
}
}
else {
// This filename is invalid.
texIdx = defaultIdx;
}
}
else {
// No any texture in the FBX model.
texIdx = defaultIdx;
}
// Store the material data into this manager.
material.albedoColor = pConveter->albedoColor;
material.specularColor = pConveter->specularColor;
material.albedoMapIdx = texIdx;
materialsVector.push_back(material);
}
if (materialsVector.size())
{
// Create a material buffer.
ComPtr<ID3D12Resource> materialBuffer;
CD3DX12_HEAP_PROPERTIES heapProperty(D3D12_HEAP_TYPE_UPLOAD);
D3D12_RESOURCE_DESC resourceDesc;
ZeroMemory(&resourceDesc, sizeof(resourceDesc));
resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
resourceDesc.Alignment = 0;
resourceDesc.SampleDesc.Count = 1;
resourceDesc.SampleDesc.Quality = 0;
resourceDesc.MipLevels = 1;
resourceDesc.Format = DXGI_FORMAT_UNKNOWN;
resourceDesc.DepthOrArraySize = 1;
resourceDesc.Height = 1;
resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
resourceDesc.Width = sizeof(materialsVector[0])*materialsVector.size();
ThrowIfFailed(g_d3dObjects->GetD3DDevice()->CreateCommittedResource(&heapProperty, D3D12_HEAP_FLAG_NONE, &resourceDesc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(materialBuffer.GetAddressOf())));
void* mapped = nullptr;
materialBuffer->Map(0, nullptr, &mapped);
memcpy(mapped, &materialsVector[0], sizeof(materialsVector[0])*materialsVector.size());
materialBuffer->Unmap(0, nullptr);
materialMgr.UpdateMaterialBuffer(materialBuffer, materialsVector.size(), sizeof(materialsVector[0]));
}
}
