Merge remote-tracking branch 'upstream/master' into launcher
Conflicts: apps/launcher/CMakeLists.txt apps/launcher/datafilespage.cppactorid
Pieter van der Kloet
13 years ago
commit
2429f3960f
@ -1,5 +0,0 @@
|
||||
esmtool_cmd.c: esmtool.ggo
|
||||
gengetopt < esmtool.ggo
|
||||
|
||||
clean:
|
||||
rm esmtool_cmd.c esmtool_cmd.h
|
||||
@ -1,10 +0,0 @@
|
||||
package "esmtool"
|
||||
version "1.0"
|
||||
purpose "Inspect and extract from Morrowind ES files (ESM, ESP, ESS)"
|
||||
args "--unamed-opts=ES-FILE -F esmtool_cmd -G"
|
||||
|
||||
option "raw" r "Show an unformattet list of all records and subrecords" optional
|
||||
option "quiet" q "Supress all record information. Useful for speed tests." optional
|
||||
option "loadcells" C "Browse through contents of all cells." optional
|
||||
|
||||
text "\nIf no option is given, the default action is to parse all records in the archive and display diagnostic information."
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,179 +0,0 @@
|
||||
/** @file esmtool_cmd.h
|
||||
* @brief The header file for the command line option parser
|
||||
* generated by GNU Gengetopt version 2.22.2
|
||||
* http://www.gnu.org/software/gengetopt.
|
||||
* DO NOT modify this file, since it can be overwritten
|
||||
* @author GNU Gengetopt by Lorenzo Bettini */
|
||||
|
||||
#ifndef ESMTOOL_CMD_H
|
||||
#define ESMTOOL_CMD_H
|
||||
|
||||
/* If we use autoconf. */
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <stdio.h> /* for FILE */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifndef CMDLINE_PARSER_PACKAGE
|
||||
/** @brief the program name (used for printing errors) */
|
||||
#define CMDLINE_PARSER_PACKAGE "esmtool"
|
||||
#endif
|
||||
|
||||
#ifndef CMDLINE_PARSER_PACKAGE_NAME
|
||||
/** @brief the complete program name (used for help and version) */
|
||||
#define CMDLINE_PARSER_PACKAGE_NAME "esmtool"
|
||||
#endif
|
||||
|
||||
#ifndef CMDLINE_PARSER_VERSION
|
||||
/** @brief the program version */
|
||||
#define CMDLINE_PARSER_VERSION "1.0"
|
||||
#endif
|
||||
|
||||
/** @brief Where the command line options are stored */
|
||||
struct gengetopt_args_info
|
||||
{
|
||||
const char *help_help; /**< @brief Print help and exit help description. */
|
||||
const char *version_help; /**< @brief Print version and exit help description. */
|
||||
const char *raw_help; /**< @brief Show an unformattet list of all records and subrecords help description. */
|
||||
const char *quiet_help; /**< @brief Supress all record information. Useful for speed tests. help description. */
|
||||
const char *loadcells_help; /**< @brief Browse through contents of all cells. help description. */
|
||||
|
||||
unsigned int help_given ; /**< @brief Whether help was given. */
|
||||
unsigned int version_given ; /**< @brief Whether version was given. */
|
||||
unsigned int raw_given ; /**< @brief Whether raw was given. */
|
||||
unsigned int quiet_given ; /**< @brief Whether quiet was given. */
|
||||
unsigned int loadcells_given ; /**< @brief Whether loadcells was given. */
|
||||
|
||||
char **inputs ; /**< @brief unamed options (options without names) */
|
||||
unsigned inputs_num ; /**< @brief unamed options number */
|
||||
} ;
|
||||
|
||||
/** @brief The additional parameters to pass to parser functions */
|
||||
struct cmdline_parser_params
|
||||
{
|
||||
int override; /**< @brief whether to override possibly already present options (default 0) */
|
||||
int initialize; /**< @brief whether to initialize the option structure gengetopt_args_info (default 1) */
|
||||
int check_required; /**< @brief whether to check that all required options were provided (default 1) */
|
||||
int check_ambiguity; /**< @brief whether to check for options already specified in the option structure gengetopt_args_info (default 0) */
|
||||
int print_errors; /**< @brief whether getopt_long should print an error message for a bad option (default 1) */
|
||||
} ;
|
||||
|
||||
/** @brief the purpose string of the program */
|
||||
extern const char *gengetopt_args_info_purpose;
|
||||
/** @brief the usage string of the program */
|
||||
extern const char *gengetopt_args_info_usage;
|
||||
/** @brief all the lines making the help output */
|
||||
extern const char *gengetopt_args_info_help[];
|
||||
|
||||
/**
|
||||
* The command line parser
|
||||
* @param argc the number of command line options
|
||||
* @param argv the command line options
|
||||
* @param args_info the structure where option information will be stored
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
*/
|
||||
int cmdline_parser (int argc, char * const *argv,
|
||||
struct gengetopt_args_info *args_info);
|
||||
|
||||
/**
|
||||
* The command line parser (version with additional parameters - deprecated)
|
||||
* @param argc the number of command line options
|
||||
* @param argv the command line options
|
||||
* @param args_info the structure where option information will be stored
|
||||
* @param override whether to override possibly already present options
|
||||
* @param initialize whether to initialize the option structure my_args_info
|
||||
* @param check_required whether to check that all required options were provided
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
* @deprecated use cmdline_parser_ext() instead
|
||||
*/
|
||||
int cmdline_parser2 (int argc, char * const *argv,
|
||||
struct gengetopt_args_info *args_info,
|
||||
int override, int initialize, int check_required);
|
||||
|
||||
/**
|
||||
* The command line parser (version with additional parameters)
|
||||
* @param argc the number of command line options
|
||||
* @param argv the command line options
|
||||
* @param args_info the structure where option information will be stored
|
||||
* @param params additional parameters for the parser
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
*/
|
||||
int cmdline_parser_ext (int argc, char * const *argv,
|
||||
struct gengetopt_args_info *args_info,
|
||||
struct cmdline_parser_params *params);
|
||||
|
||||
/**
|
||||
* Save the contents of the option struct into an already open FILE stream.
|
||||
* @param outfile the stream where to dump options
|
||||
* @param args_info the option struct to dump
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
*/
|
||||
int cmdline_parser_dump(FILE *outfile,
|
||||
struct gengetopt_args_info *args_info);
|
||||
|
||||
/**
|
||||
* Save the contents of the option struct into a (text) file.
|
||||
* This file can be read by the config file parser (if generated by gengetopt)
|
||||
* @param filename the file where to save
|
||||
* @param args_info the option struct to save
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
*/
|
||||
int cmdline_parser_file_save(const char *filename,
|
||||
struct gengetopt_args_info *args_info);
|
||||
|
||||
/**
|
||||
* Print the help
|
||||
*/
|
||||
void cmdline_parser_print_help(void);
|
||||
/**
|
||||
* Print the version
|
||||
*/
|
||||
void cmdline_parser_print_version(void);
|
||||
|
||||
/**
|
||||
* Initializes all the fields a cmdline_parser_params structure
|
||||
* to their default values
|
||||
* @param params the structure to initialize
|
||||
*/
|
||||
void cmdline_parser_params_init(struct cmdline_parser_params *params);
|
||||
|
||||
/**
|
||||
* Allocates dynamically a cmdline_parser_params structure and initializes
|
||||
* all its fields to their default values
|
||||
* @return the created and initialized cmdline_parser_params structure
|
||||
*/
|
||||
struct cmdline_parser_params *cmdline_parser_params_create(void);
|
||||
|
||||
/**
|
||||
* Initializes the passed gengetopt_args_info structure's fields
|
||||
* (also set default values for options that have a default)
|
||||
* @param args_info the structure to initialize
|
||||
*/
|
||||
void cmdline_parser_init (struct gengetopt_args_info *args_info);
|
||||
/**
|
||||
* Deallocates the string fields of the gengetopt_args_info structure
|
||||
* (but does not deallocate the structure itself)
|
||||
* @param args_info the structure to deallocate
|
||||
*/
|
||||
void cmdline_parser_free (struct gengetopt_args_info *args_info);
|
||||
|
||||
/**
|
||||
* Checks that all the required options were specified
|
||||
* @param args_info the structure to check
|
||||
* @param prog_name the name of the program that will be used to print
|
||||
* possible errors
|
||||
* @return
|
||||
*/
|
||||
int cmdline_parser_required (struct gengetopt_args_info *args_info,
|
||||
const char *prog_name);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* ESMTOOL_CMD_H */
|
||||
@ -1,28 +0,0 @@
|
||||
#ifndef GAME_MWCLASS_CONTAINERUTIL_H
|
||||
#define GAME_MWCLASS_CONTAINERUTIL_H
|
||||
|
||||
#include <components/esm_store/cell_store.hpp>
|
||||
|
||||
#include "../mwworld/ptr.hpp"
|
||||
#include "../mwworld/containerstore.hpp"
|
||||
|
||||
namespace MWClass
|
||||
{
|
||||
template<typename T>
|
||||
void insertIntoContainerStore (const MWWorld::Ptr& ptr,
|
||||
ESMS::CellRefList<T, MWWorld::RefData>& containerStore)
|
||||
{
|
||||
if (!ptr.isEmpty())
|
||||
{
|
||||
// TODO check stacking
|
||||
|
||||
ESMS::LiveCellRef<T, MWWorld::RefData> cellRef(ptr.getCellRef(), ptr.get<T>()->base);
|
||||
cellRef.mData = ptr.getRefData();
|
||||
|
||||
containerStore.list.push_back (cellRef);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,629 @@
|
||||
#include "charactercreation.hpp"
|
||||
|
||||
#include "text_input.hpp"
|
||||
#include "race.hpp"
|
||||
#include "class.hpp"
|
||||
#include "birth.hpp"
|
||||
#include "review.hpp"
|
||||
#include "dialogue.hpp"
|
||||
#include "mode.hpp"
|
||||
|
||||
namespace
|
||||
{
|
||||
struct Step
|
||||
{
|
||||
const char* mText;
|
||||
const char* mButtons[3];
|
||||
ESM::Class::Specialization mSpecializations[3]; // The specialization for each answer
|
||||
};
|
||||
|
||||
static boost::array<Step, 10> sGenerateClassSteps = { {
|
||||
// Question 1
|
||||
{"On a clear day you chance upon a strange animal, its legs trapped in a hunter's clawsnare. Judging from the bleeding, it will not survive long.",
|
||||
{"Draw your dagger, mercifully endings its life with a single thrust.",
|
||||
"Use herbs from your pack to put it to sleep.",
|
||||
"Do not interfere in the natural evolution of events, but rather take the opportunity to learn more about a strange animal that you have never seen before."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 2
|
||||
{"One Summer afternoon your father gives you a choice of chores.",
|
||||
{"Work in the forge with him casting iron for a new plow.",
|
||||
"Gather herbs for your mother who is preparing dinner.",
|
||||
"Go catch fish at the stream using a net and line."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 3
|
||||
{"Your cousin has given you a very embarrassing nickname and, even worse, likes to call you it in front of your friends. You asked him to stop, but he finds it very amusing to watch you blush.",
|
||||
{"Beat up your cousin, then tell him that if he ever calls you that nickname again, you will bloody him worse than this time.",
|
||||
"Make up a story that makes your nickname a badge of honor instead of something humiliating.",
|
||||
"Make up an even more embarrassing nickname for him and use it constantly until he learns his lesson."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 4
|
||||
{"There is a lot of heated discussion at the local tavern over a grouped of people called 'Telepaths'. They have been hired by certain City-State kings. Rumor has it these Telepaths read a person's mind and tell their lord whether a follower is telling the truth or not.",
|
||||
{"This is a terrible practice. A person's thoughts are his own and no one, not even a king, has the right to make such an invasion into another human's mind.",
|
||||
"Loyal followers to the king have nothing to fear from a Telepath. It is important to have a method of finding assassins and spies before it is too late.",
|
||||
"In these times, it is a necessary evil. Although you do not necessarily like the idea, a Telepath could have certain advantages during a time of war or in finding someone innocent of a crime."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 5
|
||||
{"Your mother sends you to the market with a list of goods to buy. After you finish you find that by mistake a shopkeeper has given you too much money back in exchange for one of the items.",
|
||||
{"Return to the store and give the shopkeeper his hard-earned money, explaining to him the mistake?",
|
||||
"Decide to put the extra money to good use and purchase items that would help your family?",
|
||||
"Pocket the extra money, knowing that shopkeepers in general tend to overcharge customers anyway?"},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 6
|
||||
{"While in the market place you witness a thief cut a purse from a noble. Even as he does so, the noble notices and calls for the city guards. In his haste to get away, the thief drops the purse near you. Surprisingly no one seems to notice the bag of coins at your feet.",
|
||||
{"Pick up the bag and signal to the guard, knowing that the only honorable thing to do is return the money to its rightful owner.",
|
||||
"Leave the bag there, knowing that it is better not to get involved.",
|
||||
"Pick up the bag and pocket it, knowing that the extra windfall will help your family in times of trouble."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 7
|
||||
{"Your father sends you on a task which you loathe, cleaning the stables. On the way there, pitchfork in hand, you run into your friend from the homestead near your own. He offers to do it for you, in return for a future favor of his choosing.",
|
||||
{"Decline his offer, knowing that your father expects you to do the work, and it is better not to be in debt.",
|
||||
"Ask him to help you, knowing that two people can do the job faster than one, and agree to help him with one task of his choosing in the future.",
|
||||
"Accept his offer, reasoning that as long as the stables are cleaned, it matters not who does the cleaning."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 8
|
||||
{"Your mother asks you to help fix the stove. While you are working, a very hot pipe slips its mooring and falls towards her.",
|
||||
{"Position yourself between the pipe and your mother.",
|
||||
"Grab the hot pipe and try to push it away.",
|
||||
"Push your mother out of the way."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 9
|
||||
{"While in town the baker gives you a sweetroll. Delighted, you take it into an alley to enjoy only to be intercepted by a gang of three other kids your age. The leader demands the sweetroll, or else he and his friends will beat you and take it.",
|
||||
{"Drop the sweetroll and step on it, then get ready for the fight.",
|
||||
"Give him the sweetroll now without argument, knowing that later this afternoon you will have all your friends with you and can come and take whatever he owes you.",
|
||||
"Act like you're going to give him the sweetroll, but at the last minute throw it in the air, hoping that they'll pay attention to it long enough for you to get a shot in on the leader."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
},
|
||||
// Question 10
|
||||
{"Entering town you find that you are witness to a very well-dressed man running from a crowd. He screams to you for help. The crowd behind him seem very angry.",
|
||||
{"Rush to the town's aid immediately, despite your lack of knowledge of the circumstances.",
|
||||
"Stand aside and allow the man and the mob to pass, realizing it is probably best not to get involved.",
|
||||
"Rush to the man's aid immediately, despite your lack of knowledge of the circumstances."},
|
||||
{ESM::Class::Combat, ESM::Class::Magic, ESM::Class::Stealth}
|
||||
}
|
||||
} };
|
||||
}
|
||||
|
||||
using namespace MWGui;
|
||||
|
||||
CharacterCreation::CharacterCreation(WindowManager* _wm, MWWorld::Environment* _environment)
|
||||
: mNameDialog(0)
|
||||
, mRaceDialog(0)
|
||||
, mDialogueWindow(0)
|
||||
, mClassChoiceDialog(0)
|
||||
, mGenerateClassQuestionDialog(0)
|
||||
, mGenerateClassResultDialog(0)
|
||||
, mPickClassDialog(0)
|
||||
, mCreateClassDialog(0)
|
||||
, mBirthSignDialog(0)
|
||||
, mReviewDialog(0)
|
||||
, mWM(_wm)
|
||||
, mEnvironment(_environment)
|
||||
{
|
||||
mCreationStage = CSE_NotStarted;
|
||||
}
|
||||
|
||||
void CharacterCreation::spawnDialog(const char id)
|
||||
{
|
||||
switch (id)
|
||||
{
|
||||
case GM_Name:
|
||||
if(mNameDialog)
|
||||
mWM->removeDialog(mNameDialog);
|
||||
mNameDialog = new TextInputDialog(*mWM);
|
||||
mNameDialog->setTextLabel(mWM->getGameSettingString("sName", "Name"));
|
||||
mNameDialog->setTextInput(mPlayerName);
|
||||
mNameDialog->setNextButtonShow(mCreationStage >= CSE_NameChosen);
|
||||
mNameDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onNameDialogDone);
|
||||
mNameDialog->open();
|
||||
break;
|
||||
|
||||
case GM_Race:
|
||||
if (mRaceDialog)
|
||||
mWM->removeDialog(mRaceDialog);
|
||||
mRaceDialog = new RaceDialog(*mWM);
|
||||
mRaceDialog->setNextButtonShow(mCreationStage >= CSE_RaceChosen);
|
||||
mRaceDialog->setRaceId(mPlayerRaceId);
|
||||
mRaceDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onRaceDialogDone);
|
||||
mRaceDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onRaceDialogBack);
|
||||
mRaceDialog->open();
|
||||
break;
|
||||
|
||||
case GM_Class:
|
||||
if (mClassChoiceDialog)
|
||||
mWM->removeDialog(mClassChoiceDialog);
|
||||
mClassChoiceDialog = new ClassChoiceDialog(*mWM);
|
||||
mClassChoiceDialog->eventButtonSelected = MyGUI::newDelegate(this, &CharacterCreation::onClassChoice);
|
||||
mClassChoiceDialog->open();
|
||||
break;
|
||||
|
||||
case GM_ClassPick:
|
||||
if (mPickClassDialog)
|
||||
mWM->removeDialog(mPickClassDialog);
|
||||
mPickClassDialog = new PickClassDialog(*mWM);
|
||||
mPickClassDialog->setNextButtonShow(mCreationStage >= CSE_ClassChosen);
|
||||
mPickClassDialog->setClassId(mPlayerClass.name);
|
||||
mPickClassDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onPickClassDialogDone);
|
||||
mPickClassDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onPickClassDialogBack);
|
||||
mPickClassDialog->open();
|
||||
break;
|
||||
|
||||
case GM_Birth:
|
||||
if (mBirthSignDialog)
|
||||
mWM->removeDialog(mBirthSignDialog);
|
||||
mBirthSignDialog = new BirthDialog(*mWM);
|
||||
mBirthSignDialog->setNextButtonShow(mCreationStage >= CSE_BirthSignChosen);
|
||||
mBirthSignDialog->setBirthId(mPlayerBirthSignId);
|
||||
mBirthSignDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onBirthSignDialogDone);
|
||||
mBirthSignDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onBirthSignDialogBack);
|
||||
mBirthSignDialog->open();
|
||||
break;
|
||||
|
||||
case GM_ClassCreate:
|
||||
if (mCreateClassDialog)
|
||||
mWM->removeDialog(mCreateClassDialog);
|
||||
mCreateClassDialog = new CreateClassDialog(*mWM);
|
||||
mCreateClassDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onCreateClassDialogDone);
|
||||
mCreateClassDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onCreateClassDialogBack);
|
||||
mCreateClassDialog->open();
|
||||
break;
|
||||
case GM_ClassGenerate:
|
||||
mGenerateClassStep = 0;
|
||||
mGenerateClass = "";
|
||||
mGenerateClassSpecializations[0] = 0;
|
||||
mGenerateClassSpecializations[1] = 0;
|
||||
mGenerateClassSpecializations[2] = 0;
|
||||
showClassQuestionDialog();
|
||||
break;
|
||||
case GM_Review:
|
||||
if (mReviewDialog)
|
||||
mWM->removeDialog(mReviewDialog);
|
||||
mReviewDialog = new ReviewDialog(*mWM);
|
||||
mReviewDialog->setPlayerName(mPlayerName);
|
||||
mReviewDialog->setRace(mPlayerRaceId);
|
||||
mReviewDialog->setClass(mPlayerClass);
|
||||
mReviewDialog->setBirthSign(mPlayerBirthSignId);
|
||||
|
||||
mReviewDialog->setHealth(mPlayerHealth);
|
||||
mReviewDialog->setMagicka(mPlayerMagicka);
|
||||
mReviewDialog->setFatigue(mPlayerFatigue);
|
||||
|
||||
{
|
||||
std::map<ESM::Attribute::AttributeID, MWMechanics::Stat<int> >::iterator end = mPlayerAttributes.end();
|
||||
for (std::map<ESM::Attribute::AttributeID, MWMechanics::Stat<int> >::iterator it = mPlayerAttributes.begin(); it != end; ++it)
|
||||
{
|
||||
mReviewDialog->setAttribute(it->first, it->second);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
std::map<ESM::Skill::SkillEnum, MWMechanics::Stat<float> >::iterator end = mPlayerSkillValues.end();
|
||||
for (std::map<ESM::Skill::SkillEnum, MWMechanics::Stat<float> >::iterator it = mPlayerSkillValues.begin(); it != end; ++it)
|
||||
{
|
||||
mReviewDialog->setSkillValue(it->first, it->second);
|
||||
}
|
||||
mReviewDialog->configureSkills(mPlayerMajorSkills, mPlayerMinorSkills);
|
||||
}
|
||||
|
||||
mReviewDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onReviewDialogDone);
|
||||
mReviewDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onReviewDialogBack);
|
||||
mReviewDialog->eventActivateDialog = MyGUI::newDelegate(this, &CharacterCreation::onReviewActivateDialog);
|
||||
mReviewDialog->open();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void CharacterCreation::setPlayerHealth (const MWMechanics::DynamicStat<int>& value)
|
||||
{
|
||||
mPlayerHealth = value;
|
||||
}
|
||||
|
||||
void CharacterCreation::setPlayerMagicka (const MWMechanics::DynamicStat<int>& value)
|
||||
{
|
||||
mPlayerMagicka = value;
|
||||
}
|
||||
|
||||
void CharacterCreation::setPlayerFatigue (const MWMechanics::DynamicStat<int>& value)
|
||||
{
|
||||
mPlayerFatigue = value;
|
||||
}
|
||||
|
||||
void CharacterCreation::onReviewDialogDone(WindowBase* parWindow)
|
||||
{
|
||||
if (mReviewDialog)
|
||||
mWM->removeDialog(mReviewDialog);
|
||||
|
||||
mWM->setGuiMode(GM_Game);
|
||||
}
|
||||
|
||||
void CharacterCreation::onReviewDialogBack()
|
||||
{
|
||||
if (mReviewDialog)
|
||||
mWM->removeDialog(mReviewDialog);
|
||||
|
||||
mWM->setGuiMode(GM_Birth);
|
||||
}
|
||||
|
||||
void CharacterCreation::onReviewActivateDialog(int parDialog)
|
||||
{
|
||||
if (mReviewDialog)
|
||||
mWM->removeDialog(mReviewDialog);
|
||||
mCreationStage = CSE_ReviewNext;
|
||||
|
||||
switch(parDialog)
|
||||
{
|
||||
case ReviewDialog::NAME_DIALOG:
|
||||
mWM->setGuiMode(GM_Name);
|
||||
break;
|
||||
case ReviewDialog::RACE_DIALOG:
|
||||
mWM->setGuiMode(GM_Race);
|
||||
break;
|
||||
case ReviewDialog::CLASS_DIALOG:
|
||||
mWM->setGuiMode(GM_Class);
|
||||
break;
|
||||
case ReviewDialog::BIRTHSIGN_DIALOG:
|
||||
mWM->setGuiMode(GM_Birth);
|
||||
};
|
||||
}
|
||||
|
||||
void CharacterCreation::onPickClassDialogDone(WindowBase* parWindow)
|
||||
{
|
||||
if (mPickClassDialog)
|
||||
{
|
||||
const std::string &classId = mPickClassDialog->getClassId();
|
||||
if (!classId.empty())
|
||||
mEnvironment->mMechanicsManager->setPlayerClass(classId);
|
||||
const ESM::Class *klass = mEnvironment->mWorld->getStore().classes.find(classId);
|
||||
if (klass)
|
||||
{
|
||||
mPlayerClass = *klass;
|
||||
mWM->setPlayerClass(mPlayerClass);
|
||||
}
|
||||
mWM->removeDialog(mPickClassDialog);
|
||||
}
|
||||
|
||||
//TODO This bit gets repeated a few times; wrap it in a function
|
||||
if (mCreationStage == CSE_ReviewNext)
|
||||
mWM->setGuiMode(GM_Review);
|
||||
else if (mCreationStage >= CSE_ClassChosen)
|
||||
mWM->setGuiMode(GM_Birth);
|
||||
else
|
||||
{
|
||||
mCreationStage = CSE_ClassChosen;
|
||||
mWM->setGuiMode(GM_Game);
|
||||
}
|
||||
}
|
||||
|
||||
void CharacterCreation::onPickClassDialogBack()
|
||||
{
|
||||
if (mPickClassDialog)
|
||||
{
|
||||
const std::string classId = mPickClassDialog->getClassId();
|
||||
if (!classId.empty())
|
||||
mEnvironment->mMechanicsManager->setPlayerClass(classId);
|
||||
mWM->removeDialog(mPickClassDialog);
|
||||
}
|
||||
|
||||
mWM->setGuiMode(GM_Class);
|
||||
}
|
||||
|
||||
void CharacterCreation::onClassChoice(int _index)
|
||||
{
|
||||
if (mClassChoiceDialog)
|
||||
{
|
||||
mWM->removeDialog(mClassChoiceDialog);
|
||||
}
|
||||
|
||||
switch(_index)
|
||||
{
|
||||
case ClassChoiceDialog::Class_Generate:
|
||||
mWM->setGuiMode(GM_ClassGenerate);
|
||||
break;
|
||||
case ClassChoiceDialog::Class_Pick:
|
||||
mWM->setGuiMode(GM_ClassPick);
|
||||
break;
|
||||
case ClassChoiceDialog::Class_Create:
|
||||
mWM->setGuiMode(GM_ClassCreate);
|
||||
break;
|
||||
case ClassChoiceDialog::Class_Back:
|
||||
mWM->setGuiMode(GM_Race);
|
||||
break;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
void CharacterCreation::onNameDialogDone(WindowBase* parWindow)
|
||||
{
|
||||
if (mNameDialog)
|
||||
{
|
||||
mPlayerName = mNameDialog->getTextInput();
|
||||
mWM->setValue("name", mPlayerName);
|
||||
mEnvironment->mMechanicsManager->setPlayerName(mPlayerName);
|
||||
mWM->removeDialog(mNameDialog);
|
||||
}
|
||||
|
||||
if (mCreationStage == CSE_ReviewNext)
|
||||
mWM->setGuiMode(GM_Review);
|
||||
else if (mCreationStage >= CSE_NameChosen)
|
||||
mWM->setGuiMode(GM_Race);
|
||||
else
|
||||
{
|
||||
mCreationStage = CSE_NameChosen;
|
||||
mWM->setGuiMode(GM_Game);
|
||||
}
|
||||
}
|
||||
|
||||
void CharacterCreation::onRaceDialogBack()
|
||||
{
|
||||
if (mRaceDialog)
|
||||
{
|
||||
mPlayerRaceId = mRaceDialog->getRaceId();
|
||||
if (!mPlayerRaceId.empty())
|
||||
mEnvironment->mMechanicsManager->setPlayerRace(mPlayerRaceId, mRaceDialog->getGender() == RaceDialog::GM_Male);
|
||||
mWM->removeDialog(mRaceDialog);
|
||||
}
|
||||
|
||||
mWM->setGuiMode(GM_Name);
|
||||
}
|
||||
|
||||
void CharacterCreation::onRaceDialogDone(WindowBase* parWindow)
|
||||
{
|
||||
if (mRaceDialog)
|
||||
{
|
||||
mPlayerRaceId = mRaceDialog->getRaceId();
|
||||
mWM->setValue("race", mPlayerRaceId);
|
||||
if (!mPlayerRaceId.empty())
|
||||
mEnvironment->mMechanicsManager->setPlayerRace(mPlayerRaceId, mRaceDialog->getGender() == RaceDialog::GM_Male);
|
||||
mWM->removeDialog(mRaceDialog);
|
||||
}
|
||||
|
||||
if (mCreationStage == CSE_ReviewNext)
|
||||
mWM->setGuiMode(GM_Review);
|
||||
else if(mCreationStage >= CSE_RaceChosen)
|
||||
mWM->setGuiMode(GM_Class);
|
||||
else
|
||||
{
|
||||
mCreationStage = CSE_RaceChosen;
|
||||
mWM->setGuiMode(GM_Game);
|
||||
}
|
||||
}
|
||||
|
||||
void CharacterCreation::onBirthSignDialogDone(WindowBase* parWindow)
|
||||
{
|
||||
if (mBirthSignDialog)
|
||||
{
|
||||
mPlayerBirthSignId = mBirthSignDialog->getBirthId();
|
||||
mWM->setBirthSign(mPlayerBirthSignId);
|
||||
if (!mPlayerBirthSignId.empty())
|
||||
mEnvironment->mMechanicsManager->setPlayerBirthsign(mPlayerBirthSignId);
|
||||
mWM->removeDialog(mBirthSignDialog);
|
||||
}
|
||||
|
||||
if (mCreationStage >= CSE_BirthSignChosen)
|
||||
mWM->setGuiMode(GM_Review);
|
||||
else
|
||||
{
|
||||
mCreationStage = CSE_BirthSignChosen;
|
||||
mWM->setGuiMode(GM_Game);
|
||||
}
|
||||
}
|
||||
|
||||
void CharacterCreation::onBirthSignDialogBack()
|
||||
{
|
||||
if (mBirthSignDialog)
|
||||
{
|
||||
mEnvironment->mMechanicsManager->setPlayerBirthsign(mBirthSignDialog->getBirthId());
|
||||
mWM->removeDialog(mBirthSignDialog);
|
||||
}
|
||||
|
||||
mWM->setGuiMode(GM_Class);
|
||||
}
|
||||
|
||||
void CharacterCreation::onCreateClassDialogDone(WindowBase* parWindow)
|
||||
{
|
||||
if (mCreateClassDialog)
|
||||
{
|
||||
ESM::Class klass;
|
||||
klass.name = mCreateClassDialog->getName();
|
||||
klass.description = mCreateClassDialog->getDescription();
|
||||
klass.data.specialization = mCreateClassDialog->getSpecializationId();
|
||||
klass.data.isPlayable = 0x1;
|
||||
|
||||
std::vector<int> attributes = mCreateClassDialog->getFavoriteAttributes();
|
||||
assert(attributes.size() == 2);
|
||||
klass.data.attribute[0] = attributes[0];
|
||||
klass.data.attribute[1] = attributes[1];
|
||||
|
||||
std::vector<ESM::Skill::SkillEnum> majorSkills = mCreateClassDialog->getMajorSkills();
|
||||
std::vector<ESM::Skill::SkillEnum> minorSkills = mCreateClassDialog->getMinorSkills();
|
||||
assert(majorSkills.size() >= sizeof(klass.data.skills)/sizeof(klass.data.skills[0]));
|
||||
assert(minorSkills.size() >= sizeof(klass.data.skills)/sizeof(klass.data.skills[0]));
|
||||
for (size_t i = 0; i < sizeof(klass.data.skills)/sizeof(klass.data.skills[0]); ++i)
|
||||
{
|
||||
klass.data.skills[i][1] = majorSkills[i];
|
||||
klass.data.skills[i][0] = minorSkills[i];
|
||||
}
|
||||
mEnvironment->mMechanicsManager->setPlayerClass(klass);
|
||||
mPlayerClass = klass;
|
||||
mWM->setPlayerClass(klass);
|
||||
|
||||
mWM->removeDialog(mCreateClassDialog);
|
||||
}
|
||||
|
||||
if (mCreationStage == CSE_ReviewNext)
|
||||
mWM->setGuiMode(GM_Review);
|
||||
else if (mCreationStage >= CSE_ClassChosen)
|
||||
mWM->setGuiMode(GM_Birth);
|
||||
else
|
||||
{
|
||||
mCreationStage = CSE_ClassChosen;
|
||||
mWM->setGuiMode(GM_Game);
|
||||
}
|
||||
}
|
||||
|
||||
void CharacterCreation::onCreateClassDialogBack()
|
||||
{
|
||||
if (mCreateClassDialog)
|
||||
mWM->removeDialog(mCreateClassDialog);
|
||||
|
||||
mWM->setGuiMode(GM_Class);
|
||||
}
|
||||
|
||||
void CharacterCreation::onClassQuestionChosen(int _index)
|
||||
{
|
||||
if (mGenerateClassQuestionDialog)
|
||||
mWM->removeDialog(mGenerateClassQuestionDialog);
|
||||
if (_index < 0 || _index >= 3)
|
||||
{
|
||||
mWM->setGuiMode(GM_Class);
|
||||
return;
|
||||
}
|
||||
|
||||
ESM::Class::Specialization specialization = sGenerateClassSteps[mGenerateClassStep].mSpecializations[_index];
|
||||
if (specialization == ESM::Class::Stealth)
|
||||
++mGenerateClassSpecializations[0];
|
||||
else if (specialization == ESM::Class::Combat)
|
||||
++mGenerateClassSpecializations[1];
|
||||
else if (specialization == ESM::Class::Magic)
|
||||
++mGenerateClassSpecializations[2];
|
||||
++mGenerateClassStep;
|
||||
showClassQuestionDialog();
|
||||
}
|
||||
|
||||
void CharacterCreation::showClassQuestionDialog()
|
||||
{
|
||||
if (mGenerateClassStep == sGenerateClassSteps.size())
|
||||
{
|
||||
static boost::array<ClassPoint, 23> classes = { {
|
||||
{"Acrobat", {6, 2, 2}},
|
||||
{"Agent", {6, 1, 3}},
|
||||
{"Archer", {3, 5, 2}},
|
||||
{"Archer", {5, 5, 0}},
|
||||
{"Assassin", {6, 3, 1}},
|
||||
{"Barbarian", {3, 6, 1}},
|
||||
{"Bard", {3, 3, 3}},
|
||||
{"Battlemage", {1, 3, 6}},
|
||||
{"Crusader", {1, 6, 3}},
|
||||
{"Healer", {3, 1, 6}},
|
||||
{"Knight", {2, 6, 2}},
|
||||
{"Monk", {5, 3, 2}},
|
||||
{"Nightblade", {4, 2, 4}},
|
||||
{"Pilgrim", {5, 2, 3}},
|
||||
{"Rogue", {3, 4, 3}},
|
||||
{"Rogue", {4, 4, 2}},
|
||||
{"Rogue", {5, 4, 1}},
|
||||
{"Scout", {2, 5, 3}},
|
||||
{"Sorcerer", {2, 2, 6}},
|
||||
{"Spellsword", {2, 4, 4}},
|
||||
{"Spellsword", {5, 1, 4}},
|
||||
{"Witchhunter", {2, 3, 5}},
|
||||
{"Witchhunter", {5, 0, 5}}
|
||||
} };
|
||||
|
||||
int match = -1;
|
||||
for (unsigned i = 0; i < classes.size(); ++i)
|
||||
{
|
||||
if (mGenerateClassSpecializations[0] == classes[i].points[0] &&
|
||||
mGenerateClassSpecializations[1] == classes[i].points[1] &&
|
||||
mGenerateClassSpecializations[2] == classes[i].points[2])
|
||||
{
|
||||
match = i;
|
||||
mGenerateClass = classes[i].id;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (match == -1)
|
||||
{
|
||||
if (mGenerateClassSpecializations[0] >= 7)
|
||||
mGenerateClass = "Thief";
|
||||
else if (mGenerateClassSpecializations[1] >= 7)
|
||||
mGenerateClass = "Warrior";
|
||||
else if (mGenerateClassSpecializations[2] >= 7)
|
||||
mGenerateClass = "Mage";
|
||||
else
|
||||
{
|
||||
std::cerr << "Failed to deduce class from chosen answers in generate class dialog" << std::endl;
|
||||
mGenerateClass = "Thief";
|
||||
}
|
||||
}
|
||||
|
||||
if (mGenerateClassResultDialog)
|
||||
mWM->removeDialog(mGenerateClassResultDialog);
|
||||
mGenerateClassResultDialog = new GenerateClassResultDialog(*mWM);
|
||||
mGenerateClassResultDialog->setClassId(mGenerateClass);
|
||||
mGenerateClassResultDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onGenerateClassBack);
|
||||
mGenerateClassResultDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onGenerateClassDone);
|
||||
mGenerateClassResultDialog->open();
|
||||
return;
|
||||
}
|
||||
|
||||
if (mGenerateClassStep > sGenerateClassSteps.size())
|
||||
{
|
||||
mWM->setGuiMode(GM_Class);
|
||||
return;
|
||||
}
|
||||
|
||||
if (mGenerateClassQuestionDialog)
|
||||
mWM->removeDialog(mGenerateClassQuestionDialog);
|
||||
mGenerateClassQuestionDialog = new InfoBoxDialog(*mWM);
|
||||
|
||||
InfoBoxDialog::ButtonList buttons;
|
||||
mGenerateClassQuestionDialog->setText(sGenerateClassSteps[mGenerateClassStep].mText);
|
||||
buttons.push_back(sGenerateClassSteps[mGenerateClassStep].mButtons[0]);
|
||||
buttons.push_back(sGenerateClassSteps[mGenerateClassStep].mButtons[1]);
|
||||
buttons.push_back(sGenerateClassSteps[mGenerateClassStep].mButtons[2]);
|
||||
mGenerateClassQuestionDialog->setButtons(buttons);
|
||||
mGenerateClassQuestionDialog->eventButtonSelected = MyGUI::newDelegate(this, &CharacterCreation::onClassQuestionChosen);
|
||||
mGenerateClassQuestionDialog->open();
|
||||
}
|
||||
|
||||
void CharacterCreation::onGenerateClassBack()
|
||||
{
|
||||
if(mCreationStage < CSE_ClassChosen)
|
||||
mCreationStage = CSE_ClassChosen;
|
||||
|
||||
if (mGenerateClassResultDialog)
|
||||
mWM->removeDialog(mGenerateClassResultDialog);
|
||||
mEnvironment->mMechanicsManager->setPlayerClass(mGenerateClass);
|
||||
|
||||
mWM->setGuiMode(GM_Class);
|
||||
}
|
||||
|
||||
void CharacterCreation::onGenerateClassDone(WindowBase* parWindow)
|
||||
{
|
||||
if (mGenerateClassResultDialog)
|
||||
mWM->removeDialog(mGenerateClassResultDialog);
|
||||
mEnvironment->mMechanicsManager->setPlayerClass(mGenerateClass);
|
||||
|
||||
if (mCreationStage == CSE_ReviewNext)
|
||||
mWM->setGuiMode(GM_Review);
|
||||
else if (mCreationStage >= CSE_ClassChosen)
|
||||
mWM->setGuiMode(GM_Birth);
|
||||
else
|
||||
{
|
||||
mCreationStage = CSE_ClassChosen;
|
||||
mWM->setGuiMode(GM_Game);
|
||||
}
|
||||
}
|
||||
|
||||
CharacterCreation::~CharacterCreation()
|
||||
{
|
||||
delete mNameDialog;
|
||||
delete mRaceDialog;
|
||||
delete mDialogueWindow;
|
||||
delete mClassChoiceDialog;
|
||||
delete mGenerateClassQuestionDialog;
|
||||
delete mGenerateClassResultDialog;
|
||||
delete mPickClassDialog;
|
||||
delete mCreateClassDialog;
|
||||
delete mBirthSignDialog;
|
||||
delete mReviewDialog;
|
||||
}
|
||||
@ -0,0 +1,120 @@
|
||||
#ifndef CHARACTER_CREATION_HPP
|
||||
#define CHARACTER_CREATION_HPP
|
||||
|
||||
#include "window_manager.hpp"
|
||||
|
||||
#include "../mwmechanics/mechanicsmanager.hpp"
|
||||
#include "../mwmechanics/stat.hpp"
|
||||
#include "../mwworld/world.hpp"
|
||||
#include <components/esm_store/store.hpp>
|
||||
|
||||
namespace MWGui
|
||||
{
|
||||
class WindowManager;
|
||||
class WindowBase;
|
||||
|
||||
class TextInputDialog;
|
||||
class InfoBoxDialog;
|
||||
class RaceDialog;
|
||||
class DialogueWindow;
|
||||
class ClassChoiceDialog;
|
||||
class GenerateClassResultDialog;
|
||||
class PickClassDialog;
|
||||
class CreateClassDialog;
|
||||
class BirthDialog;
|
||||
class ReviewDialog;
|
||||
class MessageBoxManager;
|
||||
|
||||
class CharacterCreation
|
||||
{
|
||||
public:
|
||||
typedef std::vector<int> SkillList;
|
||||
|
||||
CharacterCreation(WindowManager* _wm, MWWorld::Environment* _environment);
|
||||
~CharacterCreation();
|
||||
|
||||
//Show a dialog
|
||||
void spawnDialog(const char id);
|
||||
|
||||
void setPlayerHealth (const MWMechanics::DynamicStat<int>& value);
|
||||
|
||||
void setPlayerMagicka (const MWMechanics::DynamicStat<int>& value);
|
||||
|
||||
void setPlayerFatigue (const MWMechanics::DynamicStat<int>& value);
|
||||
|
||||
private:
|
||||
//Dialogs
|
||||
TextInputDialog* mNameDialog;
|
||||
RaceDialog* mRaceDialog;
|
||||
DialogueWindow* mDialogueWindow;
|
||||
ClassChoiceDialog* mClassChoiceDialog;
|
||||
InfoBoxDialog* mGenerateClassQuestionDialog;
|
||||
GenerateClassResultDialog* mGenerateClassResultDialog;
|
||||
PickClassDialog* mPickClassDialog;
|
||||
CreateClassDialog* mCreateClassDialog;
|
||||
BirthDialog* mBirthSignDialog;
|
||||
ReviewDialog* mReviewDialog;
|
||||
|
||||
WindowManager* mWM;
|
||||
MWWorld::Environment* mEnvironment;
|
||||
|
||||
//Player data
|
||||
std::string mPlayerName;
|
||||
std::string mPlayerRaceId;
|
||||
std::string mPlayerBirthSignId;
|
||||
ESM::Class mPlayerClass;
|
||||
std::map<ESM::Attribute::AttributeID, MWMechanics::Stat<int> > mPlayerAttributes;
|
||||
SkillList mPlayerMajorSkills, mPlayerMinorSkills;
|
||||
std::map<ESM::Skill::SkillEnum, MWMechanics::Stat<float> > mPlayerSkillValues;
|
||||
MWMechanics::DynamicStat<int> mPlayerHealth;
|
||||
MWMechanics::DynamicStat<int> mPlayerMagicka;
|
||||
MWMechanics::DynamicStat<int> mPlayerFatigue;
|
||||
|
||||
//Class generation vars
|
||||
unsigned mGenerateClassStep; // Keeps track of current step in Generate Class dialog
|
||||
unsigned mGenerateClassSpecializations[3]; // A counter for each specialization which is increased when an answer is chosen
|
||||
std::string mGenerateClass; // In order: Stealth, Combat, Magic
|
||||
|
||||
////Dialog events
|
||||
//Name dialog
|
||||
void onNameDialogDone(WindowBase* parWindow);
|
||||
|
||||
//Race dialog
|
||||
void onRaceDialogDone(WindowBase* parWindow);
|
||||
void onRaceDialogBack();
|
||||
|
||||
//Class dialogs
|
||||
void onClassChoice(int _index);
|
||||
void onPickClassDialogDone(WindowBase* parWindow);
|
||||
void onPickClassDialogBack();
|
||||
void onCreateClassDialogDone(WindowBase* parWindow);
|
||||
void onCreateClassDialogBack();
|
||||
void showClassQuestionDialog();
|
||||
void onClassQuestionChosen(int _index);
|
||||
void onGenerateClassBack();
|
||||
void onGenerateClassDone(WindowBase* parWindow);
|
||||
|
||||
//Birthsign dialog
|
||||
void onBirthSignDialogDone(WindowBase* parWindow);
|
||||
void onBirthSignDialogBack();
|
||||
|
||||
//Review dialog
|
||||
void onReviewDialogDone(WindowBase* parWindow);
|
||||
void onReviewDialogBack();
|
||||
void onReviewActivateDialog(int parDialog);
|
||||
|
||||
enum CSE //Creation Stage Enum
|
||||
{
|
||||
CSE_NotStarted,
|
||||
CSE_NameChosen,
|
||||
CSE_RaceChosen,
|
||||
CSE_ClassChosen,
|
||||
CSE_BirthSignChosen,
|
||||
CSE_ReviewNext
|
||||
};
|
||||
|
||||
CSE mCreationStage; // Which state the character creating is in, controls back/next/ok buttons
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,116 +1,770 @@
|
||||
#include "sky.hpp"
|
||||
#include "Caelum.h"
|
||||
|
||||
namespace MWRender
|
||||
{
|
||||
//
|
||||
// Implements a Caelum sky with default settings.
|
||||
//
|
||||
// Note: this is intended as a temporary solution to provide some form of
|
||||
// sky rendering. This code will obviously need significant tailoring to
|
||||
// support fidelity with Morrowind's rendering. Before doing major work
|
||||
// on this class, more research should be done to determine whether
|
||||
// Caelum or another plug-in such as SkyX would be best for the long-term.
|
||||
//
|
||||
class CaelumManager : public SkyManager
|
||||
{
|
||||
protected:
|
||||
Caelum::CaelumSystem* mpCaelumSystem;
|
||||
|
||||
public:
|
||||
CaelumManager (Ogre::RenderWindow* pRenderWindow,
|
||||
Ogre::Camera* pCamera,
|
||||
const boost::filesystem::path& resDir);
|
||||
virtual ~CaelumManager ();
|
||||
|
||||
virtual void enable() {}
|
||||
|
||||
virtual void disable() {}
|
||||
|
||||
virtual void setHour (double hour) {}
|
||||
///< will be called even when sky is disabled.
|
||||
|
||||
virtual void setDate (int day, int month) {}
|
||||
///< will be called even when sky is disabled.
|
||||
|
||||
virtual int getMasserPhase() const { return 0; }
|
||||
///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
|
||||
/// 3 waxing or waning gibbous, 4 full moon
|
||||
|
||||
virtual int getSecundaPhase() const { return 0; }
|
||||
///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
|
||||
/// 3 waxing or waning gibbous, 4 full moon
|
||||
|
||||
virtual void setMoonColour (bool red) {}
|
||||
};
|
||||
|
||||
CaelumManager::CaelumManager (Ogre::RenderWindow* pRenderWindow,
|
||||
Ogre::Camera* pCamera,
|
||||
const boost::filesystem::path& resDir)
|
||||
: mpCaelumSystem (NULL)
|
||||
|
||||
#include <OgreCamera.h>
|
||||
#include <OgreRenderWindow.h>
|
||||
#include <OgreSceneNode.h>
|
||||
#include <OgreMesh.h>
|
||||
#include <OgreSceneManager.h>
|
||||
#include <OgreHardwareVertexBuffer.h>
|
||||
#include <OgreHighLevelGpuProgramManager.h>
|
||||
|
||||
#include <components/nifogre/ogre_nif_loader.hpp>
|
||||
|
||||
using namespace MWRender;
|
||||
using namespace Ogre;
|
||||
|
||||
// the speed at which the clouds are animated
|
||||
#define CLOUD_SPEED 0.001
|
||||
|
||||
// this distance has to be set accordingly so that the
|
||||
// celestial bodies are behind the clouds, but in front of the atmosphere
|
||||
#define CELESTIAL_BODY_DISTANCE 1000.f
|
||||
|
||||
BillboardObject::BillboardObject( const String& textureName,
|
||||
const float initialSize,
|
||||
const Vector3& position,
|
||||
SceneNode* rootNode)
|
||||
{
|
||||
init(textureName, initialSize, position, rootNode);
|
||||
}
|
||||
|
||||
BillboardObject::BillboardObject()
|
||||
{
|
||||
}
|
||||
|
||||
void BillboardObject::setVisible(const bool visible)
|
||||
{
|
||||
mNode->setVisible(visible);
|
||||
}
|
||||
|
||||
void BillboardObject::setSize(const float size)
|
||||
{
|
||||
mNode->setScale(size, size, size);
|
||||
}
|
||||
|
||||
void BillboardObject::setVisibility(const float visibility)
|
||||
{
|
||||
mMaterial->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, visibility);
|
||||
}
|
||||
|
||||
void BillboardObject::setPosition(const Vector3& pPosition)
|
||||
{
|
||||
Vector3 normalised = pPosition.normalisedCopy();
|
||||
Vector3 finalPosition = normalised * CELESTIAL_BODY_DISTANCE;
|
||||
|
||||
mBBSet->setCommonDirection( -normalised );
|
||||
|
||||
mNode->setPosition(finalPosition);
|
||||
}
|
||||
|
||||
Vector3 BillboardObject::getPosition() const
|
||||
{
|
||||
return mNode->getPosition();
|
||||
}
|
||||
|
||||
void BillboardObject::setColour(const ColourValue& pColour)
|
||||
{
|
||||
mMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(pColour);
|
||||
}
|
||||
|
||||
void BillboardObject::setRenderQueue(unsigned int id)
|
||||
{
|
||||
mBBSet->setRenderQueueGroup(id);
|
||||
}
|
||||
|
||||
SceneNode* BillboardObject::getNode()
|
||||
{
|
||||
return mNode;
|
||||
}
|
||||
|
||||
void BillboardObject::init(const String& textureName,
|
||||
const float initialSize,
|
||||
const Vector3& position,
|
||||
SceneNode* rootNode)
|
||||
{
|
||||
SceneManager* sceneMgr = rootNode->getCreator();
|
||||
|
||||
Vector3 finalPosition = position.normalisedCopy() * CELESTIAL_BODY_DISTANCE;
|
||||
|
||||
static unsigned int bodyCount=0;
|
||||
|
||||
/// \todo These billboards are not 100% correct, might want to revisit them later
|
||||
mBBSet = sceneMgr->createBillboardSet("SkyBillboardSet"+StringConverter::toString(bodyCount), 1);
|
||||
mBBSet->setDefaultDimensions(550.f*initialSize, 550.f*initialSize);
|
||||
mBBSet->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+2);
|
||||
mBBSet->setBillboardType(BBT_PERPENDICULAR_COMMON);
|
||||
mBBSet->setCommonDirection( -position.normalisedCopy() );
|
||||
mNode = rootNode->createChildSceneNode();
|
||||
mNode->setPosition(finalPosition);
|
||||
mNode->attachObject(mBBSet);
|
||||
mBBSet->createBillboard(0,0,0);
|
||||
|
||||
mMaterial = MaterialManager::getSingleton().create("BillboardMaterial"+StringConverter::toString(bodyCount), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
|
||||
mMaterial->removeAllTechniques();
|
||||
Pass* p = mMaterial->createTechnique()->createPass();
|
||||
p->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
p->setDepthCheckEnabled(false);
|
||||
p->setDepthWriteEnabled(false);
|
||||
p->setSelfIllumination(1.0,1.0,1.0);
|
||||
p->setDiffuse(0.0,0.0,0.0,1.0);
|
||||
p->setAmbient(0.0,0.0,0.0);
|
||||
p->createTextureUnitState(textureName);
|
||||
mBBSet->setMaterialName("BillboardMaterial"+StringConverter::toString(bodyCount));
|
||||
|
||||
bodyCount++;
|
||||
}
|
||||
|
||||
Moon::Moon( const String& textureName,
|
||||
const float initialSize,
|
||||
const Vector3& position,
|
||||
SceneNode* rootNode)
|
||||
{
|
||||
init(textureName, initialSize, position, rootNode);
|
||||
|
||||
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
|
||||
HighLevelGpuProgramPtr vshader;
|
||||
if (mgr.resourceExists("Moon_VP"))
|
||||
vshader = mgr.getByName("Moon_VP");
|
||||
else
|
||||
vshader = mgr.createProgram("Moon_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_VERTEX_PROGRAM);
|
||||
vshader->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader->setParameter("entry_point", "main_vp");
|
||||
StringUtil::StrStreamType outStream;
|
||||
outStream <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float2 oUV : TEXCOORD0, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oUV = uv; \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
"}";
|
||||
vshader->setSource(outStream.str());
|
||||
vshader->load();
|
||||
vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
mMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
|
||||
|
||||
HighLevelGpuProgramPtr fshader;
|
||||
if (mgr.resourceExists("Moon_FP"))
|
||||
fshader = mgr.getByName("Moon_FP");
|
||||
else
|
||||
fshader = mgr.createProgram("Moon_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_FRAGMENT_PROGRAM);
|
||||
|
||||
fshader->setParameter("profiles", "ps_2_x arbfp1");
|
||||
fshader->setParameter("entry_point", "main_fp");
|
||||
StringUtil::StrStreamType outStream2;
|
||||
outStream2 <<
|
||||
"void main_fp( \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" uniform sampler2D texture : TEXUNIT0, \n"
|
||||
" uniform float4 diffuse, \n"
|
||||
" uniform float4 emissive \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" float4 tex = tex2D(texture, uv); \n"
|
||||
" oColor = float4(emissive.xyz,1) * tex2D(texture, uv) * float4(1,1,1,diffuse.a); \n"
|
||||
" float bump = pow((1-diffuse.a),4); \n"
|
||||
" oColor.rgb += float3(bump, bump, bump)*0.5; \n"
|
||||
"}";
|
||||
fshader->setSource(outStream2.str());
|
||||
fshader->load();
|
||||
fshader->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
|
||||
fshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
mMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(fshader->getName());
|
||||
|
||||
setVisibility(1.0);
|
||||
|
||||
mPhase = Moon::Phase_Full;
|
||||
}
|
||||
|
||||
void Moon::setType(const Moon::Type& type)
|
||||
{
|
||||
mType = type;
|
||||
}
|
||||
|
||||
|
||||
/// \todo the moon phase rendering is not correct - the dark part of the moon does not occlude the stars
|
||||
void Moon::setPhase(const Moon::Phase& phase)
|
||||
{
|
||||
Ogre::String textureName = "textures\\tx_";
|
||||
|
||||
if (mType == Moon::Type_Secunda) textureName += "secunda_";
|
||||
else textureName += "masser_";
|
||||
|
||||
if (phase == Moon::Phase_New) textureName += "new";
|
||||
else if (phase == Moon::Phase_WaxingCrescent) textureName += "one_wax";
|
||||
else if (phase == Moon::Phase_WaxingHalf) textureName += "half_wax";
|
||||
else if (phase == Moon::Phase_WaxingGibbous) textureName += "three_wax";
|
||||
else if (phase == Moon::Phase_WaningCrescent) textureName += "one_wan";
|
||||
else if (phase == Moon::Phase_WaningHalf) textureName += "half_wan";
|
||||
else if (phase == Moon::Phase_WaningGibbous) textureName += "three_wan";
|
||||
else if (phase == Moon::Phase_Full) textureName += "full";
|
||||
|
||||
textureName += ".dds";
|
||||
|
||||
mMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(textureName);
|
||||
|
||||
mPhase = phase;
|
||||
}
|
||||
|
||||
Moon::Phase Moon::getPhase() const
|
||||
{
|
||||
return mPhase;
|
||||
}
|
||||
|
||||
unsigned int Moon::getPhaseInt() const
|
||||
{
|
||||
if (mPhase == Moon::Phase_New) return 0;
|
||||
else if (mPhase == Moon::Phase_WaxingCrescent) return 1;
|
||||
else if (mPhase == Moon::Phase_WaningCrescent) return 1;
|
||||
else if (mPhase == Moon::Phase_WaxingHalf) return 2;
|
||||
else if (mPhase == Moon::Phase_WaningHalf) return 2;
|
||||
else if (mPhase == Moon::Phase_WaxingGibbous) return 3;
|
||||
else if (mPhase == Moon::Phase_WaningGibbous) return 3;
|
||||
else if (mPhase == Moon::Phase_Full) return 4;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void SkyManager::ModVertexAlpha(Entity* ent, unsigned int meshType)
|
||||
{
|
||||
// Get the vertex colour buffer of this mesh
|
||||
const Ogre::VertexElement* ves_diffuse = ent->getMesh()->getSubMesh(0)->vertexData->vertexDeclaration->findElementBySemantic( Ogre::VES_DIFFUSE );
|
||||
HardwareVertexBufferSharedPtr colourBuffer = ent->getMesh()->getSubMesh(0)->vertexData->vertexBufferBinding->getBuffer(ves_diffuse->getSource());
|
||||
|
||||
// Lock
|
||||
void* pData = colourBuffer->lock(HardwareBuffer::HBL_NORMAL);
|
||||
|
||||
// Iterate over all vertices
|
||||
int vertex_size = colourBuffer->getVertexSize();
|
||||
float * currentVertex = NULL;
|
||||
for (unsigned int i=0; i<colourBuffer->getNumVertices(); ++i)
|
||||
{
|
||||
using namespace Ogre;
|
||||
using namespace Caelum;
|
||||
|
||||
assert(pCamera);
|
||||
assert(pRenderWindow);
|
||||
|
||||
// Load the Caelum resources
|
||||
//
|
||||
ResourceGroupManager::getSingleton().addResourceLocation((resDir / "caelum").string(), "FileSystem", "Caelum");
|
||||
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
|
||||
|
||||
// Load the Caelum resources
|
||||
//
|
||||
Ogre::SceneManager* pScene = pCamera->getSceneManager();
|
||||
Caelum::CaelumSystem::CaelumComponent componentMask = CaelumSystem::CAELUM_COMPONENTS_DEFAULT;
|
||||
mpCaelumSystem = new Caelum::CaelumSystem (Root::getSingletonPtr(), pScene, componentMask);
|
||||
|
||||
// Set time acceleration.
|
||||
mpCaelumSystem->getUniversalClock()->setTimeScale(128);
|
||||
|
||||
// Disable fog since OpenMW is handling OGRE fog elsewhere
|
||||
mpCaelumSystem->setManageSceneFog(false);
|
||||
|
||||
// Change the camera far distance to make sure the sky is not clipped
|
||||
pCamera->setFarClipDistance(50000);
|
||||
|
||||
// Register Caelum as an OGRE listener
|
||||
pRenderWindow->addListener(mpCaelumSystem);
|
||||
Root::getSingletonPtr()->addFrameListener(mpCaelumSystem);
|
||||
// Get a pointer to the vertex colour
|
||||
ves_diffuse->baseVertexPointerToElement( pData, ¤tVertex );
|
||||
|
||||
unsigned char alpha;
|
||||
if (meshType == 0) alpha = i%2 ? 0 : 255; // this is a cylinder, so every second vertex belongs to the bottom-most row
|
||||
else if (meshType == 1)
|
||||
{
|
||||
if (i>= 49 && i <= 64) alpha = 0; // bottom-most row
|
||||
else if (i>= 33 && i <= 48) alpha = 64; // second bottom-most row
|
||||
else alpha = 255;
|
||||
}
|
||||
|
||||
uint8 tmpR = static_cast<uint8>(255);
|
||||
uint8 tmpG = static_cast<uint8>(255);
|
||||
uint8 tmpB = static_cast<uint8>(255);
|
||||
uint8 tmpA = static_cast<uint8>(alpha);
|
||||
|
||||
// This does not matter since R and B are always 1.
|
||||
/*VertexElementType format = Root::getSingleton().getRenderSystem()->getColourVertexElementType();
|
||||
switch (format)
|
||||
{
|
||||
case VET_COLOUR_ARGB:
|
||||
std::swap(tmpR, tmpB);
|
||||
break;
|
||||
case VET_COLOUR_ABGR:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}*/
|
||||
|
||||
// Modify
|
||||
*((uint32*)currentVertex) = tmpR | (tmpG << 8) | (tmpB << 16) | (tmpA << 24);
|
||||
|
||||
// Move to the next vertex
|
||||
pData = static_cast<unsigned char *> (pData) + vertex_size;
|
||||
}
|
||||
|
||||
CaelumManager::~CaelumManager()
|
||||
// Unlock
|
||||
ent->getMesh()->getSubMesh(0)->vertexData->vertexBufferBinding->getBuffer(ves_diffuse->getSource())->unlock();
|
||||
}
|
||||
|
||||
SkyManager::SkyManager (SceneNode* pMwRoot, Camera* pCamera) :
|
||||
mGlareFade(0), mGlareEnabled(false)
|
||||
{
|
||||
mViewport = pCamera->getViewport();
|
||||
mSceneMgr = pMwRoot->getCreator();
|
||||
mRootNode = pCamera->getParentSceneNode()->createChildSceneNode();
|
||||
mRootNode->pitch(Degree(-90)); // convert MW to ogre coordinates
|
||||
mRootNode->setInheritOrientation(false);
|
||||
|
||||
/// \todo preload all the textures and meshes that are used for sky rendering
|
||||
|
||||
// Create overlay used for thunderstorm
|
||||
MaterialPtr material = MaterialManager::getSingleton().create( "ThunderMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
|
||||
Pass* pass = material->getTechnique(0)->getPass(0);
|
||||
pass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
mThunderTextureUnit = pass->createTextureUnitState();
|
||||
mThunderTextureUnit->setColourOperationEx(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, ColourValue(1.f, 1.f, 1.f)); // always black colour
|
||||
mThunderTextureUnit->setAlphaOperation(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, 0.5f);
|
||||
OverlayManager& ovm = OverlayManager::getSingleton();
|
||||
mThunderOverlay = ovm.create( "ThunderOverlay" );
|
||||
OverlayContainer* overlay_panel;
|
||||
overlay_panel = (OverlayContainer*)ovm.createOverlayElement("Panel", "ThunderPanel");
|
||||
overlay_panel->_setPosition(0, 0);
|
||||
overlay_panel->_setDimensions(1, 1);
|
||||
overlay_panel->setMaterialName( "ThunderMaterial" );
|
||||
overlay_panel->show();
|
||||
mThunderOverlay->add2D(overlay_panel);
|
||||
mThunderOverlay->hide();
|
||||
|
||||
mSecunda = new Moon("textures\\tx_secunda_full.dds", 0.5, Vector3(-0.4, 0.4, 0.5), mRootNode);
|
||||
mSecunda->setType(Moon::Type_Secunda);
|
||||
mSecunda->setRenderQueue(RENDER_QUEUE_SKIES_EARLY+4);
|
||||
|
||||
mMasser = new Moon("textures\\tx_masser_full.dds", 0.75, Vector3(-0.4, 0.4, 0.5), mRootNode);
|
||||
mMasser->setRenderQueue(RENDER_QUEUE_SKIES_EARLY+3);
|
||||
mMasser->setType(Moon::Type_Masser);
|
||||
|
||||
mSun = new BillboardObject("textures\\tx_sun_05.dds", 1, Vector3(0.4, 0.4, 0.4), mRootNode);
|
||||
mSunGlare = new BillboardObject("textures\\tx_sun_flash_grey_05.dds", 3, Vector3(0.4, 0.4, 0.4), mRootNode);
|
||||
mSunGlare->setRenderQueue(RENDER_QUEUE_SKIES_LATE);
|
||||
|
||||
|
||||
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
|
||||
|
||||
// Stars
|
||||
/// \todo sky_night_02.nif (available in Bloodmoon)
|
||||
MeshPtr mesh = NifOgre::NIFLoader::load("meshes\\sky_night_01.nif");
|
||||
Entity* night1_ent = mSceneMgr->createEntity("meshes\\sky_night_01.nif");
|
||||
night1_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+1);
|
||||
|
||||
mAtmosphereNight = mRootNode->createChildSceneNode();
|
||||
mAtmosphereNight->attachObject(night1_ent);
|
||||
|
||||
for (unsigned int i=0; i<night1_ent->getNumSubEntities(); ++i)
|
||||
{
|
||||
if (mpCaelumSystem)
|
||||
mpCaelumSystem->shutdown (false);
|
||||
MaterialPtr mp = night1_ent->getSubEntity(i)->getMaterial();
|
||||
mp->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
|
||||
mp->getTechnique(0)->getPass(0)->setAmbient(0.0, 0.0, 0.0);
|
||||
mp->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, 1.0);
|
||||
mp->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
|
||||
mp->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
|
||||
mp->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
|
||||
mStarsMaterials[i] = mp;
|
||||
}
|
||||
|
||||
/// Creates and connects the sky rendering component to OGRE.
|
||||
///
|
||||
/// \return NULL on failure.
|
||||
///
|
||||
SkyManager* SkyManager::create (Ogre::RenderWindow* pRenderWindow,
|
||||
Ogre::Camera* pCamera,
|
||||
const boost::filesystem::path& resDir)
|
||||
// Stars vertex shader
|
||||
HighLevelGpuProgramPtr vshader3 = mgr.createProgram("Stars_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_VERTEX_PROGRAM);
|
||||
vshader3->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader3->setParameter("entry_point", "main_vp");
|
||||
StringUtil::StrStreamType outStream4;
|
||||
outStream4 <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float2 oUV : TEXCOORD0, \n"
|
||||
" out float oFade : TEXCOORD1, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oUV = uv; \n"
|
||||
" oFade = (position.z > 50) ? 1.f : 0.f; \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
"}";
|
||||
vshader3->setSource(outStream4.str());
|
||||
vshader3->load();
|
||||
vshader3->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
night1_ent->getSubEntity(3)->getMaterial()->getTechnique(0)->getPass(0)->setVertexProgram(vshader3->getName());
|
||||
|
||||
// Stars fragment shader
|
||||
HighLevelGpuProgramPtr stars_fp = mgr.createProgram("Stars_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_FRAGMENT_PROGRAM);
|
||||
stars_fp->setParameter("profiles", "ps_2_x arbfp1");
|
||||
stars_fp->setParameter("entry_point", "main_fp");
|
||||
StringUtil::StrStreamType outStream5;
|
||||
outStream5 <<
|
||||
"void main_fp( \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" in float fade : TEXCOORD1, \n"
|
||||
" uniform sampler2D texture : TEXUNIT0, \n"
|
||||
" uniform float opacity, \n"
|
||||
" uniform float4 diffuse, \n"
|
||||
" uniform float4 emissive \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oColor = tex2D(texture, uv) * float4(emissive.xyz, 1) * float4(1,1,1,fade*diffuse.a); \n"
|
||||
"}";
|
||||
stars_fp->setSource(outStream5.str());
|
||||
stars_fp->load();
|
||||
stars_fp->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
stars_fp->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
|
||||
night1_ent->getSubEntity(3)->getMaterial()->getTechnique(0)->getPass(0)->setFragmentProgram(stars_fp->getName());
|
||||
|
||||
// Atmosphere (day)
|
||||
mesh = NifOgre::NIFLoader::load("meshes\\sky_atmosphere.nif");
|
||||
Entity* atmosphere_ent = mSceneMgr->createEntity("meshes\\sky_atmosphere.nif");
|
||||
|
||||
ModVertexAlpha(atmosphere_ent, 0);
|
||||
|
||||
atmosphere_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY);
|
||||
mAtmosphereDay = mRootNode->createChildSceneNode();
|
||||
mAtmosphereDay->attachObject(atmosphere_ent);
|
||||
mAtmosphereMaterial = atmosphere_ent->getSubEntity(0)->getMaterial();
|
||||
|
||||
// Atmosphere shader
|
||||
HighLevelGpuProgramPtr vshader = mgr.createProgram("Atmosphere_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_VERTEX_PROGRAM);
|
||||
|
||||
vshader->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader->setParameter("entry_point", "main_vp");
|
||||
|
||||
StringUtil::StrStreamType outStream;
|
||||
outStream <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float4 color : COLOR, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" uniform float4 emissive, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
" oColor = color * emissive; \n"
|
||||
"}";
|
||||
vshader->setSource(outStream.str());
|
||||
vshader->load();
|
||||
|
||||
vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
vshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
|
||||
|
||||
// Clouds
|
||||
NifOgre::NIFLoader::load("meshes\\sky_clouds_01.nif");
|
||||
Entity* clouds_ent = mSceneMgr->createEntity("meshes\\sky_clouds_01.nif");
|
||||
clouds_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+5);
|
||||
SceneNode* clouds_node = mRootNode->createChildSceneNode();
|
||||
clouds_node->attachObject(clouds_ent);
|
||||
mCloudMaterial = clouds_ent->getSubEntity(0)->getMaterial();
|
||||
|
||||
// Clouds vertex shader
|
||||
HighLevelGpuProgramPtr vshader2 = mgr.createProgram("Clouds_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_VERTEX_PROGRAM);
|
||||
vshader2->setParameter("profiles", "vs_2_x arbvp1");
|
||||
vshader2->setParameter("entry_point", "main_vp");
|
||||
StringUtil::StrStreamType outStream3;
|
||||
outStream3 <<
|
||||
"void main_vp( \n"
|
||||
" float4 position : POSITION, \n"
|
||||
" in float4 color : COLOR, \n"
|
||||
" out float4 oColor : TEXCOORD1, \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float2 oUV : TEXCOORD0, \n"
|
||||
" out float4 oPosition : POSITION, \n"
|
||||
" uniform float4x4 worldViewProj \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" oUV = uv; \n"
|
||||
" oColor = color; \n"
|
||||
" oPosition = mul( worldViewProj, position ); \n"
|
||||
"}";
|
||||
vshader2->setSource(outStream3.str());
|
||||
vshader2->load();
|
||||
vshader2->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader2->getName());
|
||||
|
||||
// Clouds fragment shader
|
||||
mCloudFragmentShader = mgr.createProgram("Clouds_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
|
||||
"cg", GPT_FRAGMENT_PROGRAM);
|
||||
mCloudFragmentShader->setParameter("profiles", "ps_2_x arbfp1");
|
||||
mCloudFragmentShader->setParameter("entry_point", "main_fp");
|
||||
StringUtil::StrStreamType outStream2;
|
||||
outStream2 <<
|
||||
"void main_fp( \n"
|
||||
" in float2 uv : TEXCOORD0, \n"
|
||||
" out float4 oColor : COLOR, \n"
|
||||
" in float4 color : TEXCOORD1, \n"
|
||||
" uniform sampler2D texture : TEXUNIT0, \n"
|
||||
" uniform sampler2D secondTexture : TEXUNIT1, \n"
|
||||
" uniform float transitionFactor, \n"
|
||||
" uniform float time, \n"
|
||||
" uniform float speed, \n"
|
||||
" uniform float opacity, \n"
|
||||
" uniform float4 emissive \n"
|
||||
") \n"
|
||||
"{ \n"
|
||||
" uv += float2(1,1) * time * speed * "<<CLOUD_SPEED<<"; \n" // Scroll in x,y direction
|
||||
" float4 tex = lerp(tex2D(texture, uv), tex2D(secondTexture, uv), transitionFactor); \n"
|
||||
" oColor = color * float4(emissive.xyz,1) * tex * float4(1,1,1,opacity); \n"
|
||||
"}";
|
||||
mCloudFragmentShader->setSource(outStream2.str());
|
||||
mCloudFragmentShader->load();
|
||||
mCloudFragmentShader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(mCloudFragmentShader->getName());
|
||||
setCloudsOpacity(0.75);
|
||||
|
||||
ModVertexAlpha(clouds_ent, 1);
|
||||
|
||||
// I'm not sure if the materials are being used by any other objects
|
||||
// Make a unique "modifiable" copy of the materials to be sure
|
||||
mCloudMaterial = mCloudMaterial->clone("Clouds");
|
||||
clouds_ent->getSubEntity(0)->setMaterial(mCloudMaterial);
|
||||
mAtmosphereMaterial = mAtmosphereMaterial->clone("Atmosphere");
|
||||
atmosphere_ent->getSubEntity(0)->setMaterial(mAtmosphereMaterial);
|
||||
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, 0.0);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setAmbient(0.0, 0.0, 0.0);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
|
||||
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->createTextureUnitState("");
|
||||
}
|
||||
|
||||
SkyManager::~SkyManager()
|
||||
{
|
||||
delete mSun;
|
||||
delete mSunGlare;
|
||||
delete mMasser;
|
||||
delete mSecunda;
|
||||
}
|
||||
|
||||
int SkyManager::getMasserPhase() const
|
||||
{
|
||||
return mMasser->getPhaseInt();
|
||||
}
|
||||
|
||||
int SkyManager::getSecundaPhase() const
|
||||
{
|
||||
return mSecunda->getPhaseInt();
|
||||
}
|
||||
|
||||
void SkyManager::update(float duration)
|
||||
{
|
||||
if (!mEnabled) return;
|
||||
|
||||
// UV Scroll the clouds
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstantFromTime("time", 1);
|
||||
|
||||
/// \todo improve this
|
||||
mMasser->setPhase( static_cast<Moon::Phase>( (int) ((mDay % 32)/4.f)) );
|
||||
mSecunda->setPhase ( static_cast<Moon::Phase>( (int) ((mDay % 32)/4.f)) );
|
||||
|
||||
// increase the strength of the sun glare effect depending
|
||||
// on how directly the player is looking at the sun
|
||||
if (mSunEnabled)
|
||||
{
|
||||
SkyManager* pSkyManager = NULL;
|
||||
Vector3 sun = mSunGlare->getPosition();
|
||||
sun = Vector3(sun.x, sun.z, -sun.y);
|
||||
Vector3 cam = mViewport->getCamera()->getRealDirection();
|
||||
const Degree angle = sun.angleBetween( cam );
|
||||
float val = 1- (angle.valueDegrees() / 180.f);
|
||||
val = (val*val*val*val)*2;
|
||||
|
||||
try
|
||||
if (mGlareEnabled)
|
||||
{
|
||||
pSkyManager = new CaelumManager(pRenderWindow, pCamera, resDir);
|
||||
mGlareFade += duration*3;
|
||||
if (mGlareFade > 1) mGlareFade = 1;
|
||||
}
|
||||
catch (Ogre::Exception& e)
|
||||
else
|
||||
{
|
||||
std::cout << "\nOGRE Exception when attempting to add sky: "
|
||||
<< e.getFullDescription().c_str() << std::endl;
|
||||
mGlareFade -= duration*3;
|
||||
if (mGlareFade < 0.3) mGlareFade = 0;
|
||||
}
|
||||
catch (std::exception& e)
|
||||
|
||||
mSunGlare->setSize(val * (mGlareFade));
|
||||
}
|
||||
|
||||
mSunGlare->setVisible(mGlareFade>0 && mSunEnabled);
|
||||
mSun->setVisible(mSunEnabled);
|
||||
mMasser->setVisible(mMasserEnabled);
|
||||
mSecunda->setVisible(mSecundaEnabled);
|
||||
}
|
||||
|
||||
void SkyManager::enable()
|
||||
{
|
||||
mRootNode->setVisible(true);
|
||||
mEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::disable()
|
||||
{
|
||||
mRootNode->setVisible(false);
|
||||
mEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::setMoonColour (bool red)
|
||||
{
|
||||
mSecunda->setColour( red ? ColourValue(1.0, 0.0784, 0.0784)
|
||||
: ColourValue(1.0, 1.0, 1.0));
|
||||
}
|
||||
|
||||
void SkyManager::setCloudsOpacity(float opacity)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("opacity", Real(opacity));
|
||||
}
|
||||
|
||||
void SkyManager::setWeather(const MWWorld::WeatherResult& weather)
|
||||
{
|
||||
if (mClouds != weather.mCloudTexture)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName("textures\\"+weather.mCloudTexture);
|
||||
mClouds = weather.mCloudTexture;
|
||||
}
|
||||
|
||||
if (mNextClouds != weather.mNextCloudTexture)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(1)->setTextureName("textures\\"+weather.mNextCloudTexture);
|
||||
mNextClouds = weather.mNextCloudTexture;
|
||||
}
|
||||
|
||||
if (mCloudBlendFactor != weather.mCloudBlendFactor)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("transitionFactor", Real(weather.mCloudBlendFactor));
|
||||
mCloudBlendFactor = weather.mCloudBlendFactor;
|
||||
}
|
||||
|
||||
if (mCloudOpacity != weather.mCloudOpacity)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("opacity", Real(weather.mCloudOpacity));
|
||||
mCloudOpacity = weather.mCloudOpacity;
|
||||
}
|
||||
|
||||
if (mCloudColour != weather.mSunColor)
|
||||
{
|
||||
ColourValue clr( weather.mSunColor.r*0.7 + weather.mAmbientColor.r*0.7,
|
||||
weather.mSunColor.g*0.7 + weather.mAmbientColor.g*0.7,
|
||||
weather.mSunColor.b*0.7 + weather.mAmbientColor.b*0.7);
|
||||
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(clr);
|
||||
mCloudColour = weather.mSunColor;
|
||||
}
|
||||
|
||||
if (mSkyColour != weather.mSkyColor)
|
||||
{
|
||||
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(weather.mSkyColor);
|
||||
mSkyColour = weather.mSkyColor;
|
||||
}
|
||||
|
||||
if (mCloudSpeed != weather.mCloudSpeed)
|
||||
{
|
||||
mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("speed", Real(weather.mCloudSpeed));
|
||||
mCloudSpeed = weather.mCloudSpeed;
|
||||
}
|
||||
|
||||
if (weather.mNight && mStarsOpacity != weather.mNightFade)
|
||||
{
|
||||
if (weather.mNightFade == 0)
|
||||
mAtmosphereNight->setVisible(false);
|
||||
else
|
||||
{
|
||||
std::cout << "\nException when attempting to add sky: "
|
||||
<< e.what() << std::endl;
|
||||
mAtmosphereNight->setVisible(true);
|
||||
for (int i=0; i<7; ++i)
|
||||
mStarsMaterials[i]->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, weather.mNightFade);
|
||||
mStarsOpacity = weather.mNightFade;
|
||||
}
|
||||
}
|
||||
|
||||
float strength;
|
||||
float timeofday_angle = std::abs(mSunGlare->getPosition().z/mSunGlare->getPosition().length());
|
||||
if (timeofday_angle <= 0.44)
|
||||
strength = timeofday_angle/0.44f;
|
||||
else
|
||||
strength = 1.f;
|
||||
|
||||
mSunGlare->setVisibility(weather.mGlareView * strength);
|
||||
|
||||
mAtmosphereNight->setVisible(weather.mNight && mEnabled);
|
||||
}
|
||||
|
||||
void SkyManager::setGlare(bool glare)
|
||||
{
|
||||
mGlareEnabled = glare;
|
||||
}
|
||||
|
||||
Vector3 SkyManager::getRealSunPos()
|
||||
{
|
||||
return mSun->getNode()->_getDerivedPosition();
|
||||
}
|
||||
|
||||
void SkyManager::sunEnable()
|
||||
{
|
||||
mSunEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::sunDisable()
|
||||
{
|
||||
mSunEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::setSunDirection(const Vector3& direction)
|
||||
{
|
||||
mSun->setPosition(direction);
|
||||
mSunGlare->setPosition(direction);
|
||||
}
|
||||
|
||||
return pSkyManager;
|
||||
void SkyManager::setMasserDirection(const Vector3& direction)
|
||||
{
|
||||
mMasser->setPosition(direction);
|
||||
}
|
||||
|
||||
void SkyManager::setSecundaDirection(const Vector3& direction)
|
||||
{
|
||||
mSecunda->setPosition(direction);
|
||||
}
|
||||
|
||||
void SkyManager::masserEnable()
|
||||
{
|
||||
mMasserEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::secundaEnable()
|
||||
{
|
||||
mSecundaEnabled = true;
|
||||
}
|
||||
|
||||
void SkyManager::masserDisable()
|
||||
{
|
||||
mMasserEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::secundaDisable()
|
||||
{
|
||||
mSecundaEnabled = false;
|
||||
}
|
||||
|
||||
void SkyManager::setThunder(const float factor)
|
||||
{
|
||||
if (factor > 0.f)
|
||||
{
|
||||
mThunderOverlay->show();
|
||||
mThunderTextureUnit->setAlphaOperation(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, factor*0.6);
|
||||
}
|
||||
}
|
||||
else
|
||||
mThunderOverlay->hide();
|
||||
}
|
||||
|
||||
void SkyManager::setMasserFade(const float fade)
|
||||
{
|
||||
mMasser->setVisibility(fade);
|
||||
}
|
||||
|
||||
void SkyManager::setSecundaFade(const float fade)
|
||||
{
|
||||
mSecunda->setVisibility(fade);
|
||||
}
|
||||
|
||||
void SkyManager::setHour(double hour)
|
||||
{
|
||||
mHour = hour;
|
||||
}
|
||||
|
||||
void SkyManager::setDate(int day, int month)
|
||||
{
|
||||
mDay = day;
|
||||
mMonth = month;
|
||||
}
|
||||
|
||||
@ -0,0 +1,342 @@
|
||||
|
||||
#include "containerstore.hpp"
|
||||
|
||||
#include <cassert>
|
||||
#include <typeinfo>
|
||||
#include <stdexcept>
|
||||
|
||||
MWWorld::ContainerStoreIterator MWWorld::ContainerStore::begin (int mask)
|
||||
{
|
||||
return ContainerStoreIterator (mask, this);
|
||||
}
|
||||
|
||||
MWWorld::ContainerStoreIterator MWWorld::ContainerStore::end()
|
||||
{
|
||||
return ContainerStoreIterator (this);
|
||||
}
|
||||
|
||||
void MWWorld::ContainerStore::add (const Ptr& ptr)
|
||||
{
|
||||
/// \todo implement item stocking
|
||||
|
||||
switch (getType (ptr))
|
||||
{
|
||||
case Type_Potion: potions.list.push_back (*ptr.get<ESM::Potion>()); break;
|
||||
case Type_Apparatus: appas.list.push_back (*ptr.get<ESM::Apparatus>()); break;
|
||||
case Type_Armor: armors.list.push_back (*ptr.get<ESM::Armor>()); break;
|
||||
case Type_Book: books.list.push_back (*ptr.get<ESM::Book>()); break;
|
||||
case Type_Clothing: clothes.list.push_back (*ptr.get<ESM::Clothing>()); break;
|
||||
case Type_Ingredient: ingreds.list.push_back (*ptr.get<ESM::Ingredient>()); break;
|
||||
case Type_Light: lights.list.push_back (*ptr.get<ESM::Light>()); break;
|
||||
case Type_Lockpick: lockpicks.list.push_back (*ptr.get<ESM::Tool>()); break;
|
||||
case Type_Miscellaneous: miscItems.list.push_back (*ptr.get<ESM::Miscellaneous>()); break;
|
||||
case Type_Probe: probes.list.push_back (*ptr.get<ESM::Probe>()); break;
|
||||
case Type_Repair: repairs.list.push_back (*ptr.get<ESM::Repair>()); break;
|
||||
case Type_Weapon: weapons.list.push_back (*ptr.get<ESM::Weapon>()); break;
|
||||
}
|
||||
}
|
||||
|
||||
int MWWorld::ContainerStore::getType (const Ptr& ptr)
|
||||
{
|
||||
if (ptr.isEmpty())
|
||||
throw std::runtime_error ("can't put a non-existent object into a container");
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Potion).name())
|
||||
return Type_Potion;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Apparatus).name())
|
||||
return Type_Apparatus;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Armor).name())
|
||||
return Type_Armor;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Book).name())
|
||||
return Type_Book;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Clothing).name())
|
||||
return Type_Clothing;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Ingredient).name())
|
||||
return Type_Ingredient;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Light).name())
|
||||
return Type_Light;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Tool).name())
|
||||
return Type_Lockpick;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Miscellaneous).name())
|
||||
return Type_Miscellaneous;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Probe).name())
|
||||
return Type_Probe;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Repair).name())
|
||||
return Type_Repair;
|
||||
|
||||
if (ptr.getTypeName()==typeid (ESM::Weapon).name())
|
||||
return Type_Weapon;
|
||||
|
||||
throw std::runtime_error (
|
||||
"Object of type " + ptr.getTypeName() + " can not be placed into a container");
|
||||
}
|
||||
|
||||
|
||||
MWWorld::ContainerStoreIterator::ContainerStoreIterator (ContainerStore *container)
|
||||
: mType (-1), mMask (0), mContainer (container)
|
||||
{}
|
||||
|
||||
MWWorld::ContainerStoreIterator::ContainerStoreIterator (int mask, ContainerStore *container)
|
||||
: mType (0), mMask (mask), mContainer (container)
|
||||
{
|
||||
nextType();
|
||||
}
|
||||
|
||||
void MWWorld::ContainerStoreIterator::incType()
|
||||
{
|
||||
if (mType==0)
|
||||
mType = 1;
|
||||
else if (mType!=-1)
|
||||
{
|
||||
mType <<= 1;
|
||||
|
||||
if (mType>ContainerStore::Type_Last)
|
||||
mType = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void MWWorld::ContainerStoreIterator::nextType()
|
||||
{
|
||||
while (mType!=-1)
|
||||
{
|
||||
incType();
|
||||
|
||||
if (mType & mMask)
|
||||
if (resetIterator())
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool MWWorld::ContainerStoreIterator::resetIterator()
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case ContainerStore::Type_Potion:
|
||||
|
||||
mPotion = mContainer->potions.list.begin();
|
||||
return mPotion!=mContainer->potions.list.end();
|
||||
|
||||
case ContainerStore::Type_Apparatus:
|
||||
|
||||
mApparatus = mContainer->appas.list.begin();
|
||||
return mApparatus!=mContainer->appas.list.end();
|
||||
|
||||
case ContainerStore::Type_Armor:
|
||||
|
||||
mArmor = mContainer->armors.list.begin();
|
||||
return mArmor!=mContainer->armors.list.end();
|
||||
|
||||
case ContainerStore::Type_Book:
|
||||
|
||||
mBook = mContainer->books.list.begin();
|
||||
return mBook!=mContainer->books.list.end();
|
||||
|
||||
case ContainerStore::Type_Clothing:
|
||||
|
||||
mClothing = mContainer->clothes.list.begin();
|
||||
return mClothing!=mContainer->clothes.list.end();
|
||||
|
||||
case ContainerStore::Type_Ingredient:
|
||||
|
||||
mIngredient = mContainer->ingreds.list.begin();
|
||||
return mIngredient!=mContainer->ingreds.list.end();
|
||||
|
||||
case ContainerStore::Type_Light:
|
||||
|
||||
mLight = mContainer->lights.list.begin();
|
||||
return mLight!=mContainer->lights.list.end();
|
||||
|
||||
case ContainerStore::Type_Lockpick:
|
||||
|
||||
mLockpick = mContainer->lockpicks.list.begin();
|
||||
return mLockpick!=mContainer->lockpicks.list.end();
|
||||
|
||||
case ContainerStore::Type_Miscellaneous:
|
||||
|
||||
mMiscellaneous = mContainer->miscItems.list.begin();
|
||||
return mMiscellaneous!=mContainer->miscItems.list.end();
|
||||
|
||||
case ContainerStore::Type_Probe:
|
||||
|
||||
mProbe = mContainer->probes.list.begin();
|
||||
return mProbe!=mContainer->probes.list.end();
|
||||
|
||||
case ContainerStore::Type_Repair:
|
||||
|
||||
mRepair = mContainer->repairs.list.begin();
|
||||
return mRepair!=mContainer->repairs.list.end();
|
||||
|
||||
case ContainerStore::Type_Weapon:
|
||||
|
||||
mWeapon = mContainer->weapons.list.begin();
|
||||
return mWeapon!=mContainer->weapons.list.end();
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool MWWorld::ContainerStoreIterator::incIterator()
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case ContainerStore::Type_Potion:
|
||||
|
||||
++mPotion;
|
||||
return mPotion==mContainer->potions.list.end();
|
||||
|
||||
case ContainerStore::Type_Apparatus:
|
||||
|
||||
++mApparatus;
|
||||
return mApparatus==mContainer->appas.list.end();
|
||||
|
||||
case ContainerStore::Type_Armor:
|
||||
|
||||
++mArmor;
|
||||
return mArmor==mContainer->armors.list.end();
|
||||
|
||||
case ContainerStore::Type_Book:
|
||||
|
||||
++mBook;
|
||||
return mBook==mContainer->books.list.end();
|
||||
|
||||
case ContainerStore::Type_Clothing:
|
||||
|
||||
++mClothing;
|
||||
return mClothing==mContainer->clothes.list.end();
|
||||
|
||||
case ContainerStore::Type_Ingredient:
|
||||
|
||||
++mIngredient;
|
||||
return mIngredient==mContainer->ingreds.list.end();
|
||||
|
||||
case ContainerStore::Type_Light:
|
||||
|
||||
++mLight;
|
||||
return mLight==mContainer->lights.list.end();
|
||||
|
||||
case ContainerStore::Type_Lockpick:
|
||||
|
||||
++mLockpick;
|
||||
return mLockpick==mContainer->lockpicks.list.end();
|
||||
|
||||
case ContainerStore::Type_Miscellaneous:
|
||||
|
||||
++mMiscellaneous;
|
||||
return mMiscellaneous==mContainer->miscItems.list.end();
|
||||
|
||||
case ContainerStore::Type_Probe:
|
||||
|
||||
++mProbe;
|
||||
return mProbe==mContainer->probes.list.end();
|
||||
|
||||
case ContainerStore::Type_Repair:
|
||||
|
||||
++mRepair;
|
||||
return mRepair==mContainer->repairs.list.end();
|
||||
|
||||
case ContainerStore::Type_Weapon:
|
||||
|
||||
++mWeapon;
|
||||
return mWeapon==mContainer->weapons.list.end();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
MWWorld::Ptr *MWWorld::ContainerStoreIterator::operator->() const
|
||||
{
|
||||
mPtr = **this;
|
||||
return &mPtr;
|
||||
}
|
||||
|
||||
MWWorld::Ptr MWWorld::ContainerStoreIterator::operator*() const
|
||||
{
|
||||
switch (mType)
|
||||
{
|
||||
case ContainerStore::Type_Potion: return MWWorld::Ptr (&*mPotion, 0);
|
||||
case ContainerStore::Type_Apparatus: return MWWorld::Ptr (&*mApparatus, 0);
|
||||
case ContainerStore::Type_Armor: return MWWorld::Ptr (&*mArmor, 0);
|
||||
case ContainerStore::Type_Book: return MWWorld::Ptr (&*mBook, 0);
|
||||
case ContainerStore::Type_Clothing: return MWWorld::Ptr (&*mClothing, 0);
|
||||
case ContainerStore::Type_Ingredient: return MWWorld::Ptr (&*mIngredient, 0);
|
||||
case ContainerStore::Type_Light: return MWWorld::Ptr (&*mLight, 0);
|
||||
case ContainerStore::Type_Lockpick: return MWWorld::Ptr (&*mLockpick, 0);
|
||||
case ContainerStore::Type_Miscellaneous: return MWWorld::Ptr (&*mMiscellaneous, 0);
|
||||
case ContainerStore::Type_Probe: return MWWorld::Ptr (&*mProbe, 0);
|
||||
case ContainerStore::Type_Repair: return MWWorld::Ptr (&*mRepair, 0);
|
||||
case ContainerStore::Type_Weapon: return MWWorld::Ptr (&*mWeapon, 0);
|
||||
}
|
||||
|
||||
throw std::runtime_error ("invalid pointer");
|
||||
}
|
||||
|
||||
MWWorld::ContainerStoreIterator& MWWorld::ContainerStoreIterator::operator++()
|
||||
{
|
||||
do
|
||||
{
|
||||
if (incIterator())
|
||||
nextType();
|
||||
}
|
||||
while (mType!=-1 && !(**this).getRefData().getCount());
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
MWWorld::ContainerStoreIterator MWWorld::ContainerStoreIterator::operator++ (int)
|
||||
{
|
||||
ContainerStoreIterator iter (*this);
|
||||
++*this;
|
||||
return iter;
|
||||
}
|
||||
|
||||
bool MWWorld::ContainerStoreIterator::isEqual (const ContainerStoreIterator& iter) const
|
||||
{
|
||||
assert (mContainer==iter.mContainer);
|
||||
|
||||
if (mType!=iter.mType)
|
||||
return false;
|
||||
|
||||
switch (mType)
|
||||
{
|
||||
case ContainerStore::Type_Potion: return mPotion==iter.mPotion;
|
||||
case ContainerStore::Type_Apparatus: return mApparatus==iter.mApparatus;
|
||||
case ContainerStore::Type_Armor: return mArmor==iter.mArmor;
|
||||
case ContainerStore::Type_Book: return mBook==iter.mBook;
|
||||
case ContainerStore::Type_Clothing: return mClothing==iter.mClothing;
|
||||
case ContainerStore::Type_Ingredient: return mIngredient==iter.mIngredient;
|
||||
case ContainerStore::Type_Light: return mLight==iter.mLight;
|
||||
case ContainerStore::Type_Lockpick: return mLockpick==iter.mLockpick;
|
||||
case ContainerStore::Type_Miscellaneous: return mMiscellaneous==iter.mMiscellaneous;
|
||||
case ContainerStore::Type_Probe: return mProbe==iter.mProbe;
|
||||
case ContainerStore::Type_Repair: return mRepair==iter.mRepair;
|
||||
case ContainerStore::Type_Weapon: return mWeapon==iter.mWeapon;
|
||||
case -1: return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
int MWWorld::ContainerStoreIterator::getType() const
|
||||
{
|
||||
return mType;
|
||||
}
|
||||
|
||||
bool MWWorld::operator== (const ContainerStoreIterator& left, const ContainerStoreIterator& right)
|
||||
{
|
||||
return left.isEqual (right);
|
||||
}
|
||||
|
||||
bool MWWorld::operator!= (const ContainerStoreIterator& left, const ContainerStoreIterator& right)
|
||||
{
|
||||
return !(left==right);
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
|
||||
#include "containerutil.hpp"
|
||||
|
||||
namespace
|
||||
{
|
||||
template<typename T>
|
||||
void listItemsInContainerImp (const std::string& id,
|
||||
ESMS::CellRefList<T, MWWorld::RefData>& containerStore,
|
||||
const ESMS::RecListT<T>& store, std::vector<MWWorld::Ptr>& list)
|
||||
{
|
||||
if (const T *record = store.search (id))
|
||||
{
|
||||
for (typename ESMS::CellRefList<T, MWWorld::RefData>::List::iterator iter
|
||||
(containerStore.list.begin());
|
||||
iter!=containerStore.list.end(); ++iter)
|
||||
{
|
||||
if (iter->base==record)
|
||||
list.push_back (MWWorld::Ptr (&*iter, 0));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
void listItemsInContainer (const std::string& id,
|
||||
ContainerStore<MWWorld::RefData>& containerStore,
|
||||
const ESMS::ESMStore& store, std::vector<Ptr>& list)
|
||||
{
|
||||
listItemsInContainerImp (id, containerStore.potions, store.potions, list);
|
||||
listItemsInContainerImp (id, containerStore.appas, store.appas, list);
|
||||
listItemsInContainerImp (id, containerStore.armors, store.armors, list);
|
||||
listItemsInContainerImp (id, containerStore.books, store.books, list);
|
||||
listItemsInContainerImp (id, containerStore.clothes, store.clothes, list);
|
||||
listItemsInContainerImp (id, containerStore.ingreds, store.ingreds, list);
|
||||
listItemsInContainerImp (id, containerStore.lights, store.lights, list);
|
||||
listItemsInContainerImp (id, containerStore.lockpicks, store.lockpicks, list);
|
||||
listItemsInContainerImp (id, containerStore.miscItems, store.miscItems, list);
|
||||
listItemsInContainerImp (id, containerStore.probes, store.probes, list);
|
||||
listItemsInContainerImp (id, containerStore.repairs, store.repairs, list);
|
||||
listItemsInContainerImp (id, containerStore.weapons, store.weapons, list);
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
#ifndef GAME_MWWORLD_CONTAINERUTIL_H
|
||||
#define GAME_MWWORLD_CONTAINERUTIL_H
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <components/esm_store/store.hpp>
|
||||
|
||||
#include "containerstore.hpp"
|
||||
#include "ptr.hpp"
|
||||
#include "refdata.hpp"
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
void listItemsInContainer (const std::string& id, ContainerStore<MWWorld::RefData>& containerStore,
|
||||
const ESMS::ESMStore& store, std::vector<Ptr>& list);
|
||||
///< append all references with the given id to list.
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,17 @@
|
||||
#ifndef GAME_MWWORLD_CUSTOMDATA_H
|
||||
#define GAME_MWWORLD_CUSTOMDATA_H
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
/// \brief Base class for the MW-class-specific part of RefData
|
||||
class CustomData
|
||||
{
|
||||
public:
|
||||
|
||||
virtual ~CustomData() {}
|
||||
|
||||
virtual CustomData *clone() const = 0;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,144 @@
|
||||
|
||||
#include "refdata.hpp"
|
||||
|
||||
#include <components/esm_store/cell_store.hpp>
|
||||
|
||||
#include "customdata.hpp"
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
void RefData::copy (const RefData& refData)
|
||||
{
|
||||
mBaseNode = refData.mBaseNode;
|
||||
mLocals = refData.mLocals;
|
||||
mHasLocals = refData.mHasLocals;
|
||||
mEnabled = refData.mEnabled;
|
||||
mCount = refData.mCount;
|
||||
mPosition = refData.mPosition;
|
||||
|
||||
mCustomData = refData.mCustomData ? refData.mCustomData->clone() : 0;
|
||||
}
|
||||
|
||||
void RefData::cleanup()
|
||||
{
|
||||
mBaseNode = 0;
|
||||
|
||||
delete mCustomData;
|
||||
mCustomData = 0;
|
||||
}
|
||||
|
||||
RefData::RefData (const ESM::CellRef& cellRef)
|
||||
: mBaseNode(0), mHasLocals (false), mEnabled (true), mCount (1), mPosition (cellRef.pos),
|
||||
mCustomData (0)
|
||||
{}
|
||||
|
||||
RefData::RefData (const RefData& refData)
|
||||
: mBaseNode(0), mCustomData (0)
|
||||
{
|
||||
try
|
||||
{
|
||||
copy (refData);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
cleanup();
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
RefData& RefData::operator= (const RefData& refData)
|
||||
{
|
||||
try
|
||||
{
|
||||
cleanup();
|
||||
copy (refData);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
cleanup();
|
||||
throw;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
RefData::~RefData()
|
||||
{
|
||||
try
|
||||
{
|
||||
cleanup();
|
||||
}
|
||||
catch (...)
|
||||
{}
|
||||
}
|
||||
|
||||
std::string RefData::getHandle()
|
||||
{
|
||||
return mBaseNode->getName();
|
||||
}
|
||||
|
||||
Ogre::SceneNode* RefData::getBaseNode()
|
||||
{
|
||||
return mBaseNode;
|
||||
}
|
||||
|
||||
void RefData::setBaseNode(Ogre::SceneNode* base)
|
||||
{
|
||||
mBaseNode = base;
|
||||
}
|
||||
|
||||
int RefData::getCount() const
|
||||
{
|
||||
return mCount;
|
||||
}
|
||||
|
||||
void RefData::setLocals (const ESM::Script& script)
|
||||
{
|
||||
if (!mHasLocals)
|
||||
{
|
||||
mLocals.configure (script);
|
||||
mHasLocals = true;
|
||||
}
|
||||
}
|
||||
|
||||
void RefData::setCount (int count)
|
||||
{
|
||||
mCount = count;
|
||||
}
|
||||
|
||||
MWScript::Locals& RefData::getLocals()
|
||||
{
|
||||
return mLocals;
|
||||
}
|
||||
|
||||
bool RefData::isEnabled() const
|
||||
{
|
||||
return mEnabled;
|
||||
}
|
||||
|
||||
void RefData::enable()
|
||||
{
|
||||
mEnabled = true;
|
||||
}
|
||||
|
||||
void RefData::disable()
|
||||
{
|
||||
mEnabled = true;
|
||||
}
|
||||
|
||||
ESM::Position& RefData::getPosition()
|
||||
{
|
||||
return mPosition;
|
||||
}
|
||||
|
||||
void RefData::setCustomData (CustomData *data)
|
||||
{
|
||||
delete mCustomData;
|
||||
mCustomData = data;
|
||||
}
|
||||
|
||||
CustomData *RefData::getCustomData()
|
||||
{
|
||||
return mCustomData;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,803 @@
|
||||
#include "weather.hpp"
|
||||
#include "world.hpp"
|
||||
#include "player.hpp"
|
||||
|
||||
#include "../mwrender/renderingmanager.hpp"
|
||||
#include "../mwsound/soundmanager.hpp"
|
||||
|
||||
#include <ctime>
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
|
||||
using namespace Ogre;
|
||||
using namespace MWWorld;
|
||||
using namespace MWSound;
|
||||
|
||||
#define lerp(x, y) (x * (1-factor) + y * factor)
|
||||
|
||||
const std::string WeatherGlobals::mThunderSoundID0 = "Thunder0";
|
||||
const std::string WeatherGlobals::mThunderSoundID1 = "Thunder1";
|
||||
const std::string WeatherGlobals::mThunderSoundID2 = "Thunder2";
|
||||
const std::string WeatherGlobals::mThunderSoundID3 = "Thunder3";
|
||||
|
||||
WeatherManager::WeatherManager(MWRender::RenderingManager* rendering, Environment* env) :
|
||||
mHour(14), mCurrentWeather("clear"), mFirstUpdate(true), mWeatherUpdateTime(0),
|
||||
mThunderFlash(0), mThunderChance(0), mThunderChanceNeeded(50), mThunderSoundDelay(0)
|
||||
{
|
||||
mRendering = rendering;
|
||||
mEnvironment = env;
|
||||
|
||||
#define clr(r,g,b) ColourValue(r/255.f, g/255.f, b/255.f)
|
||||
|
||||
/// \todo read these from Morrowind.ini
|
||||
Weather clear;
|
||||
clear.mCloudTexture = "tx_sky_clear.dds";
|
||||
clear.mCloudsMaximumPercent = 1.0;
|
||||
clear.mTransitionDelta = 0.015;
|
||||
clear.mSkySunriseColor = clr(118, 141, 164);
|
||||
clear.mSkyDayColor = clr(95, 135, 203);
|
||||
clear.mSkySunsetColor = clr(56, 89, 129);
|
||||
clear.mSkyNightColor = clr(9, 10, 11);
|
||||
clear.mFogSunriseColor = clr(255, 189, 157);
|
||||
clear.mFogDayColor = clr(206, 227, 255);
|
||||
clear.mFogSunsetColor = clr(255, 189, 157);
|
||||
clear.mFogNightColor = clr(9, 10, 11);
|
||||
clear.mAmbientSunriseColor = clr(47, 66, 96);
|
||||
clear.mAmbientDayColor = clr(137, 140, 160);
|
||||
clear.mAmbientSunsetColor = clr(68, 75, 96);
|
||||
clear.mAmbientNightColor = clr(32, 35, 42);
|
||||
clear.mSunSunriseColor = clr(242, 159, 99);
|
||||
clear.mSunDayColor = clr(255, 252, 238);
|
||||
clear.mSunSunsetColor = clr(255, 115, 79);
|
||||
clear.mSunNightColor = clr(59, 97, 176);
|
||||
clear.mSunDiscSunsetColor = clr(255, 189, 157);
|
||||
clear.mLandFogDayDepth = 0.69;
|
||||
clear.mLandFogNightDepth = 0.69;
|
||||
clear.mWindSpeed = 0.1;
|
||||
clear.mCloudSpeed = 1.25;
|
||||
clear.mGlareView = 1.0;
|
||||
mWeatherSettings["clear"] = clear;
|
||||
|
||||
Weather cloudy;
|
||||
cloudy.mCloudTexture = "tx_sky_cloudy.dds";
|
||||
cloudy.mCloudsMaximumPercent = 1.0;
|
||||
cloudy.mTransitionDelta = 0.015;
|
||||
cloudy.mSkySunriseColor = clr(126, 158, 173);
|
||||
cloudy.mSkyDayColor = clr(117, 160, 215);
|
||||
cloudy.mSkySunsetColor = clr(111, 114, 159);
|
||||
cloudy.mSkyNightColor = clr(9, 10, 11);
|
||||
cloudy.mFogSunriseColor = clr(255, 207, 149);
|
||||
cloudy.mFogDayColor = clr(245, 235, 224);
|
||||
cloudy.mFogSunsetColor = clr(255, 155, 106);
|
||||
cloudy.mFogNightColor = clr(9, 10, 11);
|
||||
cloudy.mAmbientSunriseColor = clr(66, 74, 87);
|
||||
cloudy.mAmbientDayColor = clr(137, 145, 160);
|
||||
cloudy.mAmbientSunsetColor = clr(71, 80, 92);
|
||||
cloudy.mAmbientNightColor = clr(32, 39, 54);
|
||||
cloudy.mSunSunriseColor = clr(241, 177, 99);
|
||||
cloudy.mSunDayColor = clr(255, 236, 221);
|
||||
cloudy.mSunSunsetColor = clr(255, 89, 00);
|
||||
cloudy.mSunNightColor = clr(77, 91, 124);
|
||||
cloudy.mSunDiscSunsetColor = clr(255, 202, 179);
|
||||
cloudy.mLandFogDayDepth = 0.72;
|
||||
cloudy.mLandFogNightDepth = 0.72;
|
||||
cloudy.mWindSpeed = 0.2;
|
||||
cloudy.mCloudSpeed = 2;
|
||||
cloudy.mGlareView = 1.0;
|
||||
mWeatherSettings["cloudy"] = cloudy;
|
||||
|
||||
Weather foggy;
|
||||
foggy.mCloudTexture = "tx_sky_foggy.dds";
|
||||
foggy.mCloudsMaximumPercent = 1.0;
|
||||
foggy.mTransitionDelta = 0.015;
|
||||
foggy.mSkySunriseColor = clr(197, 190, 180);
|
||||
foggy.mSkyDayColor = clr(184, 211, 228);
|
||||
foggy.mSkySunsetColor = clr(142, 159, 176);
|
||||
foggy.mSkyNightColor = clr(18, 23, 28);
|
||||
foggy.mFogSunriseColor = clr(173, 164, 148);
|
||||
foggy.mFogDayColor = clr(150, 187, 209);
|
||||
foggy.mFogSunsetColor = clr(113, 135, 157);
|
||||
foggy.mFogNightColor = clr(19, 24, 29);
|
||||
foggy.mAmbientSunriseColor = clr(48, 43, 37);
|
||||
foggy.mAmbientDayColor = clr(92, 109, 120);
|
||||
foggy.mAmbientSunsetColor = clr(28, 33, 39);
|
||||
foggy.mAmbientNightColor = clr(28, 33, 39);
|
||||
foggy.mSunSunriseColor = clr(177, 162, 137);
|
||||
foggy.mSunDayColor = clr(111, 131, 151);
|
||||
foggy.mSunSunsetColor = clr(125, 157, 189);
|
||||
foggy.mSunNightColor = clr(81, 100, 119);
|
||||
foggy.mSunDiscSunsetColor = clr(223, 223, 223);
|
||||
foggy.mLandFogDayDepth = 1.0;
|
||||
foggy.mLandFogNightDepth = 1.9;
|
||||
foggy.mWindSpeed = 0;
|
||||
foggy.mCloudSpeed = 1.25;
|
||||
foggy.mGlareView = 0.25;
|
||||
mWeatherSettings["foggy"] = foggy;
|
||||
|
||||
Weather thunderstorm;
|
||||
thunderstorm.mCloudTexture = "tx_sky_thunder.dds";
|
||||
thunderstorm.mCloudsMaximumPercent = 0.66;
|
||||
thunderstorm.mTransitionDelta = 0.03;
|
||||
thunderstorm.mSkySunriseColor = clr(35, 36, 39);
|
||||
thunderstorm.mSkyDayColor = clr(97, 104, 115);
|
||||
thunderstorm.mSkySunsetColor = clr(35, 36, 39);
|
||||
thunderstorm.mSkyNightColor = clr(19, 20, 22);
|
||||
thunderstorm.mFogSunriseColor = clr(70, 74, 85);
|
||||
thunderstorm.mFogDayColor = clr(97, 104, 115);
|
||||
thunderstorm.mFogSunsetColor = clr(70, 74, 85);
|
||||
thunderstorm.mFogNightColor = clr(19, 20, 22);
|
||||
thunderstorm.mAmbientSunriseColor = clr(54, 54, 54);
|
||||
thunderstorm.mAmbientDayColor = clr(90, 90, 90);
|
||||
thunderstorm.mAmbientSunsetColor = clr(54, 54, 54);
|
||||
thunderstorm.mAmbientNightColor = clr(49, 51, 54);
|
||||
thunderstorm.mSunSunriseColor = clr(91, 99, 122);
|
||||
thunderstorm.mSunDayColor = clr(138, 144, 155);
|
||||
thunderstorm.mSunSunsetColor = clr(96, 101, 117);
|
||||
thunderstorm.mSunNightColor = clr(55, 76, 110);
|
||||
thunderstorm.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
thunderstorm.mLandFogDayDepth = 1;
|
||||
thunderstorm.mLandFogNightDepth = 1.15;
|
||||
thunderstorm.mWindSpeed = 0.5;
|
||||
thunderstorm.mCloudSpeed = 3;
|
||||
thunderstorm.mGlareView = 0;
|
||||
thunderstorm.mRainLoopSoundID = "rain heavy";
|
||||
mWeatherSettings["thunderstorm"] = thunderstorm;
|
||||
|
||||
Weather rain;
|
||||
rain.mCloudTexture = "tx_sky_rainy.dds";
|
||||
rain.mCloudsMaximumPercent = 0.66;
|
||||
rain.mTransitionDelta = 0.015;
|
||||
rain.mSkySunriseColor = clr(71, 74, 75);
|
||||
rain.mSkyDayColor = clr(116, 120, 122);
|
||||
rain.mSkySunsetColor = clr(73, 73, 73);
|
||||
rain.mSkyNightColor = clr(24, 25, 26);
|
||||
rain.mFogSunriseColor = clr(71, 74, 75);
|
||||
rain.mFogDayColor = clr(116, 120, 122);
|
||||
rain.mFogSunsetColor = clr(73, 73, 73);
|
||||
rain.mFogNightColor = clr(24, 25, 26);
|
||||
rain.mAmbientSunriseColor = clr(97, 90, 88);
|
||||
rain.mAmbientDayColor = clr(105, 110, 113);
|
||||
rain.mAmbientSunsetColor = clr(88, 97, 97);
|
||||
rain.mAmbientNightColor = clr(50, 55, 67);
|
||||
rain.mSunSunriseColor = clr(131, 122, 120);
|
||||
rain.mSunDayColor = clr(149, 157, 170);
|
||||
rain.mSunSunsetColor = clr(120, 126, 131);
|
||||
rain.mSunNightColor = clr(50, 62, 101);
|
||||
rain.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
rain.mLandFogDayDepth = 0.8;
|
||||
rain.mLandFogNightDepth = 0.8;
|
||||
rain.mWindSpeed = 0.3;
|
||||
rain.mCloudSpeed = 2;
|
||||
rain.mGlareView = 0;
|
||||
rain.mRainLoopSoundID = "rain";
|
||||
mWeatherSettings["rain"] = rain;
|
||||
|
||||
Weather overcast;
|
||||
overcast.mCloudTexture = "tx_sky_overcast.dds";
|
||||
overcast.mCloudsMaximumPercent = 1.0;
|
||||
overcast.mTransitionDelta = 0.015;
|
||||
overcast.mSkySunriseColor = clr(91, 99, 106);
|
||||
overcast.mSkyDayColor = clr(143, 146, 149);
|
||||
overcast.mSkySunsetColor = clr(108, 115, 121);
|
||||
overcast.mSkyNightColor = clr(19, 22, 25);
|
||||
overcast.mFogSunriseColor = clr(91, 99, 106);
|
||||
overcast.mFogDayColor = clr(143, 146, 149);
|
||||
overcast.mFogSunsetColor = clr(108, 115, 121);
|
||||
overcast.mFogNightColor = clr(19, 22, 25);
|
||||
overcast.mAmbientSunriseColor = clr(84, 88, 92);
|
||||
overcast.mAmbientDayColor = clr(93, 96, 105);
|
||||
overcast.mAmbientSunsetColor = clr(83, 77, 75);
|
||||
overcast.mAmbientNightColor = clr(57, 60, 66);
|
||||
overcast.mSunSunriseColor = clr(87, 125, 163);
|
||||
overcast.mSunDayColor = clr(163, 169, 183);
|
||||
overcast.mSunSunsetColor = clr(85, 103, 157);
|
||||
overcast.mSunNightColor = clr(32, 54, 100);
|
||||
overcast.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
overcast.mLandFogDayDepth = 0.7;
|
||||
overcast.mLandFogNightDepth = 0.7;
|
||||
overcast.mWindSpeed = 0.2;
|
||||
overcast.mCloudSpeed = 1.5;
|
||||
overcast.mGlareView = 0;
|
||||
mWeatherSettings["overcast"] = overcast;
|
||||
|
||||
Weather ashstorm;
|
||||
ashstorm.mCloudTexture = "tx_sky_ashstorm.dds";
|
||||
ashstorm.mCloudsMaximumPercent = 1.0;
|
||||
ashstorm.mTransitionDelta = 0.035;
|
||||
ashstorm.mSkySunriseColor = clr(91, 56, 51);
|
||||
ashstorm.mSkyDayColor = clr(124, 73, 58);
|
||||
ashstorm.mSkySunsetColor = clr(106, 55, 40);
|
||||
ashstorm.mSkyNightColor = clr(20, 21, 22);
|
||||
ashstorm.mFogSunriseColor = clr(91, 56, 51);
|
||||
ashstorm.mFogDayColor = clr(124, 73, 58);
|
||||
ashstorm.mFogSunsetColor = clr(106, 55, 40);
|
||||
ashstorm.mFogNightColor = clr(20, 21, 22);
|
||||
ashstorm.mAmbientSunriseColor = clr(52, 42, 37);
|
||||
ashstorm.mAmbientDayColor = clr(75, 49, 41);
|
||||
ashstorm.mAmbientSunsetColor = clr(48, 39, 35);
|
||||
ashstorm.mAmbientNightColor = clr(36, 42, 49);
|
||||
ashstorm.mSunSunriseColor = clr(184, 91, 71);
|
||||
ashstorm.mSunDayColor = clr(228, 139, 114);
|
||||
ashstorm.mSunSunsetColor = clr(185, 86, 57);
|
||||
ashstorm.mSunNightColor = clr(54, 66, 74);
|
||||
ashstorm.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
ashstorm.mLandFogDayDepth = 1.1;
|
||||
ashstorm.mLandFogNightDepth = 1.2;
|
||||
ashstorm.mWindSpeed = 0.8;
|
||||
ashstorm.mCloudSpeed = 7;
|
||||
ashstorm.mGlareView = 0;
|
||||
ashstorm.mAmbientLoopSoundID = "ashstorm";
|
||||
mWeatherSettings["ashstorm"] = ashstorm;
|
||||
|
||||
Weather blight;
|
||||
blight.mCloudTexture = "tx_sky_blight.dds";
|
||||
blight.mCloudsMaximumPercent = 1.0;
|
||||
blight.mTransitionDelta = 0.04;
|
||||
blight.mSkySunriseColor = clr(90, 35, 35);
|
||||
blight.mSkyDayColor = clr(90, 35, 35);
|
||||
blight.mSkySunsetColor = clr(92, 33, 33);
|
||||
blight.mSkyNightColor = clr(44, 14, 14);
|
||||
blight.mFogSunriseColor = clr(90, 35, 35);
|
||||
blight.mFogDayColor = clr(128, 19, 19);
|
||||
blight.mFogSunsetColor = clr(92, 33, 33);
|
||||
blight.mFogNightColor = clr(44, 14, 14);
|
||||
blight.mAmbientSunriseColor = clr(61, 40, 40);
|
||||
blight.mAmbientDayColor = clr(79, 54, 54);
|
||||
blight.mAmbientSunsetColor = clr(61, 40, 40);
|
||||
blight.mAmbientNightColor = clr(56, 58, 62);
|
||||
blight.mSunSunriseColor = clr(180, 78, 78);
|
||||
blight.mSunDayColor = clr(224, 84, 84);
|
||||
blight.mSunSunsetColor = clr(180, 78, 78);
|
||||
blight.mSunNightColor = clr(61, 91, 143);
|
||||
blight.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
blight.mLandFogDayDepth = 1.1;
|
||||
blight.mLandFogNightDepth = 1.2;
|
||||
blight.mWindSpeed = 0.9;
|
||||
blight.mCloudSpeed = 9;
|
||||
blight.mGlareView = 0;
|
||||
blight.mAmbientLoopSoundID = "blight";
|
||||
mWeatherSettings["blight"] = blight;
|
||||
|
||||
Weather snow;
|
||||
snow.mCloudTexture = "tx_bm_sky_snow.dds";
|
||||
snow.mCloudsMaximumPercent = 1.0;
|
||||
snow.mTransitionDelta = 0.014;
|
||||
snow.mSkySunriseColor = clr(196, 91, 91);
|
||||
snow.mSkyDayColor = clr(153, 158, 166);
|
||||
snow.mSkySunsetColor = clr(96, 115, 134);
|
||||
snow.mSkyNightColor = clr(31, 35, 39);
|
||||
snow.mFogSunriseColor = clr(106, 91, 91);
|
||||
snow.mFogDayColor = clr(153, 158, 166);
|
||||
snow.mFogSunsetColor = clr(96, 115, 134);
|
||||
snow.mFogNightColor = clr(31, 35, 39);
|
||||
snow.mAmbientSunriseColor = clr(92, 84, 84);
|
||||
snow.mAmbientDayColor = clr(93, 96, 105);
|
||||
snow.mAmbientSunsetColor = clr(70, 79, 87);
|
||||
snow.mAmbientNightColor = clr(49, 58, 68);
|
||||
snow.mSunSunriseColor = clr(141, 109, 109);
|
||||
snow.mSunDayColor = clr(163, 169, 183);
|
||||
snow.mSunSunsetColor = clr(101, 121, 141);
|
||||
snow.mSunNightColor = clr(55, 66, 77);
|
||||
snow.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
snow.mLandFogDayDepth = 1.0;
|
||||
snow.mLandFogNightDepth = 1.2;
|
||||
snow.mWindSpeed = 0;
|
||||
snow.mCloudSpeed = 1.5;
|
||||
snow.mGlareView = 0;
|
||||
mWeatherSettings["snow"] = snow;
|
||||
|
||||
Weather blizzard;
|
||||
blizzard.mCloudTexture = "tx_bm_sky_blizzard.dds";
|
||||
blizzard.mCloudsMaximumPercent = 1.0;
|
||||
blizzard.mTransitionDelta = 0.030;
|
||||
blizzard.mSkySunriseColor = clr(91, 99, 106);
|
||||
blizzard.mSkyDayColor = clr(121, 133, 145);
|
||||
blizzard.mSkySunsetColor = clr(108, 115, 121);
|
||||
blizzard.mSkyNightColor = clr(27, 29, 31);
|
||||
blizzard.mFogSunriseColor = clr(91, 99, 106);
|
||||
blizzard.mFogDayColor = clr(121, 133, 145);
|
||||
blizzard.mFogSunsetColor = clr(108, 115, 121);
|
||||
blizzard.mFogNightColor = clr(21, 24, 28);
|
||||
blizzard.mAmbientSunriseColor = clr(84, 88, 92);
|
||||
blizzard.mAmbientDayColor = clr(93, 96, 105);
|
||||
blizzard.mAmbientSunsetColor = clr(83, 77, 75);
|
||||
blizzard.mAmbientNightColor = clr(53, 62, 70);
|
||||
blizzard.mSunSunriseColor = clr(114, 128, 146);
|
||||
blizzard.mSunDayColor = clr(163, 169, 183);
|
||||
blizzard.mSunSunsetColor = clr(106, 114, 136);
|
||||
blizzard.mSunNightColor = clr(57, 66, 74);
|
||||
blizzard.mSunDiscSunsetColor = clr(128, 128, 128);
|
||||
blizzard.mLandFogDayDepth = 2.8;
|
||||
blizzard.mLandFogNightDepth = 3.0;
|
||||
blizzard.mWindSpeed = 0.9;
|
||||
blizzard.mCloudSpeed = 7.5;
|
||||
blizzard.mGlareView = 0;
|
||||
blizzard.mAmbientLoopSoundID = "BM Blizzard";
|
||||
mWeatherSettings["blizzard"] = blizzard;
|
||||
}
|
||||
|
||||
void WeatherManager::setWeather(const String& weather, bool instant)
|
||||
{
|
||||
if (instant || mFirstUpdate)
|
||||
{
|
||||
mNextWeather = "";
|
||||
mCurrentWeather = weather;
|
||||
mFirstUpdate = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mNextWeather != "")
|
||||
{
|
||||
// transition more than 50% finished?
|
||||
if (mRemainingTransitionTime/(mWeatherSettings[mCurrentWeather].mTransitionDelta*24.f*60) <= 0.5)
|
||||
mCurrentWeather = mNextWeather;
|
||||
}
|
||||
|
||||
mNextWeather = weather;
|
||||
mRemainingTransitionTime = mWeatherSettings[mCurrentWeather].mTransitionDelta*24.f*60;
|
||||
}
|
||||
}
|
||||
|
||||
WeatherResult WeatherManager::getResult(const String& weather)
|
||||
{
|
||||
const Weather& current = mWeatherSettings[weather];
|
||||
WeatherResult result;
|
||||
|
||||
result.mCloudTexture = current.mCloudTexture;
|
||||
result.mCloudBlendFactor = 0;
|
||||
result.mCloudOpacity = current.mCloudsMaximumPercent;
|
||||
result.mWindSpeed = current.mWindSpeed;
|
||||
result.mCloudSpeed = current.mCloudSpeed;
|
||||
result.mGlareView = current.mGlareView;
|
||||
result.mAmbientLoopSoundID = current.mAmbientLoopSoundID;
|
||||
result.mSunColor = current.mSunDiscSunsetColor;
|
||||
|
||||
const float fade_duration = current.mTransitionDelta * 24.f;
|
||||
|
||||
result.mNight = (mHour < 6.f+fade_duration || mHour > 20.f-fade_duration);
|
||||
|
||||
result.mFogDepth = result.mNight ? current.mLandFogNightDepth : current.mLandFogDayDepth;
|
||||
|
||||
// night
|
||||
if (mHour <= (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration)
|
||||
|| mHour >= (WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration))
|
||||
{
|
||||
result.mFogColor = current.mFogNightColor;
|
||||
result.mAmbientColor = current.mAmbientNightColor;
|
||||
result.mSunColor = current.mSunNightColor;
|
||||
result.mSkyColor = current.mSkyNightColor;
|
||||
result.mNightFade = 1.f;
|
||||
}
|
||||
|
||||
// sunrise
|
||||
else if (mHour >= (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration) && mHour <= WeatherGlobals::mSunriseTime)
|
||||
{
|
||||
if (mHour <= (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration+fade_duration))
|
||||
{
|
||||
// fade in
|
||||
float advance = (WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration+fade_duration)-mHour;
|
||||
float factor = (advance / fade_duration);
|
||||
result.mFogColor = lerp(current.mFogSunriseColor, current.mFogNightColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunriseColor, current.mAmbientNightColor);
|
||||
result.mSunColor = lerp(current.mSunSunriseColor, current.mSunNightColor);
|
||||
result.mSkyColor = lerp(current.mSkySunriseColor, current.mSkyNightColor);
|
||||
result.mNightFade = factor;
|
||||
}
|
||||
else if (mHour >= (WeatherGlobals::mSunriseTime-fade_duration))
|
||||
{
|
||||
// fade out
|
||||
float advance = mHour-(WeatherGlobals::mSunriseTime-fade_duration);
|
||||
float factor = advance / fade_duration;
|
||||
result.mFogColor = lerp(current.mFogSunriseColor, current.mFogDayColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunriseColor, current.mAmbientDayColor);
|
||||
result.mSunColor = lerp(current.mSunSunriseColor, current.mSunDayColor);
|
||||
result.mSkyColor = lerp(current.mSkySunriseColor, current.mSkyDayColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
result.mFogColor = current.mFogSunriseColor;
|
||||
result.mAmbientColor = current.mAmbientSunriseColor;
|
||||
result.mSunColor = current.mSunSunriseColor;
|
||||
result.mSkyColor = current.mSkySunriseColor;
|
||||
}
|
||||
}
|
||||
|
||||
// day
|
||||
else if (mHour >= (WeatherGlobals::mSunriseTime) && mHour <= (WeatherGlobals::mSunsetTime))
|
||||
{
|
||||
result.mFogColor = current.mFogDayColor;
|
||||
result.mAmbientColor = current.mAmbientDayColor;
|
||||
result.mSunColor = current.mSunDayColor;
|
||||
result.mSkyColor = current.mSkyDayColor;
|
||||
}
|
||||
|
||||
// sunset
|
||||
else if (mHour >= (WeatherGlobals::mSunsetTime) && mHour <= (WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration))
|
||||
{
|
||||
if (mHour <= (WeatherGlobals::mSunsetTime+fade_duration))
|
||||
{
|
||||
// fade in
|
||||
float advance = (WeatherGlobals::mSunsetTime+fade_duration)-mHour;
|
||||
float factor = (advance / fade_duration);
|
||||
result.mFogColor = lerp(current.mFogSunsetColor, current.mFogDayColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunsetColor, current.mAmbientDayColor);
|
||||
result.mSunColor = lerp(current.mSunSunsetColor, current.mSunDayColor);
|
||||
result.mSkyColor = lerp(current.mSkySunsetColor, current.mSkyDayColor);
|
||||
}
|
||||
else if (mHour >= (WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration-fade_duration))
|
||||
{
|
||||
// fade out
|
||||
float advance = mHour-(WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration-fade_duration);
|
||||
float factor = advance / fade_duration;
|
||||
result.mFogColor = lerp(current.mFogSunsetColor, current.mFogNightColor);
|
||||
result.mAmbientColor = lerp(current.mAmbientSunsetColor, current.mAmbientNightColor);
|
||||
result.mSunColor = lerp(current.mSunSunsetColor, current.mSunNightColor);
|
||||
result.mSkyColor = lerp(current.mSkySunsetColor, current.mSkyNightColor);
|
||||
result.mNightFade = factor;
|
||||
}
|
||||
else
|
||||
{
|
||||
result.mFogColor = current.mFogSunsetColor;
|
||||
result.mAmbientColor = current.mAmbientSunsetColor;
|
||||
result.mSunColor = current.mSunSunsetColor;
|
||||
result.mSkyColor = current.mSkySunsetColor;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
WeatherResult WeatherManager::transition(float factor)
|
||||
{
|
||||
const WeatherResult& current = getResult(mCurrentWeather);
|
||||
const WeatherResult& other = getResult(mNextWeather);
|
||||
WeatherResult result;
|
||||
|
||||
result.mCloudTexture = current.mCloudTexture;
|
||||
result.mNextCloudTexture = other.mCloudTexture;
|
||||
result.mCloudBlendFactor = factor;
|
||||
|
||||
result.mCloudOpacity = lerp(current.mCloudOpacity, other.mCloudOpacity);
|
||||
result.mFogColor = lerp(current.mFogColor, other.mFogColor);
|
||||
result.mSunColor = lerp(current.mSunColor, other.mSunColor);
|
||||
result.mSkyColor = lerp(current.mSkyColor, other.mSkyColor);
|
||||
|
||||
result.mAmbientColor = lerp(current.mAmbientColor, other.mAmbientColor);
|
||||
result.mSunDiscColor = lerp(current.mSunDiscColor, other.mSunDiscColor);
|
||||
result.mFogDepth = lerp(current.mFogDepth, other.mFogDepth);
|
||||
result.mWindSpeed = lerp(current.mWindSpeed, other.mWindSpeed);
|
||||
result.mCloudSpeed = lerp(current.mCloudSpeed, other.mCloudSpeed);
|
||||
result.mCloudOpacity = lerp(current.mCloudOpacity, other.mCloudOpacity);
|
||||
result.mGlareView = lerp(current.mGlareView, other.mGlareView);
|
||||
|
||||
result.mNight = current.mNight;
|
||||
|
||||
// sound change behaviour:
|
||||
// if 'other' has a new sound, switch to it after 1/2 of the transition length
|
||||
if (other.mAmbientLoopSoundID != "")
|
||||
result.mAmbientLoopSoundID = factor>0.5 ? other.mAmbientLoopSoundID : current.mAmbientLoopSoundID;
|
||||
// if 'current' has a sound and 'other' does not have a sound, turn off the sound immediately
|
||||
else if (current.mAmbientLoopSoundID != "")
|
||||
result.mAmbientLoopSoundID = "";
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void WeatherManager::update(float duration)
|
||||
{
|
||||
mWeatherUpdateTime -= duration;
|
||||
if (mEnvironment->mWorld->isCellExterior() || mEnvironment->mWorld->isCellQuasiExterior())
|
||||
{
|
||||
std::string regionstr = mEnvironment->mWorld->getPlayer().getPlayer().getCell()->cell->region;
|
||||
boost::algorithm::to_lower(regionstr);
|
||||
|
||||
if (mWeatherUpdateTime <= 0 || regionstr != mCurrentRegion)
|
||||
{
|
||||
mCurrentRegion = regionstr;
|
||||
mWeatherUpdateTime = WeatherGlobals::mWeatherUpdateTime*60.f;
|
||||
|
||||
std::string weather;
|
||||
|
||||
if (mRegionOverrides.find(regionstr) != mRegionOverrides.end())
|
||||
weather = mRegionOverrides[regionstr];
|
||||
else
|
||||
{
|
||||
// get weather probabilities for the current region
|
||||
const ESM::Region *region = mEnvironment->mWorld->getStore().regions.find (regionstr);
|
||||
|
||||
float clear = region->data.clear/255.f;
|
||||
float cloudy = region->data.cloudy/255.f;
|
||||
float foggy = region->data.foggy/255.f;
|
||||
float overcast = region->data.overcast/255.f;
|
||||
float rain = region->data.rain/255.f;
|
||||
float thunder = region->data.thunder/255.f;
|
||||
float ash = region->data.ash/255.f;
|
||||
float blight = region->data.blight/255.f;
|
||||
float snow = region->data.a/255.f;
|
||||
float blizzard = region->data.b/255.f;
|
||||
|
||||
// re-scale to 100 percent
|
||||
const float total = clear+cloudy+foggy+overcast+rain+thunder+ash+blight+snow+blizzard;
|
||||
|
||||
srand(time(NULL));
|
||||
float random = ((rand()%100)/100.f) * total;
|
||||
|
||||
if (random >= snow+blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "blizzard";
|
||||
else if (random >= blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "snow";
|
||||
else if (random >= ash+thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "blight";
|
||||
else if (random >= thunder+rain+overcast+foggy+cloudy+clear)
|
||||
weather = "ashstorm";
|
||||
else if (random >= rain+overcast+foggy+cloudy+clear)
|
||||
weather = "thunderstorm";
|
||||
else if (random >= overcast+foggy+cloudy+clear)
|
||||
weather = "rain";
|
||||
else if (random >= foggy+cloudy+clear)
|
||||
weather = "overcast";
|
||||
else if (random >= cloudy+clear)
|
||||
weather = "foggy";
|
||||
else if (random >= clear)
|
||||
weather = "cloudy";
|
||||
else
|
||||
weather = "clear";
|
||||
}
|
||||
|
||||
setWeather(weather, false);
|
||||
/*
|
||||
std::cout << "roll result: " << random << std::endl;
|
||||
|
||||
std::cout << regionstr << " weather probabilities: " << clear << " " << cloudy << " " << foggy << " "
|
||||
<< overcast << " " << rain << " " << thunder << " " << ash << " " << blight << " " << snow << " "
|
||||
<< blizzard << std::endl;
|
||||
|
||||
std::cout << "New weather : " << weather << std::endl;
|
||||
*/
|
||||
}
|
||||
|
||||
WeatherResult result;
|
||||
|
||||
if (mNextWeather != "")
|
||||
{
|
||||
mRemainingTransitionTime -= duration;
|
||||
if (mRemainingTransitionTime < 0)
|
||||
{
|
||||
mCurrentWeather = mNextWeather;
|
||||
mNextWeather = "";
|
||||
}
|
||||
}
|
||||
|
||||
if (mNextWeather != "")
|
||||
result = transition(1-(mRemainingTransitionTime/(mWeatherSettings[mCurrentWeather].mTransitionDelta*24.f*60)));
|
||||
else
|
||||
result = getResult(mCurrentWeather);
|
||||
|
||||
mRendering->configureFog(result.mFogDepth, result.mFogColor);
|
||||
|
||||
// disable sun during night
|
||||
if (mHour >= WeatherGlobals::mSunsetTime+WeatherGlobals::mSunsetDuration
|
||||
|| mHour <= WeatherGlobals::mSunriseTime-WeatherGlobals::mSunriseDuration)
|
||||
mRendering->getSkyManager()->sunDisable();
|
||||
else
|
||||
{
|
||||
// during day, calculate sun angle
|
||||
float height = 1-std::abs(((mHour-13)/7.f));
|
||||
int facing = mHour > 13.f ? 1 : -1;
|
||||
Vector3 final(
|
||||
(1-height)*facing,
|
||||
(1-height)*facing,
|
||||
height);
|
||||
mRendering->setSunDirection(final);
|
||||
|
||||
mRendering->getSkyManager()->sunEnable();
|
||||
}
|
||||
|
||||
// moon calculations
|
||||
float night;
|
||||
if (mHour >= 14)
|
||||
night = mHour-14;
|
||||
else if (mHour <= 10)
|
||||
night = mHour+10;
|
||||
else
|
||||
night = 0;
|
||||
|
||||
night /= 20.f;
|
||||
|
||||
if (night != 0)
|
||||
{
|
||||
float moonHeight = 1-std::abs((night-0.5)*2);
|
||||
int facing = (mHour > 0.f && mHour<12.f) ? 1 : -1;
|
||||
Vector3 masser(
|
||||
(1-moonHeight)*facing,
|
||||
(1-moonHeight)*facing,
|
||||
moonHeight);
|
||||
|
||||
Vector3 secunda(
|
||||
(1-moonHeight)*facing*0.8,
|
||||
(1-moonHeight)*facing*1.25,
|
||||
moonHeight);
|
||||
|
||||
mRendering->getSkyManager()->setMasserDirection(masser);
|
||||
mRendering->getSkyManager()->setSecundaDirection(secunda);
|
||||
mRendering->getSkyManager()->masserEnable();
|
||||
mRendering->getSkyManager()->secundaEnable();
|
||||
|
||||
float hour_fade;
|
||||
if (mHour >= 7.f && mHour <= 14.f)
|
||||
hour_fade = 1-(mHour-7)/3.f;
|
||||
else if (mHour >= 14 && mHour <= 15.f)
|
||||
hour_fade = mHour-14;
|
||||
else
|
||||
hour_fade = 1;
|
||||
|
||||
float secunda_angle_fade;
|
||||
float masser_angle_fade;
|
||||
float angle = moonHeight*90.f;
|
||||
|
||||
if (angle >= 30 && angle <= 50)
|
||||
secunda_angle_fade = (angle-30)/20.f;
|
||||
else if (angle <30)
|
||||
secunda_angle_fade = 0.f;
|
||||
else
|
||||
secunda_angle_fade = 1.f;
|
||||
|
||||
if (angle >= 40 && angle <= 50)
|
||||
masser_angle_fade = (angle-40)/10.f;
|
||||
else if (angle <40)
|
||||
masser_angle_fade = 0.f;
|
||||
else
|
||||
masser_angle_fade = 1.f;
|
||||
|
||||
masser_angle_fade *= hour_fade;
|
||||
secunda_angle_fade *= hour_fade;
|
||||
|
||||
mRendering->getSkyManager()->setMasserFade(masser_angle_fade);
|
||||
mRendering->getSkyManager()->setSecundaFade(secunda_angle_fade);
|
||||
}
|
||||
else
|
||||
{
|
||||
mRendering->getSkyManager()->masserDisable();
|
||||
mRendering->getSkyManager()->secundaDisable();
|
||||
}
|
||||
|
||||
if (mCurrentWeather == "thunderstorm" && mNextWeather == "")
|
||||
{
|
||||
if (mThunderFlash > 0)
|
||||
{
|
||||
// play the sound after a delay
|
||||
mThunderSoundDelay -= duration;
|
||||
if (mThunderSoundDelay <= 0)
|
||||
{
|
||||
// pick a random sound
|
||||
int sound = rand() % 4;
|
||||
std::string soundname;
|
||||
if (sound == 0) soundname = WeatherGlobals::mThunderSoundID0;
|
||||
else if (sound == 1) soundname = WeatherGlobals::mThunderSoundID1;
|
||||
else if (sound == 2) soundname = WeatherGlobals::mThunderSoundID2;
|
||||
else if (sound == 3) soundname = WeatherGlobals::mThunderSoundID3;
|
||||
mEnvironment->mSoundManager->playSound(soundname, 1.0, 1.0);
|
||||
mThunderSoundDelay = 1000;
|
||||
}
|
||||
|
||||
mThunderFlash -= duration;
|
||||
if (mThunderFlash > 0)
|
||||
mRendering->getSkyManager()->setThunder( mThunderFlash / WeatherGlobals::mThunderThreshold );
|
||||
else
|
||||
{
|
||||
srand(time(NULL));
|
||||
mThunderChanceNeeded = rand() % 100;
|
||||
mThunderChance = 0;
|
||||
mRendering->getSkyManager()->setThunder( 0.f );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// no thunder active
|
||||
mThunderChance += duration*4; // chance increases by 4 percent every second
|
||||
if (mThunderChance >= mThunderChanceNeeded)
|
||||
{
|
||||
mThunderFlash = WeatherGlobals::mThunderThreshold;
|
||||
|
||||
mRendering->getSkyManager()->setThunder( mThunderFlash / WeatherGlobals::mThunderThreshold );
|
||||
|
||||
mThunderSoundDelay = WeatherGlobals::mThunderSoundDelay;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
mRendering->getSkyManager()->setThunder(0.f);
|
||||
|
||||
mRendering->setAmbientColour(result.mAmbientColor);
|
||||
mRendering->sunEnable();
|
||||
mRendering->setSunColour(result.mSunColor);
|
||||
|
||||
mRendering->getSkyManager()->setWeather(result);
|
||||
}
|
||||
else
|
||||
{
|
||||
mRendering->sunDisable();
|
||||
mRendering->skyDisable();
|
||||
mRendering->getSkyManager()->setThunder(0.f);
|
||||
}
|
||||
}
|
||||
|
||||
void WeatherManager::setHour(const float hour)
|
||||
{
|
||||
// accelerate a bit for testing
|
||||
/*
|
||||
mHour += 0.005;
|
||||
|
||||
if (mHour >= 24.f) mHour = 0.f;
|
||||
|
||||
std::cout << "hour " << mHour << std::endl;
|
||||
*/
|
||||
|
||||
mHour = hour;
|
||||
}
|
||||
|
||||
void WeatherManager::setDate(const int day, const int month)
|
||||
{
|
||||
mDay = day;
|
||||
mMonth = month;
|
||||
}
|
||||
|
||||
unsigned int WeatherManager::getWeatherID() const
|
||||
{
|
||||
// Source: http://www.uesp.net/wiki/Tes3Mod:GetCurrentWeather
|
||||
|
||||
if (mCurrentWeather == "clear")
|
||||
return 0;
|
||||
else if (mCurrentWeather == "cloudy")
|
||||
return 1;
|
||||
else if (mCurrentWeather == "foggy")
|
||||
return 2;
|
||||
else if (mCurrentWeather == "overcast")
|
||||
return 3;
|
||||
else if (mCurrentWeather == "rain")
|
||||
return 4;
|
||||
else if (mCurrentWeather == "thunderstorm")
|
||||
return 5;
|
||||
else if (mCurrentWeather == "ashstorm")
|
||||
return 6;
|
||||
else if (mCurrentWeather == "blight")
|
||||
return 7;
|
||||
else if (mCurrentWeather == "snow")
|
||||
return 8;
|
||||
else if (mCurrentWeather == "blizzard")
|
||||
return 9;
|
||||
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
void WeatherManager::changeWeather(const std::string& region, const unsigned int id)
|
||||
{
|
||||
std::string weather;
|
||||
if (id==0)
|
||||
weather = "clear";
|
||||
else if (id==1)
|
||||
weather = "cloudy";
|
||||
else if (id==2)
|
||||
weather = "foggy";
|
||||
else if (id==3)
|
||||
weather = "overcast";
|
||||
else if (id==4)
|
||||
weather = "rain";
|
||||
else if (id==5)
|
||||
weather = "thunderstorm";
|
||||
else if (id==6)
|
||||
weather = "ashstorm";
|
||||
else if (id==7)
|
||||
weather = "blight";
|
||||
else if (id==8)
|
||||
weather = "snow";
|
||||
else if (id==9)
|
||||
weather = "blizzard";
|
||||
else
|
||||
weather = "clear";
|
||||
|
||||
mRegionOverrides[region] = weather;
|
||||
}
|
||||
@ -0,0 +1,272 @@
|
||||
#ifndef GAME_MWWORLD_WEATHER_H
|
||||
#define GAME_MWWORLD_WEATHER_H
|
||||
|
||||
#include <OgreString.h>
|
||||
#include <OgreColourValue.h>
|
||||
|
||||
namespace MWRender
|
||||
{
|
||||
class RenderingManager;
|
||||
}
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
class Environment;
|
||||
|
||||
/// Global weather manager properties (according to INI)
|
||||
struct WeatherGlobals
|
||||
{
|
||||
/*
|
||||
[Weather]
|
||||
EnvReduceColor=255,255,255,255
|
||||
LerpCloseColor=037,046,048,255
|
||||
BumpFadeColor=230,239,255,255
|
||||
AlphaReduce=0.35
|
||||
Minimum Time Between Environmental Sounds=1.0
|
||||
Maximum Time Between Environmental Sounds=5.0
|
||||
Sun Glare Fader Max=0.5
|
||||
Sun Glare Fader Angle Max=30.0
|
||||
Sun Glare Fader Color=222,095,039
|
||||
Timescale Clouds=0
|
||||
Precip Gravity=575
|
||||
Hours Between Weather Changes=20
|
||||
Rain Ripples=1
|
||||
Rain Ripple Radius=1024
|
||||
Rain Ripples Per Drop=1
|
||||
Rain Ripple Scale=0.3
|
||||
Rain Ripple Speed=1.0
|
||||
Fog Depth Change Speed=3
|
||||
Sunrise Time=6
|
||||
Sunset Time=18
|
||||
Sunrise Duration=2
|
||||
Sunset Duration=2
|
||||
Sky Pre-Sunrise Time=.5
|
||||
Sky Post-Sunrise Time=1
|
||||
Sky Pre-Sunset Time=1.5
|
||||
Sky Post-Sunset Time=.5
|
||||
Ambient Pre-Sunrise Time=.5
|
||||
Ambient Post-Sunrise Time=2
|
||||
Ambient Pre-Sunset Time=1
|
||||
Ambient Post-Sunset Time=1.25
|
||||
Fog Pre-Sunrise Time=.5
|
||||
Fog Post-Sunrise Time=1
|
||||
Fog Pre-Sunset Time=2
|
||||
Fog Post-Sunset Time=1
|
||||
Sun Pre-Sunrise Time=0
|
||||
Sun Post-Sunrise Time=0
|
||||
Sun Pre-Sunset Time=1
|
||||
Sun Post-Sunset Time=1.25
|
||||
Stars Post-Sunset Start=1
|
||||
Stars Pre-Sunrise Finish=2
|
||||
Stars Fading Duration=2
|
||||
Snow Ripples=0
|
||||
Snow Ripple Radius=1024
|
||||
Snow Ripples Per Flake=1
|
||||
Snow Ripple Scale=0.3
|
||||
Snow Ripple Speed=1.0
|
||||
Snow Gravity Scale=0.1
|
||||
Snow High Kill=700
|
||||
Snow Low Kill=150
|
||||
|
||||
|
||||
[Moons]
|
||||
Masser Size=94
|
||||
Masser Fade In Start=14
|
||||
Masser Fade In Finish=15
|
||||
Masser Fade Out Start=7
|
||||
Masser Fade Out Finish=10
|
||||
Masser Axis Offset=35
|
||||
Masser Speed=.5
|
||||
Masser Daily Increment=1
|
||||
Masser Fade Start Angle=50
|
||||
Masser Fade End Angle=40
|
||||
Masser Moon Shadow Early Fade Angle=0.5
|
||||
Secunda Size=40
|
||||
Secunda Fade In Start=14
|
||||
Secunda Fade In Finish=15
|
||||
Secunda Fade Out Start=7
|
||||
Secunda Fade Out Finish=10
|
||||
Secunda Axis Offset=50
|
||||
Secunda Speed=.6
|
||||
Secunda Daily Increment=1.2
|
||||
Secunda Fade Start Angle=50
|
||||
Secunda Fade End Angle=30
|
||||
Secunda Moon Shadow Early Fade Angle=0.5
|
||||
Script Color=255,20,20
|
||||
*/
|
||||
|
||||
static const float mSunriseTime = 8;
|
||||
static const float mSunsetTime = 18;
|
||||
static const float mSunriseDuration = 2;
|
||||
static const float mSunsetDuration = 2;
|
||||
|
||||
static const float mWeatherUpdateTime = 20.f;
|
||||
|
||||
// morrowind sets these per-weather, but since they are only used by 'thunderstorm'
|
||||
// weather setting anyway, we can just as well set them globally
|
||||
static const float mThunderFrequency = .4;
|
||||
static const float mThunderThreshold = 0.6;
|
||||
static const float mThunderSoundDelay = 0.25;
|
||||
static const std::string mThunderSoundID0;
|
||||
static const std::string mThunderSoundID1;
|
||||
static const std::string mThunderSoundID2;
|
||||
static const std::string mThunderSoundID3;
|
||||
};
|
||||
|
||||
/// Defines the actual weather that results from weather setting (see below), time of day and weather transition
|
||||
struct WeatherResult
|
||||
{
|
||||
Ogre::String mCloudTexture;
|
||||
Ogre::String mNextCloudTexture;
|
||||
float mCloudBlendFactor;
|
||||
|
||||
Ogre::ColourValue mFogColor;
|
||||
|
||||
Ogre::ColourValue mAmbientColor;
|
||||
|
||||
Ogre::ColourValue mSkyColor;
|
||||
|
||||
Ogre::ColourValue mSunColor;
|
||||
|
||||
Ogre::ColourValue mSunDiscColor;
|
||||
|
||||
float mFogDepth;
|
||||
|
||||
float mWindSpeed;
|
||||
|
||||
float mCloudSpeed;
|
||||
|
||||
float mCloudOpacity;
|
||||
|
||||
float mGlareView;
|
||||
|
||||
bool mNight; // use night skybox
|
||||
float mNightFade; // fading factor for night skybox
|
||||
|
||||
Ogre::String mAmbientLoopSoundID;
|
||||
};
|
||||
|
||||
|
||||
/// Defines a single weather setting (according to INI)
|
||||
struct Weather
|
||||
{
|
||||
Ogre::String mCloudTexture;
|
||||
|
||||
// Sky (atmosphere) colors
|
||||
Ogre::ColourValue mSkySunriseColor,
|
||||
mSkyDayColor,
|
||||
mSkySunsetColor,
|
||||
mSkyNightColor;
|
||||
|
||||
// Fog colors
|
||||
Ogre::ColourValue mFogSunriseColor,
|
||||
mFogDayColor,
|
||||
mFogSunsetColor,
|
||||
mFogNightColor;
|
||||
|
||||
// Ambient lighting colors
|
||||
Ogre::ColourValue mAmbientSunriseColor,
|
||||
mAmbientDayColor,
|
||||
mAmbientSunsetColor,
|
||||
mAmbientNightColor;
|
||||
|
||||
// Sun (directional) lighting colors
|
||||
Ogre::ColourValue mSunSunriseColor,
|
||||
mSunDayColor,
|
||||
mSunSunsetColor,
|
||||
mSunNightColor;
|
||||
|
||||
// Fog depth/density
|
||||
float mLandFogDayDepth,
|
||||
mLandFogNightDepth;
|
||||
|
||||
// Color modulation for the sun itself during sunset (not completely sure)
|
||||
Ogre::ColourValue mSunDiscSunsetColor;
|
||||
|
||||
// Duration of weather transition (in days)
|
||||
float mTransitionDelta;
|
||||
|
||||
// No idea what this one is used for?
|
||||
float mWindSpeed;
|
||||
|
||||
// Cloud animation speed multiplier
|
||||
float mCloudSpeed;
|
||||
|
||||
// Multiplier for clouds transparency
|
||||
float mCloudsMaximumPercent;
|
||||
|
||||
// Value between 0 and 1, defines the strength of the sun glare effect
|
||||
float mGlareView;
|
||||
|
||||
// Sound effect
|
||||
// This is used for Blight, Ashstorm and Blizzard (Bloodmoon)
|
||||
Ogre::String mAmbientLoopSoundID;
|
||||
|
||||
// Rain sound effect
|
||||
Ogre::String mRainLoopSoundID;
|
||||
|
||||
/// \todo disease chance
|
||||
};
|
||||
|
||||
///
|
||||
/// Interface for weather settings
|
||||
///
|
||||
class WeatherManager
|
||||
{
|
||||
public:
|
||||
WeatherManager(MWRender::RenderingManager*, MWWorld::Environment*);
|
||||
|
||||
/**
|
||||
* Change the weather in the specified region
|
||||
* @param region that should be changed
|
||||
* @param ID of the weather setting to shift to
|
||||
*/
|
||||
void changeWeather(const std::string& region, const unsigned int id);
|
||||
|
||||
/**
|
||||
* Per-frame update
|
||||
* @param duration
|
||||
*/
|
||||
void update(float duration);
|
||||
|
||||
void setHour(const float hour);
|
||||
|
||||
void setDate(const int day, const int month);
|
||||
|
||||
unsigned int getWeatherID() const;
|
||||
|
||||
private:
|
||||
float mHour;
|
||||
int mDay, mMonth;
|
||||
|
||||
MWRender::RenderingManager* mRendering;
|
||||
MWWorld::Environment* mEnvironment;
|
||||
|
||||
std::map<Ogre::String, Weather> mWeatherSettings;
|
||||
|
||||
std::map<std::string, std::string> mRegionOverrides;
|
||||
|
||||
Ogre::String mCurrentWeather;
|
||||
Ogre::String mNextWeather;
|
||||
|
||||
std::string mCurrentRegion;
|
||||
|
||||
bool mFirstUpdate;
|
||||
|
||||
float mWeatherUpdateTime;
|
||||
|
||||
float mRemainingTransitionTime;
|
||||
|
||||
float mThunderFlash;
|
||||
float mThunderChance;
|
||||
float mThunderChanceNeeded;
|
||||
float mThunderSoundDelay;
|
||||
|
||||
WeatherResult transition(const float factor);
|
||||
WeatherResult getResult(const Ogre::String& weather);
|
||||
|
||||
void setWeather(const Ogre::String& weather, bool instant=false);
|
||||
};
|
||||
}
|
||||
|
||||
#endif // GAME_MWWORLD_WEATHER_H
|
||||
@ -1,110 +1,542 @@
|
||||
# Find OGRE includes and library
|
||||
#-------------------------------------------------------------------
|
||||
# This file is part of the CMake build system for OGRE
|
||||
# (Object-oriented Graphics Rendering Engine)
|
||||
# For the latest info, see http://www.ogre3d.org/
|
||||
#
|
||||
# This module defines
|
||||
# OGRE_INCLUDE_DIR
|
||||
# OGRE_LIBRARIES, the libraries to link against to use OGRE.
|
||||
# OGRE_LIB_DIR, the location of the libraries
|
||||
# OGRE_FOUND, If false, do not try to use OGRE
|
||||
# The contents of this file are placed in the public domain. Feel
|
||||
# free to make use of it in any way you like.
|
||||
#-------------------------------------------------------------------
|
||||
|
||||
# - Try to find OGRE
|
||||
# If you have multiple versions of Ogre installed, use the CMake or
|
||||
# the environment variable OGRE_HOME to point to the path where the
|
||||
# desired Ogre version can be found.
|
||||
# By default this script will look for a dynamic Ogre build. If you
|
||||
# need to link against static Ogre libraries, set the CMake variable
|
||||
# OGRE_STATIC to TRUE.
|
||||
#
|
||||
# Once done, this will define
|
||||
#
|
||||
# OGRE_FOUND - system has OGRE
|
||||
# OGRE_INCLUDE_DIRS - the OGRE include directories
|
||||
# OGRE_LIBRARIES - link these to use the OGRE core
|
||||
# OGRE_BINARY_REL - location of the main Ogre binary (win32 non-static only, release)
|
||||
# OGRE_BINARY_DBG - location of the main Ogre binaries (win32 non-static only, debug)
|
||||
#
|
||||
# Additionally this script searches for the following optional
|
||||
# parts of the Ogre package:
|
||||
# Plugin_BSPSceneManager, Plugin_CgProgramManager,
|
||||
# Plugin_OctreeSceneManager, Plugin_OctreeZone,
|
||||
# Plugin_ParticleFX, Plugin_PCZSceneManager,
|
||||
# RenderSystem_GL, RenderSystem_Direct3D9,
|
||||
# Paging, Terrain
|
||||
#
|
||||
# Copyright © 2007, Matt Williams
|
||||
# For each of these components, the following variables are defined:
|
||||
#
|
||||
# Redistribution and use is allowed according to the terms of the BSD license.
|
||||
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
|
||||
CMAKE_POLICY(PUSH)
|
||||
|
||||
IF (OGRE_LIBRARIES AND OGRE_INCLUDE_DIR AND OGRE_LIB_DIR AND OGRE_PLUGIN_DIR)
|
||||
SET(OGRE_FIND_QUIETLY TRUE) # Already in cache, be silent
|
||||
ENDIF (OGRE_LIBRARIES AND OGRE_INCLUDE_DIR AND OGRE_LIB_DIR AND OGRE_PLUGIN_DIR)
|
||||
|
||||
IF (WIN32) #Windows
|
||||
MESSAGE(STATUS "Looking for OGRE")
|
||||
SET(OGRESDK $ENV{OGRE_HOME})
|
||||
SET(OGRESOURCE $ENV{OGRE_SRC})
|
||||
IF (OGRESDK)
|
||||
MESSAGE(STATUS "Using OGRE SDK")
|
||||
STRING(REGEX REPLACE "[\\]" "/" OGRESDK "${OGRESDK}")
|
||||
SET(OGRE_INCLUDE_DIR ${OGRESDK}/include)
|
||||
SET(OGRE_LIB_DIR ${OGRESDK}/lib)
|
||||
SET(OGRE_LIBRARIES debug OgreMain_d optimized OgreMain)
|
||||
ENDIF (OGRESDK)
|
||||
IF (OGRESOURCE)
|
||||
MESSAGE(STATUS "Using OGRE built from source")
|
||||
SET(OGRE_INCLUDE_DIR $ENV{OGRE_SRC}/OgreMain/include)
|
||||
SET(OGRE_LIB_DIR $ENV{OGRE_SRC}/lib)
|
||||
SET(OGRE_LIBRARIES debug OgreMain_d optimized OgreMain)
|
||||
ENDIF (OGRESOURCE)
|
||||
ENDIF (WIN32)
|
||||
|
||||
IF (UNIX AND NOT APPLE)
|
||||
CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
|
||||
FIND_PACKAGE(PkgConfig REQUIRED)
|
||||
# Don't mark REQUIRED, but use PKG_CHECK_MODULES below (otherwise PkgConfig
|
||||
# complains even if OGRE_* are set by hand).
|
||||
PKG_SEARCH_MODULE(OGRE OGRE)
|
||||
SET(OGRE_INCLUDE_DIR ${OGRE_INCLUDE_DIRS})
|
||||
SET(OGRE_LIB_DIR ${OGRE_LIBDIR})
|
||||
SET(OGRE_LIBRARIES ${OGRE_LIBRARIES} CACHE STRING "")
|
||||
PKG_CHECK_MODULES(OGRE OGRE)
|
||||
ENDIF (UNIX AND NOT APPLE)
|
||||
|
||||
# on OS X we need Ogre SDK because framework doesn't include all libs, just Ogre Main lib
|
||||
IF (APPLE)
|
||||
IF (OGRESDK)
|
||||
MESSAGE(STATUS "Using Ogre SDK")
|
||||
SET(OGRE_LIB_DIR ${OGRESDK}/lib)
|
||||
ELSE (OGRESDK)
|
||||
MESSAGE(FATAL_ERROR "Path to Ogre SDK not specified. Specify OGRESDK.")
|
||||
ENDIF (OGRESDK)
|
||||
|
||||
|
||||
FIND_PATH(OGRE_INCLUDE_DIR Ogre.h
|
||||
PATHS
|
||||
/Library/Frameworks
|
||||
/opt/local
|
||||
)
|
||||
FIND_LIBRARY(OGRE_LIBRARIES
|
||||
NAMES Ogre
|
||||
PATHS
|
||||
/Library/Frameworks
|
||||
/opt/local
|
||||
)
|
||||
ENDIF (APPLE)
|
||||
|
||||
#Do some preparation
|
||||
SEPARATE_ARGUMENTS(OGRE_INCLUDE_DIR)
|
||||
SEPARATE_ARGUMENTS(OGRE_LIBRARIES)
|
||||
|
||||
SET(OGRE_INCLUDE_DIR ${OGRE_INCLUDE_DIR} CACHE PATH "")
|
||||
SET(OGRE_LIBRARIES ${OGRE_LIBRARIES} CACHE STRING "")
|
||||
SET(OGRE_LIB_DIR ${OGRE_LIB_DIR} CACHE PATH "")
|
||||
|
||||
if(OGRE_LIB_DIR)
|
||||
CMAKE_POLICY(SET CMP0009 NEW)
|
||||
IF (NOT APPLE)
|
||||
FILE(GLOB_RECURSE OGRE_PLUGINS "${OGRE_LIB_DIR}/Plugin_*.so")
|
||||
ENDIF (NOT APPLE)
|
||||
IF (APPLE)
|
||||
FILE(GLOB_RECURSE OGRE_PLUGINS "${OGRE_LIB_DIR}/Plugin_*.dylib")
|
||||
ENDIF (APPLE)
|
||||
FOREACH (OGRE_PLUGINS_FILE ${OGRE_PLUGINS})
|
||||
STRING(REGEX REPLACE "/[^/]*$" "" OGRE_PLUGIN_DIR ${OGRE_PLUGINS_FILE})
|
||||
ENDFOREACH(OGRE_PLUGINS_FILE)
|
||||
|
||||
# OGRE_${COMPONENT}_FOUND - ${COMPONENT} is available
|
||||
# OGRE_${COMPONENT}_INCLUDE_DIRS - additional include directories for ${COMPONENT}
|
||||
# OGRE_${COMPONENT}_LIBRARIES - link these to use ${COMPONENT}
|
||||
# OGRE_${COMPONENT}_BINARY_REL - location of the component binary (win32 non-static only, release)
|
||||
# OGRE_${COMPONENT}_BINARY_DBG - location of the component binary (win32 non-static only, debug)
|
||||
#
|
||||
# Finally, the following variables are defined:
|
||||
#
|
||||
# OGRE_PLUGIN_DIR_REL - The directory where the release versions of
|
||||
# the OGRE plugins are located
|
||||
# OGRE_PLUGIN_DIR_DBG - The directory where the debug versions of
|
||||
# the OGRE plugins are located
|
||||
# OGRE_MEDIA_DIR - The directory where the OGRE sample media is
|
||||
# located, if available
|
||||
|
||||
include(FindPkgMacros)
|
||||
include(PreprocessorUtils)
|
||||
findpkg_begin(OGRE)
|
||||
|
||||
|
||||
# Get path, convert backslashes as ${ENV_${var}}
|
||||
getenv_path(OGRE_HOME)
|
||||
getenv_path(OGRE_SDK)
|
||||
getenv_path(OGRE_SOURCE)
|
||||
getenv_path(OGRE_BUILD)
|
||||
getenv_path(OGRE_DEPENDENCIES_DIR)
|
||||
getenv_path(PROGRAMFILES)
|
||||
|
||||
# Determine whether to search for a dynamic or static build
|
||||
if (OGRE_STATIC)
|
||||
set(OGRE_LIB_SUFFIX "Static")
|
||||
else ()
|
||||
set(OGRE_LIB_SUFFIX "")
|
||||
endif ()
|
||||
|
||||
|
||||
set(OGRE_LIBRARY_NAMES "OgreMain${OGRE_LIB_SUFFIX}")
|
||||
get_debug_names(OGRE_LIBRARY_NAMES)
|
||||
|
||||
# construct search paths from environmental hints and
|
||||
# OS specific guesses
|
||||
if (WIN32)
|
||||
set(OGRE_PREFIX_GUESSES
|
||||
${ENV_PROGRAMFILES}/OGRE
|
||||
C:/OgreSDK
|
||||
)
|
||||
elseif (UNIX)
|
||||
set(OGRE_PREFIX_GUESSES
|
||||
/opt/ogre
|
||||
/opt/OGRE
|
||||
/usr/lib${LIB_SUFFIX}/ogre
|
||||
/usr/lib${LIB_SUFFIX}/OGRE
|
||||
/usr/local/lib${LIB_SUFFIX}/ogre
|
||||
/usr/local/lib${LIB_SUFFIX}/OGRE
|
||||
$ENV{HOME}/ogre
|
||||
$ENV{HOME}/OGRE
|
||||
)
|
||||
endif ()
|
||||
set(OGRE_PREFIX_PATH
|
||||
${OGRE_HOME} ${OGRE_SDK} ${ENV_OGRE_HOME} ${ENV_OGRE_SDK}
|
||||
${OGRE_PREFIX_GUESSES}
|
||||
)
|
||||
create_search_paths(OGRE)
|
||||
# If both OGRE_BUILD and OGRE_SOURCE are set, prepare to find Ogre in a build dir
|
||||
set(OGRE_PREFIX_SOURCE ${OGRE_SOURCE} ${ENV_OGRE_SOURCE})
|
||||
set(OGRE_PREFIX_BUILD ${OGRE_BUILD} ${ENV_OGRE_BUILD})
|
||||
set(OGRE_PREFIX_DEPENDENCIES_DIR ${OGRE_DEPENDENCIES_DIR} ${ENV_OGRE_DEPENDENCIES_DIR})
|
||||
if (OGRE_PREFIX_SOURCE AND OGRE_PREFIX_BUILD)
|
||||
foreach(dir ${OGRE_PREFIX_SOURCE})
|
||||
set(OGRE_INC_SEARCH_PATH ${dir}/OgreMain/include ${dir}/Dependencies/include ${dir}/iPhoneDependencies/include ${OGRE_INC_SEARCH_PATH})
|
||||
set(OGRE_LIB_SEARCH_PATH ${dir}/lib ${dir}/Dependencies/lib ${dir}/iPhoneDependencies/lib ${OGRE_LIB_SEARCH_PATH})
|
||||
set(OGRE_BIN_SEARCH_PATH ${dir}/Samples/Common/bin ${OGRE_BIN_SEARCH_PATH})
|
||||
endforeach(dir)
|
||||
foreach(dir ${OGRE_PREFIX_BUILD})
|
||||
set(OGRE_INC_SEARCH_PATH ${dir}/include ${OGRE_INC_SEARCH_PATH})
|
||||
set(OGRE_LIB_SEARCH_PATH ${dir}/lib ${OGRE_LIB_SEARCH_PATH})
|
||||
set(OGRE_BIN_SEARCH_PATH ${dir}/bin ${OGRE_BIN_SEARCH_PATH})
|
||||
set(OGRE_BIN_SEARCH_PATH ${dir}/Samples/Common/bin ${OGRE_BIN_SEARCH_PATH})
|
||||
endforeach(dir)
|
||||
|
||||
if (OGRE_PREFIX_DEPENDENCIES_DIR)
|
||||
set(OGRE_INC_SEARCH_PATH ${OGRE_PREFIX_DEPENDENCIES_DIR}/include ${OGRE_INC_SEARCH_PATH})
|
||||
set(OGRE_LIB_SEARCH_PATH ${OGRE_PREFIX_DEPENDENCIES_DIR}/lib ${OGRE_LIB_SEARCH_PATH})
|
||||
set(OGRE_BIN_SEARCH_PATH ${OGRE_PREFIX_DEPENDENCIES_DIR}/bin ${OGRE_BIN_SEARCH_PATH})
|
||||
endif()
|
||||
else()
|
||||
set(OGRE_PREFIX_SOURCE "NOTFOUND")
|
||||
set(OGRE_PREFIX_BUILD "NOTFOUND")
|
||||
endif ()
|
||||
|
||||
# redo search if any of the environmental hints changed
|
||||
set(OGRE_COMPONENTS Paging Terrain
|
||||
Plugin_BSPSceneManager Plugin_CgProgramManager Plugin_OctreeSceneManager
|
||||
Plugin_OctreeZone Plugin_PCZSceneManager Plugin_ParticleFX
|
||||
RenderSystem_Direct3D11 RenderSystem_Direct3D9 RenderSystem_GL RenderSystem_GLES RenderSystem_GLES2)
|
||||
set(OGRE_RESET_VARS
|
||||
OGRE_CONFIG_INCLUDE_DIR OGRE_INCLUDE_DIR
|
||||
OGRE_LIBRARY_FWK OGRE_LIBRARY_REL OGRE_LIBRARY_DBG
|
||||
OGRE_PLUGIN_DIR_DBG OGRE_PLUGIN_DIR_REL OGRE_MEDIA_DIR)
|
||||
foreach (comp ${OGRE_COMPONENTS})
|
||||
set(OGRE_RESET_VARS ${OGRE_RESET_VARS}
|
||||
OGRE_${comp}_INCLUDE_DIR OGRE_${comp}_LIBRARY_FWK
|
||||
OGRE_${comp}_LIBRARY_DBG OGRE_${comp}_LIBRARY_REL
|
||||
)
|
||||
endforeach (comp)
|
||||
set(OGRE_PREFIX_WATCH ${OGRE_PREFIX_PATH} ${OGRE_PREFIX_SOURCE} ${OGRE_PREFIX_BUILD})
|
||||
clear_if_changed(OGRE_PREFIX_WATCH ${OGRE_RESET_VARS})
|
||||
|
||||
# try to locate Ogre via pkg-config
|
||||
use_pkgconfig(OGRE_PKGC "OGRE${OGRE_LIB_SUFFIX}")
|
||||
|
||||
if(NOT OGRE_BUILD_PLATFORM_APPLE_IOS)
|
||||
# try to find framework on OSX
|
||||
findpkg_framework(OGRE)
|
||||
else()
|
||||
set(OGRE_LIBRARY_FWK "")
|
||||
endif()
|
||||
|
||||
# locate Ogre include files
|
||||
find_path(OGRE_CONFIG_INCLUDE_DIR NAMES OgreBuildSettings.h HINTS ${OGRE_INC_SEARCH_PATH} ${OGRE_FRAMEWORK_INCLUDES} ${OGRE_PKGC_INCLUDE_DIRS} PATH_SUFFIXES "OGRE")
|
||||
find_path(OGRE_INCLUDE_DIR NAMES OgreRoot.h HINTS ${OGRE_CONFIG_INCLUDE_DIR} ${OGRE_INC_SEARCH_PATH} ${OGRE_FRAMEWORK_INCLUDES} ${OGRE_PKGC_INCLUDE_DIRS} PATH_SUFFIXES "OGRE")
|
||||
set(OGRE_INCOMPATIBLE FALSE)
|
||||
|
||||
if (OGRE_INCLUDE_DIR)
|
||||
if (NOT OGRE_CONFIG_INCLUDE_DIR)
|
||||
set(OGRE_CONFIG_INCLUDE_DIR ${OGRE_INCLUDE_DIR})
|
||||
endif ()
|
||||
# determine Ogre version
|
||||
file(READ ${OGRE_INCLUDE_DIR}/OgrePrerequisites.h OGRE_TEMP_VERSION_CONTENT)
|
||||
get_preprocessor_entry(OGRE_TEMP_VERSION_CONTENT OGRE_VERSION_MAJOR OGRE_VERSION_MAJOR)
|
||||
get_preprocessor_entry(OGRE_TEMP_VERSION_CONTENT OGRE_VERSION_MINOR OGRE_VERSION_MINOR)
|
||||
get_preprocessor_entry(OGRE_TEMP_VERSION_CONTENT OGRE_VERSION_PATCH OGRE_VERSION_PATCH)
|
||||
get_preprocessor_entry(OGRE_TEMP_VERSION_CONTENT OGRE_VERSION_NAME OGRE_VERSION_NAME)
|
||||
set(OGRE_VERSION "${OGRE_VERSION_MAJOR}.${OGRE_VERSION_MINOR}.${OGRE_VERSION_PATCH}")
|
||||
pkg_message(OGRE "Found Ogre ${OGRE_VERSION_NAME} (${OGRE_VERSION})")
|
||||
|
||||
# determine configuration settings
|
||||
set(OGRE_CONFIG_HEADERS
|
||||
${OGRE_CONFIG_INCLUDE_DIR}/OgreBuildSettings.h
|
||||
${OGRE_CONFIG_INCLUDE_DIR}/OgreConfig.h
|
||||
)
|
||||
foreach(CFG_FILE ${OGRE_CONFIG_HEADERS})
|
||||
if (EXISTS ${CFG_FILE})
|
||||
set(OGRE_CONFIG_HEADER ${CFG_FILE})
|
||||
break()
|
||||
endif()
|
||||
endforeach()
|
||||
if (OGRE_CONFIG_HEADER)
|
||||
file(READ ${OGRE_CONFIG_HEADER} OGRE_TEMP_CONFIG_CONTENT)
|
||||
has_preprocessor_entry(OGRE_TEMP_CONFIG_CONTENT OGRE_STATIC_LIB OGRE_CONFIG_STATIC)
|
||||
get_preprocessor_entry(OGRE_TEMP_CONFIG_CONTENT OGRE_THREAD_SUPPORT OGRE_CONFIG_THREADS)
|
||||
get_preprocessor_entry(OGRE_TEMP_CONFIG_CONTENT OGRE_THREAD_PROVIDER OGRE_CONFIG_THREAD_PROVIDER)
|
||||
get_preprocessor_entry(OGRE_TEMP_CONFIG_CONTENT OGRE_NO_FREEIMAGE OGRE_CONFIG_FREEIMAGE)
|
||||
if (OGRE_CONFIG_STATIC AND OGRE_STATIC)
|
||||
elseif (OGRE_CONFIG_STATIC OR OGRE_STATIC)
|
||||
pkg_message(OGRE "Build type (static, dynamic) does not match the requested one.")
|
||||
set(OGRE_INCOMPATIBLE TRUE)
|
||||
endif ()
|
||||
else ()
|
||||
pkg_message(OGRE "Could not determine Ogre build configuration.")
|
||||
set(OGRE_INCOMPATIBLE TRUE)
|
||||
endif ()
|
||||
else ()
|
||||
set(OGRE_INCOMPATIBLE FALSE)
|
||||
endif ()
|
||||
|
||||
find_library(OGRE_LIBRARY_REL NAMES ${OGRE_LIBRARY_NAMES} HINTS ${OGRE_LIB_SEARCH_PATH} ${OGRE_PKGC_LIBRARY_DIRS} ${OGRE_FRAMEWORK_SEARCH_PATH} PATH_SUFFIXES "" "release" "relwithdebinfo" "minsizerel")
|
||||
find_library(OGRE_LIBRARY_DBG NAMES ${OGRE_LIBRARY_NAMES_DBG} HINTS ${OGRE_LIB_SEARCH_PATH} ${OGRE_PKGC_LIBRARY_DIRS} ${OGRE_FRAMEWORK_SEARCH_PATH} PATH_SUFFIXES "" "debug")
|
||||
make_library_set(OGRE_LIBRARY)
|
||||
|
||||
if(APPLE)
|
||||
set(OGRE_LIBRARY_DBG ${OGRE_LIB_SEARCH_PATH})
|
||||
endif()
|
||||
if (OGRE_INCOMPATIBLE)
|
||||
set(OGRE_LIBRARY "NOTFOUND")
|
||||
endif ()
|
||||
|
||||
set(OGRE_INCLUDE_DIR ${OGRE_CONFIG_INCLUDE_DIR} ${OGRE_INCLUDE_DIR})
|
||||
list(REMOVE_DUPLICATES OGRE_INCLUDE_DIR)
|
||||
findpkg_finish(OGRE)
|
||||
add_parent_dir(OGRE_INCLUDE_DIRS OGRE_INCLUDE_DIR)
|
||||
if (OGRE_SOURCE)
|
||||
# If working from source rather than SDK, add samples include
|
||||
set(OGRE_INCLUDE_DIRS ${OGRE_INCLUDE_DIRS} "${OGRE_SOURCE}/Samples/Common/include")
|
||||
endif()
|
||||
|
||||
mark_as_advanced(OGRE_CONFIG_INCLUDE_DIR OGRE_MEDIA_DIR OGRE_PLUGIN_DIR_REL OGRE_PLUGIN_DIR_DBG)
|
||||
|
||||
if (NOT OGRE_FOUND)
|
||||
return()
|
||||
endif ()
|
||||
|
||||
|
||||
# look for required Ogre dependencies in case of static build and/or threading
|
||||
if (OGRE_STATIC)
|
||||
set(OGRE_DEPS_FOUND TRUE)
|
||||
find_package(Cg QUIET)
|
||||
find_package(DirectX QUIET)
|
||||
find_package(FreeImage QUIET)
|
||||
find_package(Freetype QUIET)
|
||||
find_package(OpenGL QUIET)
|
||||
find_package(OpenGLES QUIET)
|
||||
find_package(OpenGLES2 QUIET)
|
||||
find_package(ZLIB QUIET)
|
||||
find_package(ZZip QUIET)
|
||||
if (UNIX AND NOT APPLE)
|
||||
find_package(X11 QUIET)
|
||||
find_library(XAW_LIBRARY NAMES Xaw Xaw7 PATHS ${DEP_LIB_SEARCH_DIR} ${X11_LIB_SEARCH_PATH})
|
||||
if (NOT XAW_LIBRARY OR NOT X11_Xt_FOUND)
|
||||
set(X11_FOUND FALSE)
|
||||
endif ()
|
||||
endif ()
|
||||
if (APPLE AND NOT OGRE_BUILD_PLATFORM_APPLE_IOS)
|
||||
find_package(Cocoa QUIET)
|
||||
find_package(Carbon QUIET)
|
||||
find_package(CoreVideo QUIET)
|
||||
if (NOT Cocoa_FOUND OR NOT Carbon_FOUND OR NOT CoreVideo_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
endif ()
|
||||
endif ()
|
||||
if (APPLE AND OGRE_BUILD_PLATFORM_APPLE_IOS)
|
||||
find_package(iPhoneSDK QUIET)
|
||||
if (NOT iPhoneSDK_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
endif ()
|
||||
endif ()
|
||||
|
||||
set(OGRE_LIBRARIES ${OGRE_LIBRARIES} ${ZZip_LIBRARIES} ${ZLIB_LIBRARIES} ${FreeImage_LIBRARIES} ${FREETYPE_LIBRARIES} )
|
||||
|
||||
if (APPLE AND NOT OGRE_BUILD_PLATFORM_APPLE_IOS)
|
||||
set(OGRE_LIBRARIES ${OGRE_LIBRARIES} ${X11_LIBRARIES} ${X11_Xt_LIBRARIES} ${XAW_LIBRARY} ${X11_Xrandr_LIB} ${Carbon_LIBRARIES} ${Cocoa_LIBRARIES})
|
||||
endif()
|
||||
|
||||
if (NOT ZLIB_FOUND OR NOT ZZip_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
endif ()
|
||||
if (NOT FreeImage_FOUND AND NOT OGRE_CONFIG_FREEIMAGE)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
endif ()
|
||||
if (NOT FREETYPE_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
endif ()
|
||||
if (UNIX AND NOT APPLE)
|
||||
if (NOT X11_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
endif ()
|
||||
endif ()
|
||||
|
||||
if (OGRE_CONFIG_THREADS)
|
||||
if (OGRE_CONFIG_THREAD_PROVIDER EQUAL 1)
|
||||
find_package(Boost COMPONENTS thread QUIET)
|
||||
if (NOT Boost_THREAD_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
else ()
|
||||
set(OGRE_LIBRARIES ${OGRE_LIBRARIES} ${Boost_LIBRARIES})
|
||||
set(OGRE_INCLUDE_DIRS ${OGRE_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS})
|
||||
endif ()
|
||||
elseif (OGRE_CONFIG_THREAD_PROVIDER EQUAL 2)
|
||||
find_package(POCO QUIET)
|
||||
if (NOT POCO_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
else ()
|
||||
set(OGRE_LIBRARIES ${OGRE_LIBRARIES} ${POCO_LIBRARIES})
|
||||
set(OGRE_INCLUDE_DIRS ${OGRE_INCLUDE_DIRS} ${POCO_INCLUDE_DIRS})
|
||||
endif ()
|
||||
elseif (OGRE_CONFIG_THREAD_PROVIDER EQUAL 3)
|
||||
find_package(TBB QUIET)
|
||||
if (NOT TBB_FOUND)
|
||||
set(OGRE_DEPS_FOUND FALSE)
|
||||
else ()
|
||||
set(OGRE_LIBRARIES ${OGRE_LIBRARIES} ${TBB_LIBRARIES})
|
||||
set(OGRE_INCLUDE_DIRS ${OGRE_INCLUDE_DIRS} ${TBB_INCLUDE_DIRS})
|
||||
endif ()
|
||||
endif ()
|
||||
endif ()
|
||||
|
||||
if (NOT OGRE_DEPS_FOUND)
|
||||
pkg_message(OGRE "Could not find all required dependencies for the Ogre package.")
|
||||
set(OGRE_FOUND FALSE)
|
||||
endif ()
|
||||
endif ()
|
||||
|
||||
if (NOT OGRE_FOUND)
|
||||
return()
|
||||
endif ()
|
||||
|
||||
|
||||
get_filename_component(OGRE_LIBRARY_DIR_REL "${OGRE_LIBRARY_REL}" PATH)
|
||||
get_filename_component(OGRE_LIBRARY_DIR_DBG "${OGRE_LIBRARY_DBG}" PATH)
|
||||
set(OGRE_LIBRARY_DIRS ${OGRE_LIBRARY_DIR_REL} ${OGRE_LIBRARY_DIR_DBG})
|
||||
|
||||
# find binaries
|
||||
if (NOT OGRE_STATIC)
|
||||
if (WIN32)
|
||||
find_file(OGRE_BINARY_REL NAMES "OgreMain.dll" HINTS ${OGRE_BIN_SEARCH_PATH}
|
||||
PATH_SUFFIXES "" release relwithdebinfo minsizerel)
|
||||
find_file(OGRE_BINARY_DBG NAMES "OgreMain_d.dll" HINTS ${OGRE_BIN_SEARCH_PATH}
|
||||
PATH_SUFFIXES "" debug )
|
||||
endif()
|
||||
mark_as_advanced(OGRE_BINARY_REL OGRE_BINARY_DBG)
|
||||
endif()
|
||||
|
||||
|
||||
#########################################################
|
||||
# Find Ogre components
|
||||
#########################################################
|
||||
|
||||
set(OGRE_COMPONENT_SEARCH_PATH_REL
|
||||
${OGRE_LIBRARY_DIR_REL}/..
|
||||
${OGRE_LIBRARY_DIR_REL}/../..
|
||||
${OGRE_BIN_SEARCH_PATH}
|
||||
)
|
||||
set(OGRE_COMPONENT_SEARCH_PATH_DBG
|
||||
${OGRE_LIBRARY_DIR_DBG}/..
|
||||
${OGRE_LIBRARY_DIR_DBG}/../..
|
||||
${OGRE_BIN_SEARCH_PATH}
|
||||
)
|
||||
|
||||
macro(ogre_find_component COMPONENT HEADER)
|
||||
findpkg_begin(OGRE_${COMPONENT})
|
||||
find_path(OGRE_${COMPONENT}_INCLUDE_DIR NAMES ${HEADER} HINTS ${OGRE_INCLUDE_DIRS} ${OGRE_PREFIX_SOURCE} PATH_SUFFIXES ${COMPONENT} OGRE/${COMPONENT} Components/${COMPONENT}/include)
|
||||
set(OGRE_${COMPONENT}_LIBRARY_NAMES "Ogre${COMPONENT}${OGRE_LIB_SUFFIX}")
|
||||
get_debug_names(OGRE_${COMPONENT}_LIBRARY_NAMES)
|
||||
find_library(OGRE_${COMPONENT}_LIBRARY_REL NAMES ${OGRE_${COMPONENT}_LIBRARY_NAMES} HINTS ${OGRE_LIBRARY_DIR_REL} PATH_SUFFIXES "" "release" "relwithdebinfo" "minsizerel")
|
||||
find_library(OGRE_${COMPONENT}_LIBRARY_DBG NAMES ${OGRE_${COMPONENT}_LIBRARY_NAMES_DBG} HINTS ${OGRE_LIBRARY_DIR_DBG} PATH_SUFFIXES "" "debug")
|
||||
make_library_set(OGRE_${COMPONENT}_LIBRARY)
|
||||
findpkg_finish(OGRE_${COMPONENT})
|
||||
if (OGRE_${COMPONENT}_FOUND)
|
||||
# find binaries
|
||||
if (NOT OGRE_STATIC)
|
||||
if (WIN32)
|
||||
find_file(OGRE_${COMPONENT}_BINARY_REL NAMES "Ogre${COMPONENT}.dll" HINTS ${OGRE_COMPONENT_SEARCH_PATH_REL} PATH_SUFFIXES "" bin bin/release bin/relwithdebinfo bin/minsizerel release)
|
||||
find_file(OGRE_${COMPONENT}_BINARY_DBG NAMES "Ogre${COMPONENT}_d.dll" HINTS ${OGRE_COMPONENT_SEARCH_PATH_DBG} PATH_SUFFIXES "" bin bin/debug debug)
|
||||
endif()
|
||||
mark_as_advanced(OGRE_${COMPONENT}_BINARY_REL OGRE_${COMPONENT}_BINARY_DBG)
|
||||
endif()
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
# look for Paging component
|
||||
ogre_find_component(Paging OgrePaging.h)
|
||||
# look for Terrain component
|
||||
ogre_find_component(Terrain OgreTerrain.h)
|
||||
# look for Property component
|
||||
ogre_find_component(Property OgreProperty.h)
|
||||
# look for RTShaderSystem component
|
||||
ogre_find_component(RTShaderSystem OgreRTShaderSystem.h)
|
||||
|
||||
|
||||
#########################################################
|
||||
# Find Ogre plugins
|
||||
#########################################################
|
||||
|
||||
macro(ogre_find_plugin PLUGIN HEADER)
|
||||
# On Unix, the plugins might have no prefix
|
||||
if (CMAKE_FIND_LIBRARY_PREFIXES)
|
||||
set(TMP_CMAKE_LIB_PREFIX ${CMAKE_FIND_LIBRARY_PREFIXES})
|
||||
set(CMAKE_FIND_LIBRARY_PREFIXES ${CMAKE_FIND_LIBRARY_PREFIXES} "")
|
||||
endif()
|
||||
|
||||
# strip RenderSystem_ or Plugin_ prefix from plugin name
|
||||
string(REPLACE "RenderSystem_" "" PLUGIN_TEMP ${PLUGIN})
|
||||
string(REPLACE "Plugin_" "" PLUGIN_NAME ${PLUGIN_TEMP})
|
||||
|
||||
# header files for plugins are not usually needed, but find them anyway if they are present
|
||||
set(OGRE_PLUGIN_PATH_SUFFIXES
|
||||
PlugIns PlugIns/${PLUGIN_NAME} Plugins Plugins/${PLUGIN_NAME} ${PLUGIN}
|
||||
RenderSystems RenderSystems/${PLUGIN_NAME} ${ARGN})
|
||||
find_path(OGRE_${PLUGIN}_INCLUDE_DIR NAMES ${HEADER}
|
||||
HINTS ${OGRE_INCLUDE_DIRS} ${OGRE_PREFIX_SOURCE}
|
||||
PATH_SUFFIXES ${OGRE_PLUGIN_PATH_SUFFIXES})
|
||||
# find link libraries for plugins
|
||||
set(OGRE_${PLUGIN}_LIBRARY_NAMES "${PLUGIN}${OGRE_LIB_SUFFIX}")
|
||||
get_debug_names(OGRE_${PLUGIN}_LIBRARY_NAMES)
|
||||
set(OGRE_${PLUGIN}_LIBRARY_FWK ${OGRE_LIBRARY_FWK})
|
||||
find_library(OGRE_${PLUGIN}_LIBRARY_REL NAMES ${OGRE_${PLUGIN}_LIBRARY_NAMES}
|
||||
HINTS ${OGRE_LIBRARY_DIRS} PATH_SUFFIXES "" OGRE opt release release/opt relwithdebinfo relwithdebinfo/opt minsizerel minsizerel/opt)
|
||||
find_library(OGRE_${PLUGIN}_LIBRARY_DBG NAMES ${OGRE_${PLUGIN}_LIBRARY_NAMES_DBG}
|
||||
HINTS ${OGRE_LIBRARY_DIRS} PATH_SUFFIXES "" OGRE opt debug debug/opt)
|
||||
make_library_set(OGRE_${PLUGIN}_LIBRARY)
|
||||
|
||||
if (OGRE_${PLUGIN}_LIBRARY OR OGRE_${PLUGIN}_INCLUDE_DIR)
|
||||
set(OGRE_${PLUGIN}_FOUND TRUE)
|
||||
if (OGRE_${PLUGIN}_INCLUDE_DIR)
|
||||
set(OGRE_${PLUGIN}_INCLUDE_DIRS ${OGRE_${PLUGIN}_INCLUDE_DIR})
|
||||
endif()
|
||||
set(OGRE_${PLUGIN}_LIBRARIES ${OGRE_${PLUGIN}_LIBRARY})
|
||||
endif ()
|
||||
|
||||
mark_as_advanced(OGRE_${PLUGIN}_INCLUDE_DIR OGRE_${PLUGIN}_LIBRARY_REL OGRE_${PLUGIN}_LIBRARY_DBG OGRE_${PLUGIN}_LIBRARY_FWK)
|
||||
|
||||
# look for plugin dirs
|
||||
if (OGRE_${PLUGIN}_FOUND)
|
||||
if (NOT OGRE_PLUGIN_DIR_REL OR NOT OGRE_PLUGIN_DIR_DBG)
|
||||
if (WIN32)
|
||||
set(OGRE_PLUGIN_SEARCH_PATH_REL
|
||||
${OGRE_LIBRARY_DIR_REL}/..
|
||||
${OGRE_LIBRARY_DIR_REL}/../..
|
||||
${OGRE_BIN_SEARCH_PATH}
|
||||
)
|
||||
set(OGRE_PLUGIN_SEARCH_PATH_DBG
|
||||
${OGRE_LIBRARY_DIR_DBG}/..
|
||||
${OGRE_LIBRARY_DIR_DBG}/../..
|
||||
${OGRE_BIN_SEARCH_PATH}
|
||||
)
|
||||
find_path(OGRE_PLUGIN_DIR_REL NAMES "${PLUGIN}.dll" HINTS ${OGRE_PLUGIN_SEARCH_PATH_REL}
|
||||
PATH_SUFFIXES "" bin bin/release bin/relwithdebinfo bin/minsizerel release)
|
||||
find_path(OGRE_PLUGIN_DIR_DBG NAMES "${PLUGIN}_d.dll" HINTS ${OGRE_PLUGIN_SEARCH_PATH_DBG}
|
||||
PATH_SUFFIXES "" bin bin/debug debug)
|
||||
elseif (UNIX)
|
||||
get_filename_component(OGRE_PLUGIN_DIR_TMP ${OGRE_${PLUGIN}_LIBRARY_REL} PATH)
|
||||
set(OGRE_PLUGIN_DIR_REL ${OGRE_PLUGIN_DIR_TMP} CACHE STRING "Ogre plugin dir (release)" FORCE)
|
||||
get_filename_component(OGRE_PLUGIN_DIR_TMP ${OGRE_${PLUGIN}_LIBRARY_DBG} PATH)
|
||||
set(OGRE_PLUGIN_DIR_DBG ${OGRE_PLUGIN_DIR_TMP} CACHE STRING "Ogre plugin dir (debug)" FORCE)
|
||||
endif ()
|
||||
endif ()
|
||||
|
||||
# find binaries
|
||||
if (NOT OGRE_STATIC)
|
||||
if (WIN32)
|
||||
find_file(OGRE_${PLUGIN}_REL NAMES "${PLUGIN}.dll" HINTS ${OGRE_PLUGIN_DIR_REL})
|
||||
find_file(OGRE_${PLUGIN}_DBG NAMES "${PLUGIN}_d.dll" HINTS ${OGRE_PLUGIN_DIR_DBG})
|
||||
endif()
|
||||
mark_as_advanced(OGRE_${PLUGIN}_REL OGRE_${PLUGIN}_DBG)
|
||||
endif()
|
||||
|
||||
endif ()
|
||||
|
||||
if (TMP_CMAKE_LIB_PREFIX)
|
||||
set(CMAKE_FIND_LIBRARY_PREFIXES ${TMP_CMAKE_LIB_PREFIX})
|
||||
endif ()
|
||||
endmacro(ogre_find_plugin)
|
||||
|
||||
ogre_find_plugin(Plugin_PCZSceneManager OgrePCZSceneManager.h PCZ PlugIns/PCZSceneManager/include)
|
||||
ogre_find_plugin(Plugin_OctreeZone OgreOctreeZone.h PCZ PlugIns/OctreeZone/include)
|
||||
ogre_find_plugin(Plugin_BSPSceneManager OgreBspSceneManager.h PlugIns/BSPSceneManager/include)
|
||||
ogre_find_plugin(Plugin_CgProgramManager OgreCgProgram.h PlugIns/CgProgramManager/include)
|
||||
ogre_find_plugin(Plugin_OctreeSceneManager OgreOctreeSceneManager.h PlugIns/OctreeSceneManager/include)
|
||||
ogre_find_plugin(Plugin_ParticleFX OgreParticleFXPrerequisites.h PlugIns/ParticleFX/include)
|
||||
ogre_find_plugin(RenderSystem_GL OgreGLRenderSystem.h RenderSystems/GL/include)
|
||||
ogre_find_plugin(RenderSystem_GLES OgreGLESRenderSystem.h RenderSystems/GLES/include)
|
||||
ogre_find_plugin(RenderSystem_GLES2 OgreGLES2RenderSystem.h RenderSystems/GLES2/include)
|
||||
ogre_find_plugin(RenderSystem_Direct3D9 OgreD3D9RenderSystem.h RenderSystems/Direct3D9/include)
|
||||
ogre_find_plugin(RenderSystem_Direct3D11 OgreD3D11RenderSystem.h RenderSystems/Direct3D11/include)
|
||||
|
||||
if (OGRE_STATIC)
|
||||
# check if dependencies for plugins are met
|
||||
if (NOT DirectX_FOUND)
|
||||
set(OGRE_RenderSystem_Direct3D9_FOUND FALSE)
|
||||
endif ()
|
||||
if (NOT DirectX_D3D11_FOUND)
|
||||
set(OGRE_RenderSystem_Direct3D11_FOUND FALSE)
|
||||
endif ()
|
||||
if (NOT OPENGL_FOUND)
|
||||
set(OGRE_RenderSystem_GL_FOUND FALSE)
|
||||
endif ()
|
||||
if (NOT OPENGLES_FOUND)
|
||||
set(OGRE_RenderSystem_GLES_FOUND FALSE)
|
||||
endif ()
|
||||
if (NOT OPENGLES2_FOUND)
|
||||
set(OGRE_RenderSystem_GLES2_FOUND FALSE)
|
||||
endif ()
|
||||
if (NOT Cg_FOUND)
|
||||
set(OGRE_Plugin_CgProgramManager_FOUND FALSE)
|
||||
endif ()
|
||||
|
||||
set(OGRE_RenderSystem_Direct3D9_LIBRARIES ${OGRE_RenderSystem_Direct3D9_LIBRARIES}
|
||||
${DirectX_LIBRARIES}
|
||||
)
|
||||
|
||||
set(OGRE_RenderSystem_Direct3D11_LIBRARIES ${OGRE_RenderSystem_Direct3D11_LIBRARIES}
|
||||
${DirectX_D3D11_LIBRARIES}
|
||||
)
|
||||
set(OGRE_RenderSystem_GL_LIBRARIES ${OGRE_RenderSystem_GL_LIBRARIES}
|
||||
${OPENGL_LIBRARIES}
|
||||
)
|
||||
set(OGRE_RenderSystem_GLES_LIBRARIES ${OGRE_RenderSystem_GLES_LIBRARIES}
|
||||
${OPENGLES_LIBRARIES}
|
||||
)
|
||||
set(OGRE_RenderSystem_GLES2_LIBRARIES ${OGRE_RenderSystem_GLES2_LIBRARIES}
|
||||
${OPENGLES2_LIBRARIES}
|
||||
)
|
||||
set(OGRE_Plugin_CgProgramManager_LIBRARIES ${OGRE_Plugin_CgProgramManager_LIBRARIES}
|
||||
${Cg_LIBRARIES}
|
||||
)
|
||||
endif ()
|
||||
|
||||
# look for the media directory
|
||||
set(OGRE_MEDIA_SEARCH_PATH
|
||||
${OGRE_SOURCE}
|
||||
${OGRE_LIBRARY_DIR_REL}/..
|
||||
${OGRE_LIBRARY_DIR_DBG}/..
|
||||
${OGRE_LIBRARY_DIR_REL}/../..
|
||||
${OGRE_LIBRARY_DIR_DBG}/../..
|
||||
${OGRE_PREFIX_SOURCE}
|
||||
)
|
||||
set(OGRE_MEDIA_SEARCH_SUFFIX
|
||||
Samples/Media
|
||||
Media
|
||||
media
|
||||
share/OGRE/media
|
||||
)
|
||||
|
||||
IF (OGRE_INCLUDE_DIR AND OGRE_LIBRARIES)
|
||||
SET(OGRE_FOUND TRUE)
|
||||
ENDIF (OGRE_INCLUDE_DIR AND OGRE_LIBRARIES)
|
||||
|
||||
IF (OGRE_FOUND)
|
||||
IF (NOT OGRE_FIND_QUIETLY)
|
||||
MESSAGE(STATUS " libraries : ${OGRE_LIBRARIES} from ${OGRE_LIB_DIR}")
|
||||
MESSAGE(STATUS " includes : ${OGRE_INCLUDE_DIR}")
|
||||
MESSAGE(STATUS " plugins : ${OGRE_PLUGIN_DIR}")
|
||||
ENDIF (NOT OGRE_FIND_QUIETLY)
|
||||
ELSE (OGRE_FOUND)
|
||||
IF (OGRE_FIND_REQUIRED)
|
||||
MESSAGE(FATAL_ERROR "Could not find OGRE")
|
||||
ENDIF (OGRE_FIND_REQUIRED)
|
||||
ENDIF (OGRE_FOUND)
|
||||
|
||||
CMAKE_POLICY(POP)
|
||||
clear_if_changed(OGRE_PREFIX_WATCH OGRE_MEDIA_DIR)
|
||||
find_path(OGRE_MEDIA_DIR NAMES packs/cubemapsJS.zip HINTS ${OGRE_MEDIA_SEARCH_PATH}
|
||||
PATHS ${OGRE_PREFIX_PATH} PATH_SUFFIXES ${OGRE_MEDIA_SEARCH_SUFFIX})
|
||||
|
||||
@ -0,0 +1,60 @@
|
||||
#-------------------------------------------------------------------
|
||||
# This file is part of the CMake build system for OGRE
|
||||
# (Object-oriented Graphics Rendering Engine)
|
||||
# For the latest info, see http://www.ogre3d.org/
|
||||
#
|
||||
# The contents of this file are placed in the public domain. Feel
|
||||
# free to make use of it in any way you like.
|
||||
#-------------------------------------------------------------------
|
||||
|
||||
macro(get_preprocessor_entry CONTENTS KEYWORD VARIABLE)
|
||||
string(REGEX MATCH
|
||||
"# *define +${KEYWORD} +((\"([^\n]*)\")|([^ \n]*))"
|
||||
PREPROC_TEMP_VAR
|
||||
${${CONTENTS}}
|
||||
)
|
||||
if (CMAKE_MATCH_3)
|
||||
set(${VARIABLE} ${CMAKE_MATCH_3})
|
||||
else ()
|
||||
set(${VARIABLE} ${CMAKE_MATCH_4})
|
||||
endif ()
|
||||
endmacro()
|
||||
|
||||
macro(has_preprocessor_entry CONTENTS KEYWORD VARIABLE)
|
||||
string(REGEX MATCH
|
||||
"\n *# *define +(${KEYWORD})"
|
||||
PREPROC_TEMP_VAR
|
||||
${${CONTENTS}}
|
||||
)
|
||||
if (CMAKE_MATCH_1)
|
||||
set(${VARIABLE} TRUE)
|
||||
else ()
|
||||
set(${VARIABLE} FALSE)
|
||||
endif ()
|
||||
endmacro()
|
||||
|
||||
macro(replace_preprocessor_entry VARIABLE KEYWORD NEW_VALUE)
|
||||
string(REGEX REPLACE
|
||||
"(// *)?# *define +${KEYWORD} +[^ \n]*"
|
||||
"#define ${KEYWORD} ${NEW_VALUE}"
|
||||
${VARIABLE}_TEMP
|
||||
${${VARIABLE}}
|
||||
)
|
||||
set(${VARIABLE} ${${VARIABLE}_TEMP})
|
||||
endmacro()
|
||||
|
||||
macro(set_preprocessor_entry VARIABLE KEYWORD ENABLE)
|
||||
if (${ENABLE})
|
||||
set(TMP_REPLACE_STR "#define ${KEYWORD}")
|
||||
else ()
|
||||
set(TMP_REPLACE_STR "// #define ${KEYWORD}")
|
||||
endif ()
|
||||
string(REGEX REPLACE
|
||||
"(// *)?# *define +${KEYWORD} *\n"
|
||||
${TMP_REPLACE_STR}
|
||||
${VARIABLE}_TEMP
|
||||
${${VARIABLE}}
|
||||
)
|
||||
set(${VARIABLE} ${${VARIABLE}_TEMP})
|
||||
endmacro()
|
||||
|
||||
@ -1,66 +0,0 @@
|
||||
project(Caelum)
|
||||
|
||||
IF(MSVC)
|
||||
add_definitions("-D_SCL_SECURE_NO_WARNINGS /wd4305 /wd4244" )
|
||||
ENDIF(MSVC)
|
||||
|
||||
ADD_DEFINITIONS(-DCAELUM_STATIC)
|
||||
INCLUDE_DIRECTORIES(
|
||||
${CMAKE_HOME_DIRECTORY}/extern/caelum/include
|
||||
${OGRE_INCLUDE_DIR}/Ogre
|
||||
)
|
||||
|
||||
file(GLOB_RECURSE CAELUM_SRC src/*)
|
||||
file(GLOB_RECURSE CAELUM_HDR include/*)
|
||||
|
||||
set(SOURCES ${CAELUM_SRC} ${CAELUM_HDR})
|
||||
add_library(caelum STATIC ${SOURCES})
|
||||
|
||||
#
|
||||
# Resources
|
||||
#
|
||||
SET(CAELUM_RES_DEST "${OpenMW_BINARY_DIR}")
|
||||
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/AtmosphereDepth.png "${CAELUM_RES_DEST}/resources/caelum/AtmosphereDepth.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumGroundFog.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumGroundFog.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumLayeredClouds.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumLayeredClouds.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumPhaseMoon.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumPhaseMoon.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumPointStarfield.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumPointStarfield.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CaelumSkyDome.cg "${CAELUM_RES_DEST}/resources/caelum/CaelumSkyDome.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/CloudCoverLookup.png "${CAELUM_RES_DEST}/resources/caelum/CloudCoverLookup.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthComposer.cg "${CAELUM_RES_DEST}/resources/caelum/DepthComposer.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthComposer.compositor "${CAELUM_RES_DEST}/resources/caelum/DepthComposer.compositor" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthComposer.material "${CAELUM_RES_DEST}/resources/caelum/DepthComposer.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/DepthRender.program "${CAELUM_RES_DEST}/resources/caelum/DepthRender.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/EarthClearSky2.png "${CAELUM_RES_DEST}/resources/caelum/EarthClearSky2.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/GroundFog.material "${CAELUM_RES_DEST}/resources/caelum/GroundFog.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/GroundFog.program "${CAELUM_RES_DEST}/resources/caelum/GroundFog.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Haze.program "${CAELUM_RES_DEST}/resources/caelum/Haze.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/LayeredClouds.material "${CAELUM_RES_DEST}/resources/caelum/LayeredClouds.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/MinimalCompositorVP.cg "${CAELUM_RES_DEST}/resources/caelum/MinimalCompositorVP.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/MinimalCompositorVP.program "${CAELUM_RES_DEST}/resources/caelum/MinimalCompositorVP.program" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/moon.material "${CAELUM_RES_DEST}/resources/caelum/moon.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/moon_disc.dds "${CAELUM_RES_DEST}/resources/caelum/moon_disc.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise1.dds "${CAELUM_RES_DEST}/resources/caelum/noise1.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise2.dds "${CAELUM_RES_DEST}/resources/caelum/noise2.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise3.dds "${CAELUM_RES_DEST}/resources/caelum/noise3.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/noise4.dds "${CAELUM_RES_DEST}/resources/caelum/noise4.dds" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/PointStarfield.material "${CAELUM_RES_DEST}/resources/caelum/PointStarfield.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Precipitation.cg "${CAELUM_RES_DEST}/resources/caelum/Precipitation.cg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Precipitation.compositor "${CAELUM_RES_DEST}/resources/caelum/Precipitation.compositor" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Precipitation.material "${CAELUM_RES_DEST}/resources/caelum/Precipitation.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_drizzle.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_drizzle.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_hail.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_hail.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_icecrystals.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_icecrystals.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_icepellets.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_icepellets.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_rain.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_rain.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_smallhail.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_smallhail.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_snow.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_snow.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/precipitation_snowgrains.png "${CAELUM_RES_DEST}/resources/caelum/precipitation_snowgrains.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/SkyDome.material "${CAELUM_RES_DEST}/resources/caelum/SkyDome.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/sphere.mesh "${CAELUM_RES_DEST}/resources/caelum/sphere.mesh" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Starfield.jpg "${CAELUM_RES_DEST}/resources/caelum/Starfield.jpg" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Starfield.material "${CAELUM_RES_DEST}/resources/caelum/Starfield.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/Sun.material "${CAELUM_RES_DEST}/resources/caelum/Sun.material" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/SunGradient.png "${CAELUM_RES_DEST}/resources/caelum/SunGradient.png" COPYONLY)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/sun_disc.png "${CAELUM_RES_DEST}/resources/caelum/sun_disc.png" COPYONLY)
|
||||
@ -1,228 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__ASTRONOMY_H
|
||||
#define CAELUM__ASTRONOMY_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Static class with astronomy routines.
|
||||
* This class contains various astronomical routines useful in Caelum.
|
||||
*
|
||||
* Most of the formulas are from http://stjarnhimlen.se/comp/ppcomp.html
|
||||
* That site contains much more than was implemented here; it has code
|
||||
* for determining the positions of all the planets. Only the sun and
|
||||
* moon are actually useful for caelum.
|
||||
*
|
||||
* The formulas are isolated here in pure procedural code for easier
|
||||
* testing (Tests are done as assertions in the demo).
|
||||
*
|
||||
* Precision is vital here, so this class uses Caelum::LongReal(double)
|
||||
* instead of Ogre::Real(float) for precission. All angles are in degrees
|
||||
* unless otherwise mentioned. Ogre::Degree and Ogre::Radian use
|
||||
* Ogre::Real and should be avoided here.
|
||||
*/
|
||||
class CAELUM_EXPORT Astronomy
|
||||
{
|
||||
private:
|
||||
Astronomy() {}
|
||||
|
||||
static const LongReal PI;
|
||||
|
||||
/** Normalize an angle to the 0, 360 range.
|
||||
* @param x The angle to normalize
|
||||
*/
|
||||
static LongReal normalizeDegrees (LongReal x);
|
||||
|
||||
/// Convert radians to degrees.
|
||||
static LongReal radToDeg (LongReal x);
|
||||
|
||||
/// Convert degrees to radians.
|
||||
static LongReal degToRad (LongReal x);
|
||||
|
||||
static LongReal sinDeg (LongReal x);
|
||||
static LongReal cosDeg (LongReal x);
|
||||
static LongReal atan2Deg (LongReal y, LongReal x);
|
||||
|
||||
public:
|
||||
/// January 1, 2000, noon
|
||||
static const LongReal J2000;
|
||||
|
||||
/** Convert from ecliptic to ecuatorial spherical coordinates, in radians.
|
||||
* @param lon Ecliptic longitude
|
||||
* @param lat Ecliptic latitude
|
||||
* @param rasc Right ascension
|
||||
* @param decl Declination
|
||||
* @warning: This function works in radians.
|
||||
*/
|
||||
static void convertEclipticToEquatorialRad (
|
||||
LongReal lon, LongReal lat,
|
||||
LongReal& rasc, LongReal& decl);
|
||||
|
||||
static void convertRectangularToSpherical (
|
||||
LongReal x, LongReal y, LongReal z,
|
||||
LongReal &rasc, LongReal &decl, LongReal &dist);
|
||||
|
||||
static void convertSphericalToRectangular (
|
||||
LongReal rasc, LongReal decl, LongReal dist,
|
||||
LongReal &x, LongReal &y, LongReal &z);
|
||||
|
||||
/** Convert from equatorial to horizontal coordinates.
|
||||
* This function converts from angles relative to the earth's equator
|
||||
* to angle relative to the horizon at a given point.
|
||||
* @param jday Astronomical time as julian day.
|
||||
* @param longitude Observer's longitude in degrees east.
|
||||
* @param latitude Observer's latitude in degrees north.
|
||||
* @param rasc Object's right ascension.
|
||||
* @param decl Object's declination.
|
||||
* @param azimuth Object's azimuth (clockwise degrees from true north).
|
||||
* @param altitude Object's altitude (degrees above the horizon).
|
||||
*/
|
||||
static void convertEquatorialToHorizontal (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal rasc, LongReal decl,
|
||||
LongReal &azimuth, LongReal &altitude);
|
||||
|
||||
/** Get the sun's position in the sky in, relative to the horizon.
|
||||
* @param jday Astronomical time as julian day.
|
||||
* @param longitude Observer longitude
|
||||
* @param latitude Observer latitude
|
||||
* @param azimuth Astronomical azimuth, measured clockwise from North = 0.
|
||||
* @param altitude Astronomical altitude, elevation above the horizon.
|
||||
*/
|
||||
static void getHorizontalSunPosition (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal &azimuth, LongReal &altitude);
|
||||
|
||||
static void getHorizontalSunPosition (
|
||||
LongReal jday,
|
||||
Ogre::Degree longitude, Ogre::Degree latitude,
|
||||
Ogre::Degree &azimuth, Ogre::Degree &altitude);
|
||||
|
||||
/// Gets the moon position at a specific time in ecliptic coordinates
|
||||
/// @param lon: Ecliptic longitude, in radians.
|
||||
/// @param lat: Ecliptic latitude, in radians.
|
||||
static void getEclipticMoonPositionRad (
|
||||
LongReal jday,
|
||||
LongReal &lon,
|
||||
LongReal &lat);
|
||||
|
||||
static void getHorizontalMoonPosition (
|
||||
LongReal jday,
|
||||
LongReal longitude, LongReal latitude,
|
||||
LongReal &azimuth, LongReal &altitude);
|
||||
static void getHorizontalMoonPosition (
|
||||
LongReal jday,
|
||||
Ogre::Degree longitude, Ogre::Degree latitude,
|
||||
Ogre::Degree &azimuth, Ogre::Degree &altitude);
|
||||
|
||||
/** Get astronomical julian day from normal gregorian calendar.
|
||||
* From wikipedia: the integer number of days that have elapsed
|
||||
* since the initial epoch defined as
|
||||
* noon Universal Time (UT) Monday, January 1, 4713 BC
|
||||
* @note this is the time at noon, not midnight.
|
||||
*/
|
||||
static int getJulianDayFromGregorianDate (
|
||||
int year, int month, int day);
|
||||
|
||||
/** Get astronomical julian day from normal gregorian calendar.
|
||||
* Calculate julian day from a day in the normal gregorian calendar.
|
||||
* Time should be given as UTC.
|
||||
* @see http://en.wikipedia.org/wiki/Julian_day
|
||||
*/
|
||||
static LongReal getJulianDayFromGregorianDateTime (
|
||||
int year, int month, int day,
|
||||
int hour, int minute, LongReal second);
|
||||
|
||||
/** Get astronomical julian day from normal gregorian calendar.
|
||||
* @see above (I don't know the proper doxygen syntax).
|
||||
*/
|
||||
static LongReal getJulianDayFromGregorianDateTime (
|
||||
int year, int month, int day,
|
||||
LongReal secondsFromMidnight);
|
||||
|
||||
/// Get gregorian date from integer julian day.
|
||||
static void getGregorianDateFromJulianDay (
|
||||
int julianDay, int &year, int &month, int &day);
|
||||
|
||||
/// Get gregorian date time from floating point julian day.
|
||||
static void getGregorianDateTimeFromJulianDay (
|
||||
LongReal julianDay, int &year, int &month, int &day,
|
||||
int &hour, int &minute, LongReal &second);
|
||||
|
||||
/// Get gregorian date from floating point julian day.
|
||||
static void getGregorianDateFromJulianDay (
|
||||
LongReal julianDay, int &year, int &month, int &day);
|
||||
|
||||
/** Enter high-precission floating-point mode.
|
||||
*
|
||||
* By default Direct3D decreases the precission of ALL floating
|
||||
* point calculations, enough to stop Caelum's astronomy routines
|
||||
* from working correctly.
|
||||
*
|
||||
* To trigger this behaviour in a standard ogre demo select the
|
||||
* Direct3D render system and set "Floating-point mode" to
|
||||
* "Fastest". Otherwise it's not a problem.
|
||||
*
|
||||
* It can be fixed by changing the precission only inside caelum's
|
||||
* astronomy routines using the _controlfp function. This only works
|
||||
* for MSVC on WIN32; This is a no-op on other compilers.
|
||||
*
|
||||
* @note: Must be paired with restoreFloatingPointMode.
|
||||
* @return Value to pass to restoreFloatingModeMode.
|
||||
*/
|
||||
static int enterHighPrecissionFloatingPointMode ();
|
||||
|
||||
/** Restore old floating point precission.
|
||||
* @see enterHighPrecissionFloatingPointMode.
|
||||
*/
|
||||
static void restoreFloatingPointMode (int oldMode);
|
||||
};
|
||||
|
||||
/** Dummy class to increase floting point precission in a block
|
||||
* This class will raise precission in the ctor and restore it
|
||||
* in the destructor. During it's lifetime floating-point
|
||||
* precission will be increased.
|
||||
*
|
||||
* To use this class just create a instance on the stack at the start of a block.
|
||||
*
|
||||
* @see Astronomy::enterHighPrecissionFloatingPointMode
|
||||
*/
|
||||
class CAELUM_EXPORT ScopedHighPrecissionFloatSwitch
|
||||
{
|
||||
private:
|
||||
int mOldFpMode;
|
||||
|
||||
public:
|
||||
inline ScopedHighPrecissionFloatSwitch() {
|
||||
mOldFpMode = Astronomy::enterHighPrecissionFloatingPointMode ();
|
||||
}
|
||||
|
||||
inline ~ScopedHighPrecissionFloatSwitch() {
|
||||
Astronomy::restoreFloatingPointMode (mOldFpMode);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__ASTRONOMY_H
|
||||
@ -1,44 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM_H
|
||||
#define CAELUM_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CaelumScriptTranslator.h"
|
||||
#include "TypeDescriptor.h"
|
||||
#include "CaelumPlugin.h"
|
||||
#include "CaelumExceptions.h"
|
||||
#include "CaelumSystem.h"
|
||||
#include "CameraBoundElement.h"
|
||||
#include "SkyDome.h"
|
||||
#include "Sun.h"
|
||||
#include "Moon.h"
|
||||
#include "UniversalClock.h"
|
||||
#include "Astronomy.h"
|
||||
#include "CloudSystem.h"
|
||||
#include "PrecipitationController.h"
|
||||
#include "FlatCloudLayer.h"
|
||||
#include "ImageStarfield.h"
|
||||
#include "PointStarfield.h"
|
||||
#include "GroundFog.h"
|
||||
#include "DepthComposer.h"
|
||||
|
||||
#endif // CAELUM_H
|
||||
@ -1,54 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_EXCEPTIONS_H
|
||||
#define CAELUM__CAELUM_EXCEPTIONS_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Exception class for unsupported features.
|
||||
* This is frequently thrown if a certain required material does not load;
|
||||
* most likely because the hardware does not support the required shaders.
|
||||
*/
|
||||
class CAELUM_EXPORT UnsupportedException : public Ogre::Exception
|
||||
{
|
||||
public:
|
||||
/// Constructor.
|
||||
UnsupportedException
|
||||
(
|
||||
int number,
|
||||
const Ogre::String &description,
|
||||
const Ogre::String &source,
|
||||
const char *file,
|
||||
long line
|
||||
):
|
||||
Ogre::Exception (number, description, source, "UnsupportedException", file, line)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
#define CAELUM_THROW_UNSUPPORTED_EXCEPTION(desc, src) \
|
||||
throw UnsupportedException(-1, (desc), (src), __FILE__, __LINE__);
|
||||
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAELUM_EXCEPTIONS_H
|
||||
@ -1,97 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_PLUGIN_H
|
||||
#define CAELUM__CAELUM_PLUGIN_H
|
||||
|
||||
#include "CaelumPrerequisites.h"
|
||||
#include "CaelumScriptTranslator.h"
|
||||
#include "TypeDescriptor.h"
|
||||
#include "OgrePlugin.h"
|
||||
|
||||
namespace Caelum
|
||||
{
|
||||
/** Implement an Ogre::Plugin for Caelum.
|
||||
*
|
||||
* Ogre plugins are usually loaded from config files and they register
|
||||
* various stuff in ogre managers. But you can also just link to the
|
||||
* library normally and call install functions manually.
|
||||
*/
|
||||
class CAELUM_EXPORT CaelumPlugin: public Ogre::Singleton<CaelumPlugin>, public Ogre::Plugin
|
||||
{
|
||||
public:
|
||||
/// Get reference to singleton instance; or crash if N/A.
|
||||
static CaelumPlugin& getSingleton(void);
|
||||
/// Get pointer to singleton instance; or pointer if N/A.
|
||||
static CaelumPlugin* getSingletonPtr(void);
|
||||
|
||||
CaelumPlugin();
|
||||
~CaelumPlugin();
|
||||
|
||||
virtual void install ();
|
||||
virtual void initialise ();
|
||||
virtual void shutdown ();
|
||||
virtual void uninstall ();
|
||||
|
||||
static const Ogre::String CAELUM_PLUGIN_NAME;
|
||||
virtual const String& getName () const;
|
||||
|
||||
// Determine if the plugin was installed (if install was called).
|
||||
inline bool isInstalled () const { return mIsInstalled; }
|
||||
|
||||
private:
|
||||
bool mIsInstalled;
|
||||
|
||||
#if CAELUM_TYPE_DESCRIPTORS
|
||||
public:
|
||||
/// Get default type descriptor data for caelum components.
|
||||
CaelumDefaultTypeDescriptorData* getTypeDescriptorData () { return &mTypeDescriptorData; }
|
||||
|
||||
private:
|
||||
CaelumDefaultTypeDescriptorData mTypeDescriptorData;
|
||||
#endif
|
||||
|
||||
#if CAELUM_SCRIPT_SUPPORT
|
||||
public:
|
||||
/** Load CaelumSystem and it's components from a script file.
|
||||
* @param sys Target CaelumSystem.
|
||||
* This is cleared using CaelumSystem::clear before loading.
|
||||
* If scripting data is not found then this is not modified.
|
||||
* @param objectName Name of caelum_sky_system from *.os file.
|
||||
* @param scriptFileGroup The group to search in (unused in Ogre 1.6)
|
||||
*/
|
||||
void loadCaelumSystemFromScript (
|
||||
CaelumSystem* sys,
|
||||
const Ogre::String& objectName,
|
||||
const Ogre::String& scriptFileGroup = Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME
|
||||
);
|
||||
|
||||
/// @see PropScriptResourceManager
|
||||
PropScriptResourceManager* getPropScriptResourceManager () { return &mPropScriptResourceManager; }
|
||||
CaelumScriptTranslatorManager* getScriptTranslatorManager () { return &mScriptTranslatorManager; }
|
||||
|
||||
private:
|
||||
PropScriptResourceManager mPropScriptResourceManager;
|
||||
CaelumScriptTranslatorManager mScriptTranslatorManager;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAELUM_PLUGIN_H
|
||||
@ -1,25 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2007 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include "Ogre/Ogre.h"
|
||||
#else
|
||||
#include "Ogre.h"
|
||||
#endif
|
||||
@ -1,180 +0,0 @@
|
||||
/*
|
||||
This file is part of Caelum.
|
||||
See http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
|
||||
Copyright (c) 2006-2008 Caelum team. See Contributors.txt for details.
|
||||
|
||||
Caelum is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
Caelum is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with Caelum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CAELUM__CAELUM_PREREQUISITES_H
|
||||
#define CAELUM__CAELUM_PREREQUISITES_H
|
||||
|
||||
// Include external headers
|
||||
#ifdef __APPLE__
|
||||
#include "Ogre/Ogre.h"
|
||||
#else
|
||||
#include "Ogre.h"
|
||||
#endif
|
||||
|
||||
#include <memory>
|
||||
|
||||
// Define the dll export qualifier if compiling for Windows
|
||||
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
|
||||
#ifdef CAELUM_STATIC
|
||||
// Don't use dll export qualifier when built as a static lib
|
||||
#define CAELUM_EXPORT
|
||||
#elif CAELUM_LIB
|
||||
#define CAELUM_EXPORT __declspec (dllexport)
|
||||
#else
|
||||
#ifdef __MINGW32__
|
||||
#define CAELUM_EXPORT
|
||||
#else
|
||||
#define CAELUM_EXPORT __declspec (dllimport)
|
||||
#endif
|
||||
#endif
|
||||
#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
|
||||
#define CAELUM_EXPORT __attribute__ ((visibility("default")))
|
||||
#else
|
||||
#define CAELUM_EXPORT
|
||||
#endif
|
||||
|
||||
// Define the version code
|
||||
#define CAELUM_VERSION_MAIN 0
|
||||
#define CAELUM_VERSION_SEC 5
|
||||
#define CAELUM_VERSION_TER 0
|
||||
#define CAELUM_VERSION = (CAELUM_VERSION_MAIN << 16) | (CAELUM_VERSION_SEC << 8) | CAELUM_VERSION_TER
|
||||
|
||||
// By default only compile type descriptors for scripting.
|
||||
#ifndef CAELUM_TYPE_DESCRIPTORS
|
||||
#if (OGRE_VERSION >= 0x00010600) && OGRE_USE_NEW_COMPILERS
|
||||
#define CAELUM_TYPE_DESCRIPTORS 1
|
||||
#else
|
||||
#define CAELUM_TYPE_DESCRIPTORS 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Scripting support requires Ogre 1.6
|
||||
// Can be also configured on compiler command line
|
||||
#ifndef CAELUM_SCRIPT_SUPPORT
|
||||
#if (OGRE_VERSION >= 0x00010600) && OGRE_USE_NEW_COMPILERS
|
||||
#define CAELUM_SCRIPT_SUPPORT 1
|
||||
#else
|
||||
#define CAELUM_SCRIPT_SUPPORT 0
|
||||
#endif
|
||||
#else
|
||||
#if !(OGRE_VERSION > 0x00010600)
|
||||
#error "Caelum script support requires Ogre 1.6."
|
||||
#endif
|
||||
#if !(OGRE_USE_NEW_COMPILERS)
|
||||
#error "Caelum script support requires Ogre 1.6 with OGRE_USE_NEW_COMPILERS."
|
||||
#endif
|
||||
#if !(CAELUM_TYPE_DESCRIPTORS)
|
||||
#error "Caelum script support also requires type descriptors."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/// @file
|
||||
|
||||
/** @mainpage
|
||||
*
|
||||
* %Caelum is an Ogre add-on for atmospheric rendering. It is composed of a
|
||||
* number of small mostly self-contained components and a big
|
||||
* Caelum::CaelumSystem class which ties them all together in an easy-to-use
|
||||
* way.
|
||||
*
|
||||
* More information is available on the wiki page:
|
||||
* http://www.ogre3d.org/wiki/index.php/Caelum
|
||||
*
|
||||
* You can discuss and report issues in the forum:
|
||||
* http://www.ogre3d.org/addonforums/viewforum.php?f=21
|
||||
*/
|
||||
|
||||
/** Caelum namespace
|
||||
*
|
||||
* All of %Caelum is inside this namespace (except for macros).
|
||||
*
|
||||
* @note: This was caelum with a lowercase 'c' in version 0.3
|
||||
*/
|
||||
namespace Caelum
|
||||
{
|
||||
// Caelum needs a lot of precission for astronomical calculations.
|
||||
// Very few calculations use it, and the precission IS required.
|
||||
typedef double LongReal;
|
||||
|
||||
// Use some ogre types.
|
||||
using Ogre::uint8;
|
||||
using Ogre::uint16;
|
||||
using Ogre::ushort;
|
||||
using Ogre::uint32;
|
||||
using Ogre::uint;
|
||||
|
||||
using Ogre::Real;
|
||||
using Ogre::String;
|
||||
|
||||
/// Resource group name for caelum resources.
|
||||
static const String RESOURCE_GROUP_NAME = "Caelum";
|
||||
|
||||
// Render group for caelum stuff
|
||||
// It's best to have them all together
|
||||
enum CaelumRenderQueueGroupId
|
||||
{
|
||||
CAELUM_RENDER_QUEUE_STARFIELD = Ogre::RENDER_QUEUE_SKIES_EARLY + 0,
|
||||
CAELUM_RENDER_QUEUE_MOON_BACKGROUND = Ogre::RENDER_QUEUE_SKIES_EARLY + 1,
|
||||
CAELUM_RENDER_QUEUE_SKYDOME = Ogre::RENDER_QUEUE_SKIES_EARLY + 2,
|
||||
CAELUM_RENDER_QUEUE_MOON = Ogre::RENDER_QUEUE_SKIES_EARLY + 3,
|
||||
CAELUM_RENDER_QUEUE_SUN = Ogre::RENDER_QUEUE_SKIES_EARLY + 4,
|
||||
CAELUM_RENDER_QUEUE_CLOUDS = Ogre::RENDER_QUEUE_SKIES_EARLY + 5,
|
||||
CAELUM_RENDER_QUEUE_GROUND_FOG = Ogre::RENDER_QUEUE_SKIES_EARLY + 6,
|
||||
};
|
||||
|
||||
// Forward declarations
|
||||
class UniversalClock;
|
||||
class SkyDome;
|
||||
class BaseSkyLight;
|
||||
class Moon;
|
||||
class SphereSun;
|
||||
class SpriteSun;
|
||||
class ImageStarfield;
|
||||
class PointStarfield;
|
||||
class CloudSystem;
|
||||
class CaelumSystem;
|
||||
class FlatCloudLayer;
|
||||
class PrecipitationController;
|
||||
class PrecipitationInstance;
|
||||
class GroundFog;
|
||||
class DepthComposer;
|
||||
class DepthComposerInstance;
|
||||
class DepthRenderer;
|
||||
}
|
||||
|
||||
namespace Ogre
|
||||
{
|
||||
#if OGRE_VERSION <= 0x010602
|
||||
// Write an Ogre::Degree to a stream.
|
||||
//
|
||||
// Ogre::Any requires that the wrapped type can be written to a stream;
|
||||
// otherwise it will fail on instantation. This function was placed here
|
||||
// so it's available everywhere. This can't be placed in namespace Caelum.
|
||||
//
|
||||
// Ogre 1.6.3 and up already include this operator; so it's ifdefed out.
|
||||
//
|
||||
// This function is never actually used; the output does not matter.
|
||||
inline std::ostream& operator << (std::ostream& out, Ogre::Degree deg) {
|
||||
return out << deg.valueDegrees();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // CAELUM__CAELUM_PREREQUISITES_H
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue