krageon/openmw-tes3coop
1
0
Fork 0
forked from teamnwah/openmw-tes3coop
Code Issues Pull requests 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.

211
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;
MWRender::Rendering rendering (cellRender, ref->ref); std::string hairModel = "meshes\\" +
environment.mWorld->getStore().bodyParts.find(hairID)->model;
cellRender.insertMesh (headModel); MWRender::Rendering rendering (cellRender, ref->ref);
//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);
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();
ref->mData.setHandle (rendering.end (ref->mData.isEnabled())); 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
{ {

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

@ -5,10 +5,12 @@
namespace MWClass namespace MWClass
{ {
static bool isChest;
//static ;bool isChest = false;
class Npc : public MWWorld::Class class Npc : public MWWorld::Class
{ {
public: public:
virtual std::string getId (const MWWorld::Ptr& ptr) const; virtual std::string getId (const MWWorld::Ptr& ptr) const;
///< Return ID of \a ptr ///< Return ID of \a ptr

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);
@ -78,6 +85,7 @@ namespace MWRender
void configureFog(); void configureFog();
void setAmbientMode(); void setAmbientMode();
public: public:

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,7 +9,12 @@
#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
{ {
using namespace ESM; using namespace ESM;
@ -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;

254
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))
{ {
@ -887,19 +1080,58 @@ void NIFLoader::loadResource(Resource *resource)
// mesh->setSkeletonName(getSkeletonName()); // mesh->setSkeletonName(getSkeletonName());
} }
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);
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";
// Nope, create a new one. const std::string beasttail1 ="tail\\b\\B_N_Khajiit_F_Skins.nif";
return MeshManager::getSingleton().createManual(name, group, NIFLoader::getSingletonPtr()); 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

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;