teamnwah/openmw-tes3coop
2
0
Fork 1
forked from mirror/openmw-tes3mp
Code Issues Pull requests 1 Releases Wiki Activity

music player and NPC rendering branch

Browse source
This commit is contained in:
Marc Zinnschlag 2010-12-30 14:50:35 +01:00
commit 5336b90149
18 changed files with 1206 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

97
apps/openmw/engine.cpp
View file

@ -1,13 +1,17 @@
#include "engine.hpp" #include "engine.hpp"
#include "components/esm/loadcell.hpp"
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
#include <utility> #include <utility>
#include "components/esm/records.hpp"
#include <components/esm_store/cell_store.hpp>
#include <components/misc/fileops.hpp> #include <components/misc/fileops.hpp>
#include <components/bsa/bsa_archive.hpp> #include <components/bsa/bsa_archive.hpp>
#include <components/esm/loadregn.hpp>
#include <components/esm/esm_reader.hpp>
#include <openengine/gui/manager.hpp> #include <openengine/gui/manager.hpp>
#include "mwgui/window_manager.hpp" #include "mwgui/window_manager.hpp"
@ -37,6 +41,9 @@
#include <MyGUI_WidgetManager.h> #include <MyGUI_WidgetManager.h>
#include "mwgui/class.hpp" #include "mwgui/class.hpp"
//using namespace ESM;
void OMW::Engine::executeLocalScripts() void OMW::Engine::executeLocalScripts()
{ {
for (MWWorld::World::ScriptList::const_iterator iter ( for (MWWorld::World::ScriptList::const_iterator iter (
@ -57,8 +64,77 @@ void OMW::Engine::executeLocalScripts()
mIgnoreLocalPtr = MWWorld::Ptr(); mIgnoreLocalPtr = MWWorld::Ptr();
} }
bool OMW::Engine::frameStarted(const Ogre::FrameEvent& evt) bool OMW::Engine::frameStarted(const Ogre::FrameEvent& evt)
{ {
if(! (mEnvironment.mSoundManager->isMusicPlaying()))
{
// Play some good 'ol tunes
mEnvironment.mSoundManager->startRandomTitle();
}
std::string effect;
MWWorld::Ptr::CellStore *current = mEnvironment.mWorld->getPlayerPos().getPlayer().getCell();
//If the region has changed
if(!(current->cell->data.flags & current->cell->Interior) && timer.elapsed() >= 10){
timer.restart();
if (test.name != current->cell->region)
{
total = 0;
test = (ESM::Region) *(mEnvironment.mWorld->getStore().regions.find(current->cell->region));
}
if(test.soundList.size() > 0)
{
std::vector<ESM::Region::SoundRef>::iterator soundIter = test.soundList.begin();
//mEnvironment.mSoundManager
if(total == 0){
while (!(soundIter == test.soundList.end()))
{
ESM::NAME32 go = soundIter->sound;
int chance = (int) soundIter->chance;
//std::cout << "Sound: " << go.name <<" Chance:" << chance << "\n";
soundIter++;
total += chance;
}
}
srand ( time(NULL) );
int r = rand() % total; //old random code
int pos = 0;
soundIter = test.soundList.begin();
while (!(soundIter == test.soundList.end()))
{
const ESM::NAME32 go = soundIter->sound;
int chance = (int) soundIter->chance;
//std::cout << "Sound: " << go.name <<" Chance:" << chance << "\n";
soundIter++;
if( r - pos < chance)
{
effect = go.name;
//play sound
std::cout << "Sound: " << go.name <<" Chance:" << chance << "\n";
mEnvironment.mSoundManager->playSound(effect, 20.0, 1.0);
break;
}
pos += chance;
}
}
//mEnvironment.mSoundManager->playSound(effect, 1.0, 1.0);
//printf("REGION: %s\n", test.name);
}
else if(current->cell->data.flags & current->cell->Interior)
{
test.name = "";
}
try try
{ {
mEnvironment.mFrameDuration = evt.timeSinceLastFrame; mEnvironment.mFrameDuration = evt.timeSinceLastFrame;
@ -108,6 +184,7 @@ bool OMW::Engine::frameStarted(const Ogre::FrameEvent& evt)
{ {
std::cerr << "Error in framelistener: " << e.what() << std::endl; std::cerr << "Error in framelistener: " << e.what() << std::endl;
} }
//std::cout << "TESTING2";
return true; return true;
} }
@ -217,6 +294,11 @@ void OMW::Engine::go()
assert (!mCellName.empty()); assert (!mCellName.empty());
assert (!mMaster.empty()); assert (!mMaster.empty());
test.name = "";
total = 0;
std::cout << "Data directory: " << mDataDir << "\n"; std::cout << "Data directory: " << mDataDir << "\n";
const char* plugCfg = "plugins.cfg"; const char* plugCfg = "plugins.cfg";
@ -257,7 +339,7 @@ void OMW::Engine::go()
mEnvironment.mSoundManager = new MWSound::SoundManager(mOgre.getRoot(), mEnvironment.mSoundManager = new MWSound::SoundManager(mOgre.getRoot(),
mOgre.getCamera(), mOgre.getCamera(),
mEnvironment.mWorld->getStore(), mEnvironment.mWorld->getStore(),
(mDataDir / "Sound").file_string(), (mDataDir),
mUseSound); mUseSound);
// Create script system // Create script system
@ -306,16 +388,7 @@ void OMW::Engine::go()
mOgre.getRoot()->addFrameListener (this); mOgre.getRoot()->addFrameListener (this);
// Play some good 'ol tunes // Play some good 'ol tunes
std::string music = (mDataDir / "Music/Explore/mx_explore_5.mp3").file_string(); mEnvironment.mSoundManager->startRandomTitle();
try
{
std::cout << "Playing " << music << "\n";
mEnvironment.mSoundManager->streamMusic(music);
}
catch(std::exception &e)
{
std::cout << " Music Error: " << e.what() << "\n";
}
// scripts // scripts
if (mCompileAll) if (mCompileAll)

8
apps/openmw/engine.hpp
View file

@ -12,6 +12,8 @@
#include "mwworld/environment.hpp" #include "mwworld/environment.hpp"
#include "mwworld/ptr.hpp" #include "mwworld/ptr.hpp"
#include <boost/timer.hpp>
namespace Compiler namespace Compiler
{ {
@ -52,6 +54,8 @@ namespace OMW
class Engine : private Ogre::FrameListener class Engine : private Ogre::FrameListener
{ {
//int nFiles;
boost::filesystem::path mDataDir; boost::filesystem::path mDataDir;
OEngine::Render::OgreRenderer mOgre; OEngine::Render::OgreRenderer mOgre;
std::string mCellName; std::string mCellName;
@ -61,12 +65,15 @@ namespace OMW
bool mNewGame; bool mNewGame;
bool mUseSound; bool mUseSound;
bool mCompileAll; bool mCompileAll;
int total;
MWWorld::Environment mEnvironment; MWWorld::Environment mEnvironment;
MWScript::ScriptManager *mScriptManager; MWScript::ScriptManager *mScriptManager;
Compiler::Extensions mExtensions; Compiler::Extensions mExtensions;
Compiler::Context *mScriptContext; Compiler::Context *mScriptContext;
OEngine::GUI::MyGUIManager *mGuiManager; OEngine::GUI::MyGUIManager *mGuiManager;
ESM::Region test;
boost::timer timer;
int focusFrameCounter; int focusFrameCounter;
static const int focusUpdateFrame = 10; static const int focusUpdateFrame = 10;
@ -79,6 +86,7 @@ namespace OMW
/// add resources directory /// add resources directory
/// \note This function works recursively. /// \note This function works recursively.
void addResourcesDirectory (const boost::filesystem::path& path); void addResourcesDirectory (const boost::filesystem::path& path);
/// Load all BSA files in data directory. /// Load all BSA files in data directory.

209
apps/openmw/mwclass/npc.cpp
View file

@ -14,6 +14,7 @@
#include "../mwrender/cellimp.hpp" #include "../mwrender/cellimp.hpp"
#include "../mwmechanics/mechanicsmanager.hpp" #include "../mwmechanics/mechanicsmanager.hpp"
#include <OgreSceneNode.h>
namespace MWClass namespace MWClass
{ {
@ -28,32 +29,230 @@ namespace MWClass
void Npc::insertObj (const MWWorld::Ptr& ptr, MWRender::CellRenderImp& cellRender, void Npc::insertObj (const MWWorld::Ptr& ptr, MWRender::CellRenderImp& cellRender,
MWWorld::Environment& environment) const MWWorld::Environment& environment) const
{ {
//Ogre::SceneNode *chest;
ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData> *ref = ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData> *ref =
ptr.get<ESM::NPC>(); ptr.get<ESM::NPC>();
//Store scenenodes by npc's name + bodypart [0] , npc's name + bodypart [1]
//Ex. Fargothchest , Fargothneck
assert (ref->base != NULL); assert (ref->base != NULL);
std::string hairID = ref->base->hair;
std::string headID = ref->base->head; std::string headID = ref->base->head;
std::string npcName = ref->base->name;
std::cout << "NPC: " << npcName << "\n";
//get the part of the bodypart id which describes the race and the gender //get the part of the bodypart id which describes the race and the gender
std::string bodyRaceID = headID.substr(0, headID.find_last_of("head_") - 4); std::string bodyRaceID = headID.substr(0, headID.find_last_of("head_") - 4);
std::string headModel = "meshes\\" + std::string headModel = "meshes\\" +
environment.mWorld->getStore().bodyParts.find(headID)->model; environment.mWorld->getStore().bodyParts.find(headID)->model;
std::string hairModel = "meshes\\" +
environment.mWorld->getStore().bodyParts.find(hairID)->model;
MWRender::Rendering rendering (cellRender, ref->ref); MWRender::Rendering rendering (cellRender, ref->ref);
cellRender.insertMesh (headModel);
//TODO: define consts for each bodypart e.g. chest, foot, wrist... and put the parts in the //TODO: define consts for each bodypart e.g. chest, foot, wrist... and put the parts in the
// right place // right place
const ESM::BodyPart *bodyPart = const ESM::BodyPart *bodyPart =
environment.mWorld->getStore().bodyParts.search (bodyRaceID + "chest"); environment.mWorld->getStore().bodyParts.search (bodyRaceID + "chest");
if (bodyPart) //bodyPart->model->
cellRender.insertMesh("meshes\\" + bodyPart->model); Ogre::Vector3 pos = Ogre::Vector3( 20, 20, 20);
Ogre::Vector3 axis = Ogre::Vector3( 0, 0, 1);
Ogre::Radian angle = Ogre::Radian(0);
ref->mData.setHandle (rendering.end (ref->mData.isEnabled())); std::string addresses[6] = {"", "", "", "","", ""};
} std::string addresses2[6] = {"", "", "", "", "", ""};
std::string upperleft[5] = {"", "", "", "", ""};
std::string upperright[5] = {"", "", "", "", ""};
std::string neckandup[5] = {"", "", "","",""};
std::string empty[6] = {"", "", "", "","", ""};
int numbers = 0;
int uppernumbers = 0;
int neckNumbers = 0;
if (bodyPart){
cellRender.insertMesh("meshes\\" + bodyPart->model, pos, axis, angle, npcName + "chest", addresses, numbers, true); //2 0
addresses2[numbers] = npcName + "chest";
addresses[numbers++] = npcName + "chest";
upperleft[uppernumbers] = npcName + "chest";
upperright[uppernumbers++] = npcName + "chest";
neckandup[neckNumbers++] = npcName + "chest";
}
//std::cout << "GETTING NPC PART";
//Orgre::SceneNode test = cellRender.getNpcPart();
const ESM::BodyPart *upperleg = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "upper leg");
const ESM::BodyPart *groin = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "groin");
const ESM::BodyPart *arm = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "upper arm");
const ESM::BodyPart *neck = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "neck");
const ESM::BodyPart *knee = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "knee");
const ESM::BodyPart *ankle = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "ankle");
const ESM::BodyPart *foot = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "foot");
const ESM::BodyPart *feet = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "feet");
const ESM::BodyPart *tail = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "tail");
const ESM::BodyPart *wrist = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "wrist");
const ESM::BodyPart *forearm = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "forearm");
const ESM::BodyPart *hand = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "hand.1st");
const ESM::BodyPart *hands = environment.mWorld->getStore().bodyParts.search (bodyRaceID + "hands.1st");
std::cout << "RACE" << bodyRaceID << "\n";
Ogre::Vector3 pos2 = Ogre::Vector3( 0, .5, 75);
std::string upperarmpath[2] = {npcName + "chest", npcName + "upper arm"};
if (groin){
cellRender.insertMesh("meshes\\" + groin->model, pos2, axis, Ogre::Radian(3.14), npcName + "groin", addresses, numbers);
addresses2[numbers] = npcName + "groin";
addresses[numbers++] = npcName + "groin";
}
if (tail) {
cellRender.insertMesh("tail\\" + tail->model, Ogre::Vector3(0 , 0, -76), axis, Ogre::Radian(3.14), npcName + "tail", addresses, numbers, "tail");
//std::cout << "TAIL\n";
}
//addresses[1] = npcName + "groin";
if(upperleg){
cellRender.insertMesh ("meshes\\" + upperleg->model, Ogre::Vector3( 6, 0, -14), axis, Ogre::Radian(3.14), npcName + "upper leg", addresses, numbers); //-18
cellRender.insertMesh ("meshes\\" + upperleg->model, Ogre::Vector3( -6, 0, -14), axis, Ogre::Radian(0), npcName + "upper leg2", addresses2, numbers);
addresses2[numbers] = npcName + "upper leg2";
addresses[numbers++] = npcName + "upper leg";
cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), addresses, numbers);
}
if(knee)
{
cellRender.insertMesh ("meshes\\" + knee->model, Ogre::Vector3( 0, -2, -18), axis, Ogre::Radian(0), npcName + "knee", addresses, numbers);
//cellRender.rotateMesh(Ogre::Vector3(0, 1, 0), Ogre::Radian (1), npcName + "upper arm");
cellRender.insertMesh ("meshes\\" + knee->model, Ogre::Vector3( 0, -2, -18), axis, Ogre::Radian(0), npcName + "knee2", addresses2, numbers);
addresses2[numbers] = npcName + "knee2";
addresses[numbers++] = npcName + "knee";
}
if(ankle){
cellRender.insertMesh ("meshes\\" + ankle->model, Ogre::Vector3( 0, -1, -18), axis, Ogre::Radian(0), npcName + "ankle", addresses, numbers); //-1
cellRender.insertMesh ("meshes\\" + ankle->model, Ogre::Vector3( 0, -1, -18), axis, Ogre::Radian(0), npcName + "ankle2", addresses2, numbers); //-1
addresses2[numbers] = npcName + "ankle2";
addresses[numbers++] = npcName + "ankle";
}
if(foot){
if(bodyRaceID.compare("b_n_khajiit_m_") == 0)
{
feet = foot;
}
else
{
cellRender.insertMesh ("meshes\\" + foot->model, Ogre::Vector3( 0, -4, -15), axis, Ogre::Radian(0), npcName + "foot", addresses, numbers);
cellRender.insertMesh ("meshes\\" + foot->model, Ogre::Vector3( 0, -4, -15), axis, Ogre::Radian(0), npcName + "foot2", addresses2, numbers);
addresses2[numbers] = npcName + "foot2";
addresses[numbers++] = npcName + "foot";
}
//cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), addresses, numbers);
}
if(feet){
cellRender.insertMesh ("foot\\" + feet->model, Ogre::Vector3( 7, 4, -16), axis, Ogre::Radian(3.14), npcName + "foot", addresses, numbers); //9, 0, -14
cellRender.insertMesh ("foot\\" + feet->model, Ogre::Vector3( 7, 4, -16), axis, Ogre::Radian(3.14), npcName + "foot2", addresses2, numbers);
addresses2[numbers] = npcName + "foot2";
addresses[numbers++] = npcName + "foot";
//cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), addresses, numbers);
}
if (arm){
//010
cellRender.insertMesh("meshes\\" + arm->model, Ogre::Vector3(-12.5, 0, 104), Ogre::Vector3(0, 1, 0), Ogre::Radian(-3.14 / 2), npcName + "upper arm", upperleft, uppernumbers); //1, 0,.75
//cellRender.rotateMesh(Ogre::Vector3(1, 0, 0), Ogre::Radian (.45), upperarmpath, 2); //-.5, 0, -.75
cellRender.insertMesh("meshes\\" + arm->model, Ogre::Vector3(12.5, 0, 105), Ogre::Vector3(-.5, 0, -.75), Ogre::Radian(3.14), npcName + "upper arm2", upperright, uppernumbers);
upperleft[uppernumbers] = npcName + "upper arm";
upperright[uppernumbers++] = npcName + "upper arm2";
cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), upperleft, uppernumbers); //1 -1 1
cellRender.rotateMesh(Ogre::Vector3(0, .1, 0), Ogre::Radian(3.14/2), upperleft, uppernumbers);
}
if (forearm)
{
//addresses[1] = npcName + "upper arm";
cellRender.insertMesh("meshes\\" + forearm->model, Ogre::Vector3(-12.5, 0, 0), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "forearm", upperleft, uppernumbers);
cellRender.insertMesh("meshes\\" + forearm->model, Ogre::Vector3(-12.5, 0, 0), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "forearm2", upperright, uppernumbers);
upperleft[uppernumbers] = npcName + "forearm";
upperright[uppernumbers++] = npcName + "forearm2";
}
//else
// std::cout << npcName << "has no forearm";
if (wrist)
{
if(upperleft[uppernumbers - 1].compare(npcName + "upper arm") == 0)
{
cellRender.insertMesh("meshes\\b\\B_N_Argonian_M_Forearm.nif", Ogre::Vector3(-12.5, 0, 0), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "forearm", upperleft, uppernumbers);
cellRender.insertMesh("meshes\\b\\B_N_Argonian_M_Forearm.nif", Ogre::Vector3(-12.5, 0, 0), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "forearm2", upperright, uppernumbers);
upperleft[uppernumbers] = npcName + "forearm";
upperright[uppernumbers++] = npcName + "forearm2";
}
cellRender.insertMesh("meshes\\" + wrist->model, Ogre::Vector3(-9.5, 0, 0), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "wrist", upperleft, uppernumbers);
cellRender.insertMesh("meshes\\" + wrist->model, Ogre::Vector3(-9.5, 0, 0), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "wrist2", upperright, uppernumbers);
upperleft[uppernumbers] = npcName + "wrist";
upperright[uppernumbers++] = npcName + "wrist2";
}
if(hand)
{
//std::cout << "WE FOUND A HAND\n";
//-50, 0, -120
//std::cout << "WE FOUND HANDS\n";
std::string pass;
if(hand->model.compare("b\\B_N_Dark Elf_F_Hands.1st.NIF")==0 && bodyRaceID.compare("b_n_dark elf_m_") == 0)
pass = "b\\B_N_Dark Elf_M_Hands.1st.NIF";
else
pass = hand->model;
cellRender.insertMesh("meshes\\" + pass, Ogre::Vector3(42, 1, -110), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "hand", upperleft, uppernumbers,false); //0, 100, -100 0,0,120
cellRender.insertMesh("meshes\\" + pass, Ogre::Vector3(42, 1, -110), Ogre::Vector3(0, 0,0), Ogre::Radian(3.14), npcName + "hand2", upperright, uppernumbers, false); //0, 100, -100 0,0,120
upperleft[uppernumbers] = npcName + "hand";
upperright[uppernumbers++] = npcName + "hand2";
//cellRender.rotateMesh(Ogre::Vector3(0, 0,0), Ogre::Radian(3.14), upperleft, uppernumbers);
cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), upperleft, uppernumbers);
cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), upperright, uppernumbers);
}
if(hands)
{
std::string pass;
if(hands->model.compare("b\\B_N_Redguard_F_Hands.1st.nif")==0 && bodyRaceID.compare("b_n_redguard_m_") == 0)
pass = "b\\B_N_Redguard_M_Hands.1st.nif";
else if(hands->model.compare("b\\B_N_Imperial_M_Hands.1st.nif") == 0 && bodyRaceID.compare("b_n_nord_m_") == 0)
pass = "b\\B_N_Nord_M_Hands.1st.nif";
else
pass =hands->model; //-50, 0, -120
cellRender.insertMesh("meshes\\" + pass, Ogre::Vector3(42, 1,-110), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "hand", upperleft, uppernumbers, false); //0, 100, -100 42, 0, -110
//cellRender.insertMesh("meshes\\" + hands->model, Ogre::Vector3(42, 0,110), Ogre::Vector3(1, 0, 0), Ogre::Radian(3.14), npcName + "hand", upperleft, uppernumbers, false); //0, 100, -100 42, 0, -110
cellRender.insertMesh("meshes\\" + pass, Ogre::Vector3(42, 1, -110), Ogre::Vector3(0, 0, 0), Ogre::Radian(3.14), npcName + "hand2", upperright, uppernumbers, false); //0, 100, -100 0,0,120
upperleft[uppernumbers] = npcName + "hand";
upperright[uppernumbers++] = npcName + "hand2";
cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), upperleft, uppernumbers);
cellRender.scaleMesh(Ogre::Vector3(1, -1, 1), upperright, uppernumbers);
}
//neck will reset chest counter
if(neck)
{
cellRender.insertMesh ("meshes\\" + neck->model, Ogre::Vector3( 0, 0, 120), axis, Ogre::Radian(3.14), npcName + "neck", neckandup, neckNumbers);
neckandup[neckNumbers++] = npcName + "neck";
}
cellRender.insertMesh (headModel, Ogre::Vector3( 0, 0, 5), axis, Ogre::Radian(0), npcName + "head", neckandup, neckNumbers);
neckandup[neckNumbers++] = npcName + "head";
cellRender.insertMesh (hairModel, Ogre::Vector3( 0, -1, 0), axis, Ogre::Radian(0), npcName + "hair", neckandup, neckNumbers);
ref->mData.setHandle (rendering.end (ref->mData.isEnabled()));
}
void Npc::enable (const MWWorld::Ptr& ptr, MWWorld::Environment& environment) const void Npc::enable (const MWWorld::Ptr& ptr, MWWorld::Environment& environment) const
{ {

2
apps/openmw/mwclass/npc.hpp
View file

@ -5,6 +5,8 @@
namespace MWClass namespace MWClass
{ {
static bool isChest;
//static ;bool isChest = false;
class Npc : public MWWorld::Class class Npc : public MWWorld::Class
{ {
public: public:

14
apps/openmw/mwrender/cellimp.hpp
View file

@ -6,6 +6,13 @@
#include "components/esm_store/cell_store.hpp" #include "components/esm_store/cell_store.hpp"
#include "../mwworld/refdata.hpp" #include "../mwworld/refdata.hpp"
#include <OgreMath.h>
namespace Ogre
{
class SceneNode;
class Vector3;
}
namespace ESM namespace ESM
{ {
@ -16,7 +23,6 @@ namespace MWWorld
{ {
class Environment; class Environment;
} }
namespace MWRender namespace MWRender
{ {
/// Base class for cell render, that implements inserting references into a cell in a /// Base class for cell render, that implements inserting references into a cell in a
@ -31,9 +37,15 @@ namespace MWRender
/// start inserting a new reference. /// start inserting a new reference.
virtual void insertBegin (ESM::CellRef &ref) = 0; virtual void insertBegin (ESM::CellRef &ref) = 0;
virtual void rotateMesh(Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName[], int elements) = 0;
/// insert a mesh related to the most recent insertBegin call. /// insert a mesh related to the most recent insertBegin call.
virtual void insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements, bool translateFirst) = 0;
virtual void insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements) = 0;
virtual void insertMesh(const std::string &mesh) = 0; virtual void insertMesh(const std::string &mesh) = 0;
virtual void scaleMesh(Ogre::Vector3 axis, std::string sceneNodeName[], int elements) = 0;
/// insert a light related to the most recent insertBegin call. /// insert a light related to the most recent insertBegin call.
virtual void insertLight(float r, float g, float b, float radius) = 0; virtual void insertLight(float r, float g, float b, float radius) = 0;

129
apps/openmw/mwrender/exterior.cpp
View file

@ -8,6 +8,9 @@
#include <components/nifogre/ogre_nif_loader.hpp> #include <components/nifogre/ogre_nif_loader.hpp>
#include "mwscene.hpp" #include "mwscene.hpp"
#include <libs/mangle/vfs/servers/ogre_vfs.hpp>
#include "mwscene.hpp"
#include <Ogre.h>
using namespace MWRender; using namespace MWRender;
using namespace Ogre; using namespace Ogre;
@ -57,8 +60,134 @@ void ExteriorCellRender::insertBegin (ESM::CellRef &ref)
insert->setOrientation(xr*yr*zr); insert->setOrientation(xr*yr*zr);
} }
void ExteriorCellRender::rotateMesh(Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName[], int elements)
{
assert(insert);
Ogre::SceneNode *parent = insert;
//std::cout << "ELEMENTS:" << elements;
for (int i = 0; i < elements; i++){
if(sceneNodeName[i] != "" && parent->getChild(sceneNodeName[i]))
parent = dynamic_cast<Ogre::SceneNode*> (parent->getChild(sceneNodeName[i]));
}
parent->rotate(axis, angle);
}
/*
void ExteriorCellRender::insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements){
assert (insert);
//insert->
Ogre::SceneNode *parent = insert;
for (int i = 0; i < elements; i++){
if(sceneParent[i] != "" && parent->getChild(sceneParent[i]))
parent = dynamic_cast<Ogre::SceneNode*> (parent->getChild(sceneParent[i]));
}
npcPart = parent->createChildSceneNode(sceneNodeName);
NIFLoader::load(mesh);
MovableObject *ent = scene.getMgr()->createEntity(mesh);
npcPart->translate(vec);
npcPart->rotate(axis, angle);
// npcPart->translate(vec);
//npcPart->rotate(axis, angle);
npcPart->attachObject(ent);
//npcPart->
}
*/
void ExteriorCellRender::insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements)
{
insertMesh(mesh, vec, axis, angle, sceneNodeName, sceneParent, elements, true);
}
void ExteriorCellRender::insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements, bool translateFirst){
assert (insert);
//insert->
Ogre::SceneNode *parent = insert;
for (int i = 0; i < elements; i++){
if(sceneParent[i] != "" && parent->getChild(sceneParent[i]))
parent = dynamic_cast<Ogre::SceneNode*> (parent->getChild(sceneParent[i]));
}
npcPart = parent->createChildSceneNode(sceneNodeName);
MeshPtr good2 = NIFLoader::load(mesh);
MovableObject *ent = scene.getMgr()->createEntity(mesh);
npcPart->translate(vec);
npcPart->rotate(axis, angle);
npcPart->attachObject(ent);
Ogre::MeshManager *m = MeshManager::getSingletonPtr();
const std::string beast1 ="meshes\\b\\B_N_Khajiit_F_Skins.nif";
const std::string beast2 ="meshes\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beast3 ="meshes\\b\\B_N_Argonian_F_Skins.nif";
const std::string beast4 ="meshes\\b\\B_N_Argonian_M_Skins.nif";
const std::string beasttail1 ="tail\\b\\B_N_Khajiit_F_Skins.nif";
const std::string beasttail2 ="tail\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beasttail3 ="tail\\b\\B_N_Argonian_F_Skins.nif";
const std::string beasttail4 ="tail\\b\\B_N_Argonian_M_Skins.nif";
const std::string beastfoot1 ="foot\\b\\B_N_Khajiit_F_Skins.nif";
const std::string beastfoot2 ="foot\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beastfoot3 ="foot\\b\\B_N_Argonian_F_Skins.nif";
const std::string beastfoot4 ="foot\\b\\B_N_Argonian_M_Skins.nif";
if(mesh.compare(beast1) == 0 && m->getByName(beasttail1).isNull())
{
//std::cout << "CLONINGKHAJIITF\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail1);
good2->reload();
MeshPtr foot = good2->clone(beastfoot1);
good2->reload();
}
else if(mesh.compare(beast2) == 0 && m->getByName(beasttail2).isNull())
{
//std::cout << "CLONINGKHAJIITM\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail2);
good2->reload();
MeshPtr foot = good2->clone(beastfoot2);
good2->reload();
}
else if(mesh.compare(beast3) == 0 && m->getByName(beasttail3).isNull())
{
//std::cout << "CLONINGARGONIANF\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail3);
good2->reload();
MeshPtr foot = good2->clone(beastfoot3);
good2->reload();
}
else if(mesh.compare(beast4) == 0 && m->getByName(beasttail4).isNull())
{
//std::cout << "CLONINGARGONIANM\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail4);
good2->reload();
MeshPtr foot = good2->clone(beastfoot4);
good2->reload();
}
}
// insert a mesh related to the most recent insertBegin call. // insert a mesh related to the most recent insertBegin call.
void ExteriorCellRender::scaleMesh(Ogre::Vector3 axis, std::string sceneNodeName[], int elements)
{
assert(insert);
Ogre::SceneNode *parent = insert;
//std::cout << "ELEMENTS:" << elements;
for (int i = 0; i < elements; i++){
if(sceneNodeName[i] != "" && parent->getChild(sceneNodeName[i]))
parent = dynamic_cast<Ogre::SceneNode*> (parent->getChild(sceneNodeName[i]));
}
parent->scale(axis);
}
// insert a mesh related to the most recent insertBegin call.
void ExteriorCellRender::insertMesh(const std::string &mesh) void ExteriorCellRender::insertMesh(const std::string &mesh)
{ {
assert (insert); assert (insert);

10
apps/openmw/mwrender/exterior.hpp
View file

@ -5,6 +5,7 @@
#include "cellimp.hpp" #include "cellimp.hpp"
#include "OgreColourValue.h" #include "OgreColourValue.h"
#include <OgreMath.h>
namespace Ogre namespace Ogre
{ {
@ -53,6 +54,7 @@ namespace MWRender
Ogre::SceneNode *base; Ogre::SceneNode *base;
Ogre::SceneNode *insert; Ogre::SceneNode *insert;
Ogre::SceneNode *npcPart;
// 0 normal, 1 more bright, 2 max // 0 normal, 1 more bright, 2 max
int ambientMode; int ambientMode;
@ -63,7 +65,12 @@ namespace MWRender
virtual void insertBegin (ESM::CellRef &ref); virtual void insertBegin (ESM::CellRef &ref);
/// insert a mesh related to the most recent insertBegin call. /// insert a mesh related to the most recent insertBegin call.
virtual void insertMesh(const std::string &mesh); virtual void insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements);
virtual void insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements, bool translateFirst);
virtual void insertMesh(const std::string &mesh);
virtual void rotateMesh(Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName[], int elements);
virtual void scaleMesh(Ogre::Vector3 axis, std::string sceneNodeName[], int elements);
/// insert a light related to the most recent insertBegin call. /// insert a light related to the most recent insertBegin call.
virtual void insertLight(float r, float g, float b, float radius); virtual void insertLight(float r, float g, float b, float radius);
@ -79,6 +86,7 @@ namespace MWRender
void setAmbientMode(); void setAmbientMode();
public: public:
ExteriorCellRender(ESMS::CellStore<MWWorld::RefData> &_cell, MWWorld::Environment& environment, ExteriorCellRender(ESMS::CellStore<MWWorld::RefData> &_cell, MWWorld::Environment& environment,

119
apps/openmw/mwrender/interior.cpp
View file

@ -5,9 +5,14 @@
#include <OgreSceneNode.h> #include <OgreSceneNode.h>
#include <OgreCamera.h> #include <OgreCamera.h>
#include <OgreSceneManager.h> #include <OgreSceneManager.h>
#include <OgreMath.h>
#include <components/nifogre/ogre_nif_loader.hpp> #include <components/nifogre/ogre_nif_loader.hpp>
#include "mwscene.hpp" #include "mwscene.hpp"
#include <Ogre.h>
#include <stdio.h>
#include <libs/mangle/vfs/servers/ogre_vfs.hpp>
using namespace MWRender; using namespace MWRender;
using namespace Ogre; using namespace Ogre;
@ -58,6 +63,120 @@ void InteriorCellRender::insertBegin (ESM::CellRef &ref)
} }
// insert a mesh related to the most recent insertBegin call. // insert a mesh related to the most recent insertBegin call.
void InteriorCellRender::rotateMesh(Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName[], int elements)
{
assert(insert);
Ogre::SceneNode *parent = insert;
//std::cout << "ELEMENTS:" << elements;
for (int i = 0; i < elements; i++){
if(sceneNodeName[i] != "" && parent->getChild(sceneNodeName[i]))
parent = dynamic_cast<Ogre::SceneNode*> (parent->getChild(sceneNodeName[i]));
}
parent->rotate(axis, angle);
}
// insert a mesh related to the most recent insertBegin call.
void InteriorCellRender::scaleMesh(Ogre::Vector3 axis, std::string sceneNodeName[], int elements)
{
assert(insert);
Ogre::SceneNode *parent = insert;
//std::cout << "ELEMENTS:" << elements;
for (int i = 0; i < elements; i++){
if(sceneNodeName[i] != "" && parent->getChild(sceneNodeName[i]))
parent = dynamic_cast<Ogre::SceneNode*> (parent->getChild(sceneNodeName[i]));
}
parent->scale(axis);
}
void InteriorCellRender::insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements)
{
insertMesh(mesh, vec, axis, angle, sceneNodeName, sceneParent, elements, true);
}
void InteriorCellRender::insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements, bool translateFirst){
assert (insert);
//insert->
Ogre::SceneNode *parent = insert;
for (int i = 0; i < elements; i++){
if(sceneParent[i] != "" && parent->getChild(sceneParent[i]))
parent = dynamic_cast<Ogre::SceneNode*> (parent->getChild(sceneParent[i]));
}
npcPart = parent->createChildSceneNode(sceneNodeName);
//npcPart->showBoundingBox(true);
MeshPtr good2 = NIFLoader::load(mesh);
MovableObject *ent = scene.getMgr()->createEntity(mesh);
//ent->extr
// MovableObject *ent2 = scene.getMgr()->createEntity(bounds
// );
//ent->
//std::cout << mesh << bounds << "\n";
if(translateFirst){
npcPart->translate(vec);
npcPart->rotate(axis, angle);
}
else{
npcPart->rotate(axis, angle);
npcPart->translate(vec);
}
npcPart->attachObject(ent);
Ogre::MeshManager *m = MeshManager::getSingletonPtr();
const std::string beast1 ="meshes\\b\\B_N_Khajiit_F_Skins.nif";
const std::string beast2 ="meshes\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beast3 ="meshes\\b\\B_N_Argonian_F_Skins.nif";
const std::string beast4 ="meshes\\b\\B_N_Argonian_M_Skins.nif";
const std::string beasttail1 ="tail\\b\\B_N_Khajiit_F_Skins.nif";
const std::string beasttail2 ="tail\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beasttail3 ="tail\\b\\B_N_Argonian_F_Skins.nif";
const std::string beasttail4 ="tail\\b\\B_N_Argonian_M_Skins.nif";
const std::string beastfoot1 ="foot\\b\\B_N_Khajiit_F_Skins.nif";
const std::string beastfoot2 ="foot\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beastfoot3 ="foot\\b\\B_N_Argonian_F_Skins.nif";
const std::string beastfoot4 ="foot\\b\\B_N_Argonian_M_Skins.nif";
if(mesh.compare(beast1) == 0 && m->getByName(beasttail1).isNull())
{
//std::cout << "CLONINGKHAJIITF\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail1);
good2->reload();
MeshPtr foot = good2->clone(beastfoot1);
good2->reload();
}
else if(mesh.compare(beast2) == 0 && m->getByName(beasttail2).isNull())
{
//std::cout << "CLONINGKHAJIITM\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail2);
good2->reload();
MeshPtr foot = good2->clone(beastfoot2);
good2->reload();
}
else if(mesh.compare(beast3) == 0 && m->getByName(beasttail3).isNull())
{
//std::cout << "CLONINGARGONIANF\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail3);
good2->reload();
MeshPtr foot = good2->clone(beastfoot3);
good2->reload();
}
else if(mesh.compare(beast4) == 0 && m->getByName(beasttail4).isNull())
{
//std::cout << "CLONINGARGONIANM\n";
good2->reload();
MeshPtr tail = good2->clone(beasttail4);
good2->reload();
MeshPtr foot = good2->clone(beastfoot4);
good2->reload();
}
}
void InteriorCellRender::insertMesh(const std::string &mesh) void InteriorCellRender::insertMesh(const std::string &mesh)
{ {

12
apps/openmw/mwrender/interior.hpp
View file

@ -5,6 +5,7 @@
#include "cellimp.hpp" #include "cellimp.hpp"
#include "OgreColourValue.h" #include "OgreColourValue.h"
#include <OgreSceneNode.h>
namespace Ogre namespace Ogre
{ {
@ -28,7 +29,7 @@ namespace MWRender
class InteriorCellRender : public CellRender, private CellRenderImp class InteriorCellRender : public CellRender, private CellRenderImp
{ {
//static bool isChest;
static bool lightConst; static bool lightConst;
static float lightConstValue; static float lightConstValue;
@ -53,6 +54,7 @@ namespace MWRender
Ogre::SceneNode *base; Ogre::SceneNode *base;
Ogre::SceneNode *insert; Ogre::SceneNode *insert;
Ogre::SceneNode *npcPart;
// 0 normal, 1 more bright, 2 max // 0 normal, 1 more bright, 2 max
int ambientMode; int ambientMode;
@ -61,10 +63,12 @@ namespace MWRender
/// start inserting a new reference. /// start inserting a new reference.
virtual void insertBegin (ESM::CellRef &ref); virtual void insertBegin (ESM::CellRef &ref);
virtual void rotateMesh(Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName[], int elements);
virtual void scaleMesh(Ogre::Vector3 axis, std::string sceneNodeName[], int elements);
/// insert a mesh related to the most recent insertBegin call. /// insert a mesh related to the most recent insertBegin call.
virtual void insertMesh(const std::string &mesh); virtual void insertMesh(const std::string &mesh);
virtual void insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements);
virtual void insertMesh(const std::string &mesh, Ogre::Vector3 vec, Ogre::Vector3 axis, Ogre::Radian angle, std::string sceneNodeName, std::string sceneParent[], int elements, bool translateFirst);
/// insert a light related to the most recent insertBegin call. /// insert a light related to the most recent insertBegin call.
virtual void insertLight(float r, float g, float b, float radius); virtual void insertLight(float r, float g, float b, float radius);
@ -79,6 +83,7 @@ namespace MWRender
void setAmbientMode(); void setAmbientMode();
public: public:
InteriorCellRender(ESMS::CellStore<MWWorld::RefData> &_cell, MWWorld::Environment& environment, InteriorCellRender(ESMS::CellStore<MWWorld::RefData> &_cell, MWWorld::Environment& environment,
@ -88,6 +93,7 @@ namespace MWRender
virtual ~InteriorCellRender() { destroy(); } virtual ~InteriorCellRender() { destroy(); }
/// Make the cell visible. Load the cell if necessary. /// Make the cell visible. Load the cell if necessary.
//virtual void scaleMesh(Ogre::Vector3 axis, std::string sceneNodeName[], int elements);
virtual void show(); virtual void show();
/// Remove the cell from rendering, but don't remove it from /// Remove the cell from rendering, but don't remove it from

74
apps/openmw/mwsound/soundmanager.cpp
View file

@ -62,6 +62,7 @@ namespace MWSound
sounds based on the sound factory it is given. sounds based on the sound factory it is given.
*/ */
OEManagerPtr mgr; OEManagerPtr mgr;
SoundPtr music;
/* This class calls update() on the sound manager each frame /* This class calls update() on the sound manager each frame
using and Ogre::FrameListener using and Ogre::FrameListener
@ -305,12 +306,13 @@ namespace MWSound
SoundManager::SoundManager(Ogre::Root *root, Ogre::Camera *camera, SoundManager::SoundManager(Ogre::Root *root, Ogre::Camera *camera,
const ESMS::ESMStore &store, const ESMS::ESMStore &store,
const std::string &soundDir, boost::filesystem::path dataDir,
bool useSound) bool useSound)
: mData(NULL) : mData(NULL)
{ {
MP3Lookup(dataDir / "Music/Explore/");
if(useSound) if(useSound)
mData = new SoundImpl(root, camera, store, soundDir); mData = new SoundImpl(root, camera, store, (dataDir / "Sound").file_string());
} }
SoundManager::~SoundManager() SoundManager::~SoundManager()
@ -319,6 +321,62 @@ namespace MWSound
delete mData; delete mData;
} }
void SoundManager::MP3Lookup(boost::filesystem::path dir)
{
boost::filesystem::directory_iterator dir_iter(dir), dir_end;
std::string mp3extension = ".mp3";
for(;dir_iter != dir_end; dir_iter++)
{
if(boost::filesystem::extension(*dir_iter) == mp3extension)
{
files.push_back(*dir_iter);
}
}
}
void SoundManager::startRandomTitle()
{
std::vector<boost::filesystem::path>::iterator fileIter;
if(files.size() > 0)
{
fileIter = files.begin();
srand ( time(NULL) );
int r = rand() % files.size() + 1; //old random code
for(int i = 1; i < r; i++)
{
fileIter++;
}
std::string music = fileIter->file_string();
try
{
std::cout << "Playing " << music << "\n";
streamMusic(music);
}
catch(std::exception &e)
{
std::cout << " Music Error: " << e.what() << "\n";
}
}
}
bool SoundManager::isMusicPlaying()
{
bool test = mData->music->isPlaying();
return test;
}
SoundManager::SoundImpl SoundManager::getMData()
{
// bool test = mData->music->isPlaying();
return *mData;
}
void SoundManager::say (MWWorld::Ptr ptr, const std::string& filename) void SoundManager::say (MWWorld::Ptr ptr, const std::string& filename)
{ {
// The range values are not tested // The range values are not tested
@ -342,16 +400,18 @@ namespace MWSound
// Play the sound and tell it to stream, if possible. TODO: // Play the sound and tell it to stream, if possible. TODO:
// Store the reference, the jukebox will need to check status, // Store the reference, the jukebox will need to check status,
// control volume etc. // control volume etc.
SoundPtr music = mData->mgr->load(filename); if (mData->music)
music->setStreaming(true); mData->music->stop();
music->setVolume(0.4); mData->music = mData->mgr->load(filename);
music->play(); mData->music->setStreaming(true);
mData->music->setVolume(0.4);
mData->music->play();
} }
void SoundManager::playSound (const std::string& soundId, float volume, float pitch) void SoundManager::playSound (const std::string& soundId, float volume, float pitch)
{ {
if(!mData) return; if(!mData) return;
// Play and forget // Play and forget
float min, max; float min, max;
const std::string &file = mData->lookup(soundId, volume, min, max); const std::string &file = mData->lookup(soundId, volume, min, max);

15
apps/openmw/mwsound/soundmanager.hpp
View file

@ -4,7 +4,9 @@
#include <string> #include <string>
#include <map> #include <map>
#include <boost/filesystem.hpp>
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include <openengine/sound/sndmanager.hpp>
namespace Ogre namespace Ogre
{ {
@ -19,18 +21,29 @@ namespace ESMS
namespace MWSound namespace MWSound
{ {
//SoundPtr *music;
class SoundManager class SoundManager
{ {
// Hide implementation details - engine.cpp is compiling // Hide implementation details - engine.cpp is compiling
// enough as it is. // enough as it is.
struct SoundImpl; struct SoundImpl;
SoundImpl *mData; SoundImpl *mData;
std::vector<boost::filesystem::path> files;
public: public:
SoundManager(Ogre::Root*, Ogre::Camera*, const ESMS::ESMStore &store, SoundManager(Ogre::Root*, Ogre::Camera*, const ESMS::ESMStore &store,
const std::string &soundDir, bool useSound); boost::filesystem::path dataDir, bool useSound);
~SoundManager(); ~SoundManager();
void startRandomTitle();
void MP3Lookup(boost::filesystem::path dir);
//struct SoundImpl;
bool isMusicPlaying();
SoundImpl getMData();
void say (MWWorld::Ptr reference, const std::string& filename); void say (MWWorld::Ptr reference, const std::string& filename);
///< Make an actor say some text. ///< Make an actor say some text.
/// \param filename name of a sound file in "Sound/Vo/" in the data directory. /// \param filename name of a sound file in "Sound/Vo/" in the data directory.

12
apps/openmw/mwworld/world.cpp
View file

@ -18,6 +18,10 @@
#include "environment.hpp" #include "environment.hpp"
#include "class.hpp" #include "class.hpp"
#include "refdata.hpp"
#include "globals.hpp"
namespace namespace
{ {
template<typename T> template<typename T>
@ -62,6 +66,7 @@ namespace
namespace MWWorld namespace MWWorld
{ {
void World::insertInteriorScripts (ESMS::CellStore<RefData>& cell) void World::insertInteriorScripts (ESMS::CellStore<RefData>& cell)
{ {
listCellScripts (mStore, cell.activators, mLocalScripts, &cell); listCellScripts (mStore, cell.activators, mLocalScripts, &cell);
@ -605,6 +610,7 @@ namespace MWWorld
adjustSky(); adjustSky();
mCellChanged = true; mCellChanged = true;
//currentRegion->name = "";
} }
void World::changeCell (int X, int Y, const ESM::Position& position) void World::changeCell (int X, int Y, const ESM::Position& position)
@ -681,7 +687,8 @@ namespace MWWorld
mCellChanged = true; mCellChanged = true;
} }
void World::changeToExteriorCell (const ESM::Position& position)
void World::changeToExteriorCell (const ESM::Position& position)
{ {
int x = 0; int x = 0;
int y = 0; int y = 0;
@ -714,7 +721,6 @@ namespace MWWorld
return 0; return 0;
} }
void World::markCellAsUnchanged() void World::markCellAsUnchanged()
{ {
mCellChanged = false; mCellChanged = false;
@ -794,6 +800,8 @@ namespace MWWorld
} }
} }
void World::positionToIndex (float x, float y, int &cellX, int &cellY) const void World::positionToIndex (float x, float y, int &cellX, int &cellY) const
{ {
const int cellSize = 8192; const int cellSize = 8192;

6
apps/openmw/mwworld/world.hpp
View file

@ -39,8 +39,8 @@ namespace MWWorld
class World class World
{ {
public:
public:
typedef std::list<std::pair<std::string, Ptr> > ScriptList; typedef std::list<std::pair<std::string, Ptr> > ScriptList;
private: private:
@ -50,7 +50,7 @@ namespace MWWorld
MWRender::SkyManager* mSkyManager; MWRender::SkyManager* mSkyManager;
MWRender::MWScene mScene; MWRender::MWScene mScene;
MWRender::PlayerPos *mPlayerPos; MWRender::PlayerPos *mPlayerPos;
Ptr::CellStore *mCurrentCell; // the cell, the player is in Ptr::CellStore *mCurrentCell; // the cell, the player is in
CellRenderCollection mActiveCells; CellRenderCollection mActiveCells;
CellRenderCollection mBufferedCells; // loaded, but not active (buffering not implementd yet) CellRenderCollection mBufferedCells; // loaded, but not active (buffering not implementd yet)
ESM::ESMReader mEsm; ESM::ESMReader mEsm;
@ -96,7 +96,7 @@ namespace MWWorld
MWRender::PlayerPos& getPlayerPos(); MWRender::PlayerPos& getPlayerPos();
ESMS::ESMStore& getStore(); ESMS::ESMStore& getStore();
const ScriptList& getLocalScripts() const; const ScriptList& getLocalScripts() const;
///< Names and local variable state of all local scripts in active cells. ///< Names and local variable state of all local scripts in active cells.

19
components/esm_store/reclists.hpp
View file

@ -9,6 +9,11 @@
#include <assert.h> #include <assert.h>
#include <stdexcept> #include <stdexcept>
#include <iterator> #include <iterator>
#include <boost/algorithm/string.hpp>
using namespace boost::algorithm;
namespace ESMS namespace ESMS
{ {
@ -233,6 +238,15 @@ namespace ESMS
} }
}; };
struct ciLessBoost : std::binary_function<std::string, std::string, bool>
{
bool operator() (const std::string & s1, const std::string & s2) const {
//case insensitive version of is_less
return lexicographical_compare(s1, s2, is_iless());
}
};
// Cells aren't simply indexed by name. Exterior cells are treated // Cells aren't simply indexed by name. Exterior cells are treated
// separately. // separately.
// TODO: case handling (cell names are case-insensitive, but they are also showen to the // TODO: case handling (cell names are case-insensitive, but they are also showen to the
@ -245,7 +259,7 @@ namespace ESMS
int getSize() { return count; } int getSize() { return count; }
// List of interior cells. Indexed by cell name. // List of interior cells. Indexed by cell name.
typedef std::map<std::string,Cell*> IntCells; typedef std::map<std::string,Cell*, ciLessBoost> IntCells;
IntCells intCells; IntCells intCells;
// List of exterior cells. Indexed as extCells[gridX][gridY]. // List of exterior cells. Indexed as extCells[gridX][gridY].
@ -268,6 +282,7 @@ namespace ESMS
} }
} }
const Cell* findInt(const std::string &id) const const Cell* findInt(const std::string &id) const
{ {
IntCells::const_iterator it = intCells.find(id); IntCells::const_iterator it = intCells.find(id);
@ -300,7 +315,7 @@ namespace ESMS
const ExtCellsCol& column = iter->second; const ExtCellsCol& column = iter->second;
for (ExtCellsCol::const_iterator iter = column.begin(); iter!=column.end(); ++iter) for (ExtCellsCol::const_iterator iter = column.begin(); iter!=column.end(); ++iter)
{ {
if (iter->second->name==id) if ( toLower(iter->second->name) == toLower(id))
return iter->second; return iter->second;
} }
} }

3
components/esm_store/store.hpp
View file

@ -115,13 +115,12 @@ namespace ESMS
recLists[REC_GLOB] = &globals; recLists[REC_GLOB] = &globals;
recLists[REC_GMST] = &gameSettings; recLists[REC_GMST] = &gameSettings;
recLists[REC_INGR] = &ingreds; recLists[REC_INGR] = &ingreds;
recLists[REC_LAND] = &lands; //recLists[REC_LAND] = &lands;
recLists[REC_LEVC] = &creatureLists; recLists[REC_LEVC] = &creatureLists;
recLists[REC_LEVI] = &itemLists; recLists[REC_LEVI] = &itemLists;
recLists[REC_LIGH] = &lights; recLists[REC_LIGH] = &lights;
recLists[REC_LOCK] = &lockpicks; recLists[REC_LOCK] = &lockpicks;
recLists[REC_LTEX] = &landTexts; recLists[REC_LTEX] = &landTexts;
//recLists[REC_MGEF] = &magicEffects;
recLists[REC_MISC] = &miscItems; recLists[REC_MISC] = &miscItems;
recLists[REC_NPC_] = &npcs; recLists[REC_NPC_] = &npcs;
recLists[REC_NPCC] = &npcChange; recLists[REC_NPCC] = &npcChange;

252
components/nifogre/ogre_nif_loader.cpp
View file

@ -21,11 +21,14 @@
*/ */
//loadResource->handleNode->handleNiTriShape->createSubMesh
#include "ogre_nif_loader.hpp" #include "ogre_nif_loader.hpp"
#include <Ogre.h> #include <Ogre.h>
#include <stdio.h> #include <stdio.h>
#include <libs/mangle/vfs/servers/ogre_vfs.hpp> #include <libs/mangle/vfs/servers/ogre_vfs.hpp>
#include "../../apps/openmw/mwclass/npc.hpp"
#include "../nif/nif_file.hpp" #include "../nif/nif_file.hpp"
#include "../nif/node.hpp" #include "../nif/node.hpp"
#include "../nif/data.hpp" #include "../nif/data.hpp"
@ -52,7 +55,6 @@ using namespace Mangle::VFS;
NIFLoader& NIFLoader::getSingleton() NIFLoader& NIFLoader::getSingleton()
{ {
static NIFLoader instance; static NIFLoader instance;
return instance; return instance;
} }
@ -325,10 +327,13 @@ void NIFLoader::findRealTexture(String &texName)
texName[len-1] = 's'; texName[len-1] = 's';
} }
//Handle node at top
// Convert Nif::NiTriShape to Ogre::SubMesh, attached to the given // Convert Nif::NiTriShape to Ogre::SubMesh, attached to the given
// mesh. // mesh.
void NIFLoader::createOgreSubMesh(NiTriShape *shape, const String &material, std::list<VertexBoneAssignment> &vertexBoneAssignments) void NIFLoader::createOgreSubMesh(NiTriShape *shape, const String &material, std::list<VertexBoneAssignment> &vertexBoneAssignments)
{ {
// cout << "s:" << shape << "\n";
NiTriShapeData *data = shape->data.getPtr(); NiTriShapeData *data = shape->data.getPtr();
SubMesh *sub = mesh->createSubMesh(shape->name.toString()); SubMesh *sub = mesh->createSubMesh(shape->name.toString());
@ -421,7 +426,7 @@ void NIFLoader::createOgreSubMesh(NiTriShape *shape, const String &material, std
for (std::list<VertexBoneAssignment>::iterator it = vertexBoneAssignments.begin(); for (std::list<VertexBoneAssignment>::iterator it = vertexBoneAssignments.begin();
it != vertexBoneAssignments.end(); it++) it != vertexBoneAssignments.end(); it++)
{ {
sub->addBoneAssignment(*it); sub->addBoneAssignment(*it);
} }
} }
@ -468,8 +473,11 @@ static void vectorMul(const Matrix &A, float *C)
C[i] = a*A.v[i].array[0] + b*A.v[i].array[1] + c*A.v[i].array[2]; C[i] = a*A.v[i].array[0] + b*A.v[i].array[1] + c*A.v[i].array[2];
} }
void NIFLoader::handleNiTriShape(NiTriShape *shape, int flags, BoundsFinder &bounds) void NIFLoader::handleNiTriShape(NiTriShape *shape, int flags, BoundsFinder &bounds)
{ {
//if( MWClass::Npc.isChest)
//cout << "t:" << shape << "\n";
assert(shape != NULL); assert(shape != NULL);
// Interpret flags // Interpret flags
@ -719,6 +727,9 @@ void NIFLoader::handleNiTriShape(NiTriShape *shape, int flags, BoundsFinder &bou
void NIFLoader::handleNode(Nif::Node *node, int flags, void NIFLoader::handleNode(Nif::Node *node, int flags,
const Transformation *trafo, BoundsFinder &bounds, Bone *parentBone) const Transformation *trafo, BoundsFinder &bounds, Bone *parentBone)
{ {
stack++;
//if( MWClass::isChest)
// cout << "u:" << node << "\n";
// Accumulate the flags from all the child nodes. This works for all // Accumulate the flags from all the child nodes. This works for all
// the flags we currently use, at least. // the flags we currently use, at least.
flags |= node->flags; flags |= node->flags;
@ -768,6 +779,8 @@ void NIFLoader::handleNode(Nif::Node *node, int flags,
if (!skel.isNull()) //if there is a skeleton if (!skel.isNull()) //if there is a skeleton
{ {
std::string name = node->name.toString(); std::string name = node->name.toString();
//if (isBeast && isChest)
// std::cout << "NAME: " << name << "\n";
// Quick-n-dirty workaround for the fact that several // Quick-n-dirty workaround for the fact that several
// bones may have the same name. // bones may have the same name.
if(!skel->hasBone(name)) if(!skel->hasBone(name))
@ -810,20 +823,199 @@ void NIFLoader::handleNode(Nif::Node *node, int flags,
{ {
NodeList &list = ((NiNode*)node)->children; NodeList &list = ((NiNode*)node)->children;
int n = list.length(); int n = list.length();
for (int i=0; i<n; i++) int i = 0;
if(isHands){
//cout << "NumberOfNs: " << n << "Stack:" << stack << "\n";
//if(stack == 3)
//n=0;
}
for (; i<n; i++)
{ {
if (list.has(i)) if (list.has(i))
handleNode(&list[i], flags, node->trafo, bounds, bone); handleNode(&list[i], flags, node->trafo, bounds, bone);
} }
} }
else if (node->recType == RC_NiTriShape) else if (node->recType == RC_NiTriShape)
{
// For shapes // For shapes
handleNiTriShape(dynamic_cast<NiTriShape*>(node), flags, bounds); /*For Beast Skins, Shape Bone Names
Tri Left Foot
Tri Right Foot
Tri Tail
Tri Chest
*/
if((isChest && stack < 10 ) || (isHands && counter < 3) || !(isChest || isHands)){ //(isBeast && isChest && stack < 10 && counter == skincounter )
std::string name = node->name.toString();
//if (isChest)
//std::cout << "NAME: " << name << "\n";
if(isChest && isBeast && skincounter == 0 && name.compare("Tri Chest") == 0){
//std::cout <<"BEASTCHEST1\n";
handleNiTriShape(dynamic_cast<NiTriShape*>(node), flags, bounds);
skincounter++;
}
else if(isChest && isBeast && skincounter == 1 && name.compare("Tri Tail") == 0){
//std::cout <<"BEASTCHEST2\n";
handleNiTriShape(dynamic_cast<NiTriShape*>(node), flags, bounds);
skincounter++;
}
else if(isChest && isBeast && skincounter == 2 && name.compare("Tri Left Foot") == 0){
//std::cout <<"BEASTCHEST3\n";
handleNiTriShape(dynamic_cast<NiTriShape*>(node), flags, bounds);
skincounter=1000;
}
else if (!isChest || !isBeast)
{
handleNiTriShape(dynamic_cast<NiTriShape*>(node), flags, bounds);
}
//if(isBeast && isChest)
//cout << "Handling Shape, Stack " << stack <<"\n";
counter++;
}
/*if(isHands){
//cout << "Handling Shape, Stack " << stack <<"\n";
counter++;
}*/
}
stack--;
} }
void NIFLoader::loadResource(Resource *resource) void NIFLoader::loadResource(Resource *resource)
{ {
if(skincounter == 1000)
skincounter = 0;
stack = 0;
counter = 0;
std::string name = resource->getName();
if(resourceName.compare(name) != 0)
{
skincounter = 0;
resourceName = name;
}
//std::cout <<"NAME:" << name;
//if(name.length() >= 20)
// {std::string split = name.substr(name.length() - 20, 20);
//if(name ==
//std::cout <<"NAME:" << name << "LEN: " << name.length() << "\n";
const std::string test ="meshes\\b\\B_N_Dark Elf_M_Skins.NIF";
const std::string test2 ="meshes\\b\\B_N_Dark Elf_M_Skins.nif";
const std::string test3 ="meshes\\b\\B_N_Redguard_F_Skins.NIF";
const std::string test4 ="meshes\\b\\B_N_Redguard_F_Skins.nif";
const std::string test5 ="meshes\\b\\B_N_Dark Elf_F_Skins.nif";
const std::string test6 ="meshes\\b\\B_N_Redguard_M_Skins.nif";
const std::string test7 ="meshes\\b\\B_N_Wood Elf_F_Skins.nif";
const std::string test8 ="meshes\\b\\B_N_Wood Elf_M_Skins.nif";
const std::string test9 ="meshes\\b\\B_N_Imperial_F_Skins.nif";
const std::string test10 ="meshes\\b\\B_N_Imperial_M_Skins.nif";
const std::string test11 ="meshes\\b\\B_N_Khajiit_F_Skins.nif";
const std::string test12 ="meshes\\b\\B_N_Khajiit_M_Skins.nif";
const std::string test13 ="meshes\\b\\B_N_Argonian_F_Skins.nif";
const std::string test14 ="meshes\\b\\B_N_Argonian_M_Skins.nif";
const std::string test15 ="meshes\\b\\B_N_Nord_F_Skins.nif";
const std::string test16 ="meshes\\b\\B_N_Nord_M_Skins.nif";
const std::string test17 ="meshes\\b\\B_N_Imperial_F_Skins.nif";
const std::string test18 ="meshes\\b\\B_N_Imperial_M_Skins.nif";
const std::string test19 ="meshes\\b\\B_N_Orc_F_Skins.nif";
const std::string test20 ="meshes\\b\\B_N_Orc_M_Skins.nif";
const std::string test21 ="meshes\\b\\B_N_Breton_F_Skins.nif";
const std::string test22 ="meshes\\b\\B_N_Breton_M_Skins.nif";
const std::string test23 ="meshes\\b\\B_N_High Elf_F_Skins.nif";
const std::string test24 ="meshes\\b\\B_N_High Elf_M_Skins.nif";
//std::cout <<"LEN1:" << test.length() << "TEST: " << test << "\n";
if(name.compare(test) == 0 || name.compare(test2) == 0 || name.compare(test3) == 0 || name.compare(test4) == 0 ||
name.compare(test5) == 0 || name.compare(test6) == 0 || name.compare(test7) == 0 || name.compare(test8) == 0 || name.compare(test9) == 0 ||
name.compare(test10) == 0 || name.compare(test11) == 0 || name.compare(test12) == 0 || name.compare(test13) == 0 ||
name.compare(test14) == 0 || name.compare(test15) == 0 || name.compare(test16) == 0 || name.compare(test17) == 0 ||
name.compare(test18) == 0 || name.compare(test19) == 0 || name.compare(test20) == 0 || name.compare(test21) == 0 ||
name.compare(test22) == 0 || name.compare(test23) == 0 || name.compare(test24) == 0
){
//std::cout << "Welcome Chest\n";
isChest = true;
if(name.compare(test11) == 0 || name.compare(test12) == 0 || name.compare(test13) == 0 || name.compare(test14) == 0)
{
isBeast = true;
//std::cout << "Welcome Beast\n";
}
else
isBeast = false;
}
else
isChest = false;
const std::string hands ="meshes\\b\\B_N_Dark Elf_M_Hands.1st.NIF";
const std::string hands2 ="meshes\\b\\B_N_Dark Elf_F_Hands.1st.NIF";
const std::string hands3 ="meshes\\b\\B_N_Redguard_M_Hands.1st.nif";
const std::string hands4 ="meshes\\b\\B_N_Redguard_F_Hands.1st.nif";
const std::string hands5 ="meshes\\b\\b_n_argonian_m_hands.1st.nif";
const std::string hands6 ="meshes\\b\\b_n_argonian_f_hands.1st.nif";
const std::string hands7 ="meshes\\b\\B_N_Breton_M_Hand.1st.NIF";
const std::string hands8 ="meshes\\b\\B_N_Breton_F_Hands.1st.nif";
const std::string hands9 ="meshes\\b\\B_N_High Elf_M_Hands.1st.nif";
const std::string hands10 ="meshes\\b\\B_N_High Elf_F_Hands.1st.nif";
const std::string hands11 ="meshes\\b\\B_N_Nord_M_Hands.1st.nif";
const std::string hands12 ="meshes\\b\\B_N_Nord_F_Hands.1st.nif";
const std::string hands13 ="meshes\\b\\b_n_khajiit_m_hands.1st.nif";
const std::string hands14 ="meshes\\b\\b_n_khajiit_f_hands.1st.nif";
const std::string hands15 ="meshes\\b\\B_N_Orc_M_Hands.1st.nif";
const std::string hands16 ="meshes\\b\\B_N_Orc_F_Hands.1st.nif";
const std::string hands17 ="meshes\\b\\B_N_Wood Elf_M_Hands.1st.nif";
const std::string hands18 ="meshes\\b\\B_N_Wood Elf_F_Hands.1st.nif";
const std::string hands19 ="meshes\\b\\B_N_Imperial_M_Hands.1st.nif";
const std::string hands20 ="meshes\\b\\B_N_Imperial_F_Hands.1st.nif";
if(name.compare(hands) == 0 || name.compare(hands2) == 0 || name.compare(hands3) == 0 || name.compare(hands4) == 0 ||
name.compare(hands5) == 0 || name.compare(hands6) == 0 || name.compare(hands7) == 0 || name.compare(hands8) == 0 ||
name.compare(hands9) == 0 || name.compare(hands10) == 0 || name.compare(hands11) == 0 || name.compare(hands12) == 0 ||
name.compare(hands13) == 0 || name.compare(hands14) == 0 || name.compare(hands15) == 0 || name.compare(hands16) == 0 ||
name.compare(hands17) == 0 || name.compare(hands18) == 0 || name.compare(hands19) == 0 || name.compare(hands20) == 0)
{
//std::cout << "Welcome Hands1st\n";
isHands = true;
isChest = false;
}
else
isHands = false;
/*
else if(name.compare(test3) == 0 || name.compare(test4) == 0)
{
std::cout << "\n\n\nWelcome FRedguard Chest\n\n\n";
isChest = true;
}
else if(name.compare(test5) == 0 || name.compare(test6) == 0)
{
std::cout << "\n\n\nWelcome FRedguard Chest\n\n\n";
isChest = true;
}
else if(name.compare(test7) == 0 || name.compare(test8) == 0)
{
std::cout << "\n\n\nWelcome FRedguard Chest\n\n\n";
isChest = true;
}
else if(name.compare(test9) == 0 || name.compare(test10) == 0)
{
std::cout << "\n\n\nWelcome FRedguard Chest\n\n\n";
isChest = true;
}*/
//if(split== "Skins.NIF")
// std::cout << "\nSPECIAL PROPS\n";
resourceName = ""; resourceName = "";
MeshManager *m = MeshManager::getSingletonPtr();
// Check if the resource already exists
//MeshPtr ptr = m->load(name, "custom");
//cout << "THISNAME: " << ptr->getName() << "\n";
//cout << "RESOURCE:"<< resource->getName();
mesh = 0; mesh = 0;
skel.setNull(); skel.setNull();
@ -836,6 +1028,7 @@ void NIFLoader::loadResource(Resource *resource)
// Look it up // Look it up
resourceName = mesh->getName(); resourceName = mesh->getName();
//std::cout << resourceName << "\n";
if (!vfs->isFile(resourceName)) if (!vfs->isFile(resourceName))
{ {
@ -888,19 +1081,58 @@ void NIFLoader::loadResource(Resource *resource)
} }
MeshPtr NIFLoader::load(const std::string &name, MeshPtr NIFLoader::load(const std::string &name,
const std::string &group) const std::string &group)
{ {
MeshManager *m = MeshManager::getSingletonPtr(); MeshManager *m = MeshManager::getSingletonPtr();
// Check if the resource already exists // Check if the resource already exists
ResourcePtr ptr = m->getByName(name, group); ResourcePtr ptr = m->getByName(name, group);
if (!ptr.isNull()) MeshPtr resize;
return MeshPtr(ptr);
// Nope, create a new one. const std::string beast1 ="meshes\\b\\B_N_Khajiit_F_Skins.nif";
return MeshManager::getSingleton().createManual(name, group, NIFLoader::getSingletonPtr()); const std::string beast2 ="meshes\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beast3 ="meshes\\b\\B_N_Argonian_F_Skins.nif";
const std::string beast4 ="meshes\\b\\B_N_Argonian_M_Skins.nif";
const std::string beasttail1 ="tail\\b\\B_N_Khajiit_F_Skins.nif";
const std::string beasttail2 ="tail\\b\\B_N_Khajiit_M_Skins.nif";
const std::string beasttail3 ="tail\\b\\B_N_Argonian_F_Skins.nif";
const std::string beasttail4 ="tail\\b\\B_N_Argonian_M_Skins.nif";
if (!ptr.isNull()){
//if(pieces > 1)
//cout << "It exists\n";
resize = MeshPtr(ptr);
//resize->load();
//resize->reload();
}
else // Nope, create a new one.
{
resize = MeshManager::getSingleton().createManual(name, group, NIFLoader::getSingletonPtr());
//cout <<"EXISTING" << name << "\n";
//if(pieces > 1)
//cout << "Creating it\n";
//resize->load();
//resize->reload();
//return 0;
ResourcePtr ptr = m->getByName(name, group);
resize = MeshPtr(ptr);
//NIFLoader::getSingletonPtr()->
/*ResourcePtr ptr = m->getByName(name, group);
if (!ptr.isNull()){
if(pieces > 1)
cout << "It exists\n";
resize = MeshPtr(ptr);*/
//return resize;
}
return resize;
} }
/* More code currently not in use, from the old D source. This was /* More code currently not in use, from the old D source. This was
used in the first attempt at loading NIF meshes, where each submesh used in the first attempt at loading NIF meshes, where each submesh
in the file was given a separate bone in a skeleton. Unfortunately in the file was given a separate bone in a skeleton. Unfortunately

18
components/nifogre/ogre_nif_loader.hpp
View file

@ -67,19 +67,22 @@ namespace Mangle
class NIFLoader : Ogre::ManualResourceLoader class NIFLoader : Ogre::ManualResourceLoader
{ {
public: public:
static int numberOfMeshes;
static NIFLoader& getSingleton(); static NIFLoader& getSingleton();
static NIFLoader* getSingletonPtr(); static NIFLoader* getSingletonPtr();
virtual void loadResource(Ogre::Resource *resource); virtual void loadResource(Ogre::Resource *resource);
static Ogre::MeshPtr load(const std::string &name, static Ogre::MeshPtr load(const std::string &name,
const std::string &group="General"); const std::string &group="General");
Ogre::Vector3 convertVector3(const Nif::Vector& vec); Ogre::Vector3 convertVector3(const Nif::Vector& vec);
Ogre::Quaternion convertRotation(const Nif::Matrix& rot); Ogre::Quaternion convertRotation(const Nif::Matrix& rot);
private: private:
NIFLoader() : resourceGroup("General") {} NIFLoader() : resourceGroup("General") { skincounter = 0; resourceName = "";}
NIFLoader(NIFLoader& n) {} NIFLoader(NIFLoader& n) {}
void warn(std::string msg); void warn(std::string msg);
@ -120,6 +123,15 @@ class NIFLoader : Ogre::ManualResourceLoader
std::string resourceName; std::string resourceName;
std::string resourceGroup; std::string resourceGroup;
int skincounter;
bool isChest;
bool isBeast;
bool isHands;
bool isFeet;
int counter;
int numbers;
int stack;
// pointer to the ogre mesh which is currently build // pointer to the ogre mesh which is currently build
Ogre::Mesh *mesh; Ogre::Mesh *mesh;

256
components/nifogre/oldnpccode.txt Normal file
View file

@ -0,0 +1,256 @@
/* //This is old
if (pieces > 1){ //pieces > 1
MeshPtr justChest = MeshManager::getSingleton().createManual("justchest", group, NIFLoader::getSingletonPtr());
Ogre::AxisAlignedBox bounds = resize->getBounds();
Ogre::Vector3 width2 = bounds.getCorner(bounds.NEAR_RIGHT_BOTTOM) - bounds.getCorner(bounds.NEAR_LEFT_BOTTOM);
Ogre::Vector3 depth2 = (bounds.getCorner(bounds.FAR_LEFT_BOTTOM) - bounds.getCorner(bounds.NEAR_LEFT_BOTTOM));
Ogre::Vector3 height2 = bounds.getCorner(bounds.NEAR_LEFT_TOP) - bounds.getCorner(bounds.NEAR_LEFT_BOTTOM);
cout << "Width:" << width2; cout << "Height:" << height2; cout << "Depth:" << depth2;
/*int width = bounds.getMaximum().x - bounds.getMinimum().x;
int height = bounds.getMaximum().y - bounds.getMinimum().y;
int depth = bounds.getMaximum().z - bounds.getMinimum().z;
int xinc = width / pieces;
int yinc = height / pieces;
int zinc = depth / pieces;
int xmincorner = bounds.getMinimum().x + xinc*pieceIndex;
int ymincorner = bounds.getMinimum().y + yinc*pieceIndex;
int zmincorner = bounds.getMinimum().z + xinc*pieceIndex;*/
//Ogre::Vector3 bottom_left = bounds.getCorner(bounds.NEAR_LEFT_BOTTOM) + (width2 / pieces) * pieceIndex; //width2
//Ogre::Vector3 top_right = bottom_left + (width2 / pieces) + height2 + depth2;
//Ogre::AxisAlignedBox set = AxisAlignedBox ( Ogre::Vector3(xmincorner, bounds.getMinimum().y, bounds.getMinimum().z), Ogre::Vector3(xmincorner + xinc, bounds.getMaximum().y, bounds.getMaximum().z));
//Ogre::AxisAlignedBox set = bounds;//AxisAlignedBox(bottom_left, top_right);
//bounds.setMinimumX(xmincorner);
//bounds.setMaximumX(xmincorner + xinc);
//bounds.setMinimumY(ymincorner);
//bounds.setMaximumY(ymincorner + yinc);
//bounds.setMinimumZ(zmincorner);
//bounds.setMaximumZ(zmincorner + zinc);
//bounds.setMinimumY(bounds.getMinimum().y);
//bounds.setMaximumY( bounds.getMaximum().y;
//resize->_setBounds(set, true);
//resize->reload();
//Ogre::Mesh::SubMeshIterator subMeshIterator = resize->getSubMeshIterator();
/*Ogre::Vector3* point;
Ogre::SubMesh* subMesh;
size_t vertex_count = 0;
Vector3* vertices;
size_t index_count = 0;
unsigned* indices;
Vector3 position = Vector3::ZERO;
Quaternion orient = Quaternion::IDENTITY;
Vector3 scale = Vector3::UNIT_SCALE;
// int vertex_count = 0;
//int index_count = 0;
bool added_shared = false;
size_t current_offset = vertex_count;
size_t shared_offset = vertex_count;
size_t next_offset = vertex_count;
size_t index_offset = index_count;
size_t prev_vert = vertex_count;
size_t prev_ind = index_count;
// Calculate how many vertices and indices we're going to need
/*
std::cout <<"FIRST CYCLE\n";
for(int i = 0;i < resize->getNumSubMeshes();i++)
{
std::cout<< "WEHAVEMESHES\n";
SubMesh* submesh = resize->getSubMesh(i);
// We only need to add the shared vertices once
if(submesh->useSharedVertices)
{
if(!added_shared)
{
VertexData* vertex_data = resize->sharedVertexData;
vertex_count += vertex_data->vertexCount;
added_shared = true;
}
}
else
{
VertexData* vertex_data = submesh->vertexData;
vertex_count += vertex_data->vertexCount;
}
// Add the indices
Ogre::IndexData* index_data = submesh->indexData;
index_count += index_data->indexCount;
}
*/
// Vector3* vertices;
// Allocate space for the vertices and indices
/*vertices = new Vector3[vertex_count];
indices = new unsigned[index_count];
int meshcounter = 0;
added_shared = false;
std::cout <<"SECOND CYCLE: " << resize->getNumSubMeshes() << "\n";
// Run through the submeshes again, adding the data into the arrays
int i;
for(i = 0;i < resize->getNumSubMeshes();i++)
{
SubMesh* submesh = resize->getSubMesh(i);
Ogre::VertexData* vertex_data = submesh->useSharedVertices ? resize->sharedVertexData : submesh->vertexData;
/*
if((!submesh->useSharedVertices)||(submesh->useSharedVertices && !added_shared))
{
if(submesh->useSharedVertices)
{
added_shared = true;
shared_offset = current_offset;
}
const Ogre::VertexElement* posElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_NORMAL));
Ogre::Real* pReal;
bool onepointexists = true;
Vector3 lastpoint;
for(size_t j = 0; j < vertex_data->vertexCount; ++j, vertex += vbuf->getVertexSize())
{
posElem->baseVertexPointerToElement(vertex, &pReal);
Vector3 pt;
pt.x = (*(pReal++));
pt.y = (*(pReal++));
pt.z = (*(pReal++));
//cout << "X:" << pt.x << "Y:" <<pt.y << "Z:" <<pt.z << "\n";
//cout << "Boxmin:" << set.getMinimum() <<" Boxmax:" <<set.getMaximum() <<"\n";
//if(set.intersects(pt))
//onepointexists = true;
if(!set.intersects(pt))
{
pt = lastpoint;
//*pReal = pt.x;
//*(pReal+1) = pt.y;
//*(pReal+2) = pt.z;
//vertex
}
else
lastpoint = pt;
pt = (orient * (pt * scale)) + position;
if(!set.intersects(pt))
onepointexists = false;
vertices[current_offset + j].x = pt.x;
vertices[current_offset + j].y = pt.y;
vertices[current_offset + j].z = pt.z;
}
/*if(true)
{
std::cout<< "Wearegoingtodelete"<< submesh->getMaterialName() << "\n";
if(meshcounter <= 2)
resize->destroySubMesh(i);
else if(meshcounter > 3 && meshcounter < 7)
resize->destroySubMesh(i);
//submesh->setMaterialName("BaseWhiteNoLighting"); //red
//submesh->updateMaterialUsingTextureAliases();
//resize->
meshcounter++;
//delete submesh;
//reakb;
}*/
/*
vbuf->unlock();
next_offset += vertex_data->vertexCount;
}
Ogre::IndexData* index_data = submesh->indexData;
size_t numTris = index_data->indexCount / 3;
unsigned short* pShort;
unsigned int* pInt;
Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
if (use32bitindexes) pInt = static_cast<unsigned int*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
else pShort = static_cast<unsigned short*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
for(size_t k = 0; k < numTris; ++k)
{
size_t offset = (submesh->useSharedVertices)?shared_offset:current_offset;
unsigned int vindex = use32bitindexes? *pInt++ : *pShort++;
indices[index_offset + 0] = vindex + offset;
vindex = use32bitindexes? *pInt++ : *pShort++;
indices[index_offset + 1] = vindex + offset;
vindex = use32bitindexes? *pInt++ : *pShort++;
indices[index_offset + 2] = vindex + offset;
index_offset += 3;
}
ibuf->unlock();
current_offset = next_offset;*/
//if (i == 3) //i!=3 i!=5
//{
//cout << "RETURNINGJUST\n";
//SubMesh* test =
//test = resize->getSubMesh(i);
// cout << "s:" << shape << "\n";
//NiTriShapeData *data = shape->data.getPtr();
// SubMesh *sub = justChest->createSubMesh(name + "2");
//sub = resize->getSubMesh(i);
// int nextBuf = 0;
// This function is just one long stream of Ogre-barf, but it works
// great.
// Add vertices
//int numVerts = data->vertices.length / 3;
//sub->vertexData = new VertexData();
//sub->vertexData->vertexCount = numVerts;
//justChest->load();
//return resize;
//}
// 0 hand thumb
// 1 hand thumb no chest on dunmer
//}
//resize->destroySubMesh(1);
/* while (subMeshIterator.hasMoreElements())
{
resize->getNum
//resize->d
std::cout << "CHEST";
subMesh = subMeshIterator.getNext();*/
//std::vector<Vector3>::type test =
//std::vector<Ogre::Vector3>::iterator fileIter = subMesh->extremityPoints.begin();
//std::vector<Ogre::Vector3>::type test = subMesh->extremityPoints;
//void* pData = subMesh->vertexData->vertexBufferBinding->getBuffer(1)->lock(0, 1000, HardwareBuffer::HBL_DISCARD);
// if(set.contains( subMesh->vertexData->vertexStart))
//delete subMesh;
//subMeshIterator.getNext();
//delete[] subMesh;
//subMesh->extremityPoints.clear();
//subMesh->mLodFaceList.clear();
//resize->destroySubMesh(subMesh->indexData->indexStart);
//resize->destroySubMesh(subMesh->indexData->);
//subMesh->
//std::cout << "THIS" << subMesh;
///}
//subMesh->vertexData->vertexBufferBinding->getBuffer(0)->readData(subMesh->vertexData->vertexStart, sizeof Ogre::Vector3, point);
//boost::filesystem::directory_iterator dir_iter(dir), dir_end;
//return resize;